shill: Convert code to use the newest version of libchrome.

The biggest change is a switch from using the deprecated
Task and CallbackN mechanisms to using the new Callback
mechanism.

Note: Original CL was https://gerrit.chromium.org/gerrit/16156.
This is logically another patch to that CL, but since the
latter was already merged, and is considered closed by
Gerrit, it's necessary to create a new CL.

BUG=chromium-os:15330
TEST=Build shill and run it on a zgb with a modem. Build and
run unit tests.
CQ-DEPEND=I37628863370323d30cac493764ea28f8ffd42637

Change-Id: I3ae78a3aa44ec167b79f2170d07650ece888254f
Reviewed-on: https://gerrit.chromium.org/gerrit/18030
Reviewed-by: Eric Shienbrood <ers@chromium.org>
Tested-by: Eric Shienbrood <ers@chromium.org>
Commit-Ready: Eric Shienbrood <ers@chromium.org>
diff --git a/http_proxy_unittest.cc b/http_proxy_unittest.cc
index 5318b0b..ba46b0e 100644
--- a/http_proxy_unittest.cc
+++ b/http_proxy_unittest.cc
@@ -88,6 +88,10 @@
   return ip_address.Equals(arg);
 }
 
+MATCHER_P(CallbackEq, callback, "") {
+  return arg.Equals(callback);
+}
+
 class HTTPProxyTest : public Test {
  public:
   HTTPProxyTest()
@@ -165,7 +169,7 @@
     EXPECT_TRUE(proxy_.client_version_.empty());
     EXPECT_EQ(HTTPProxy::kDefaultServerPort, proxy_.server_port_);
     EXPECT_EQ(-1, proxy_.server_socket_);
-    EXPECT_FALSE(proxy_.idle_timeout_);
+    EXPECT_TRUE(proxy_.idle_timeout_.IsCancelled());
     EXPECT_TRUE(proxy_.client_headers_.empty());
     EXPECT_TRUE(proxy_.server_hostname_.empty());
     EXPECT_TRUE(proxy_.client_data_.IsEmpty());
@@ -199,9 +203,10 @@
         .WillOnce(Return(0));
     EXPECT_CALL(sockets(), Listen(kProxyFD, _))
         .WillOnce(Return(0));
-    EXPECT_CALL(dispatcher_, CreateReadyHandler(kProxyFD,
-                                                IOHandler::kModeInput,
-                                                proxy_.accept_callback_.get()))
+    EXPECT_CALL(dispatcher_,
+                CreateReadyHandler(kProxyFD,
+                                   IOHandler::kModeInput,
+                                   CallbackEq(proxy_.accept_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
   }
   void ExpectStop() {
@@ -223,7 +228,8 @@
     EXPECT_CALL(sockets(), SetNonBlocking(fd))
         .WillOnce(Return(0));
     EXPECT_CALL(dispatcher(),
-                CreateInputHandler(fd, proxy_.read_client_callback_.get()))
+                CreateInputHandler(fd,
+                                   CallbackEq(proxy_.read_client_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
     ExpectTransactionTimeout();
     ExpectClientHeaderTimeout();
@@ -290,7 +296,7 @@
     EXPECT_CALL(dispatcher(),
                 CreateReadyHandler(kClientFD,
                                    IOHandler::kModeOutput,
-                                   proxy_.write_client_callback_.get()))
+                                   CallbackEq(proxy_.write_client_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
   }
   void ExpectClientResult() {
@@ -300,7 +306,7 @@
   void ExpectServerInput() {
     EXPECT_CALL(dispatcher(),
                 CreateInputHandler(kServerFD,
-                                   proxy_.read_server_callback_.get()))
+                                   CallbackEq(proxy_.read_server_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
     ExpectInputTimeout();
   }
@@ -308,15 +314,14 @@
     EXPECT_CALL(dispatcher(),
                 CreateReadyHandler(kServerFD,
                                    IOHandler::kModeOutput,
-                                   proxy_.write_server_callback_.get()))
+                                   CallbackEq(proxy_.write_server_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
     ExpectInputTimeout();
   }
   void ExpectRepeatedServerOutput() {
     EXPECT_CALL(dispatcher(),
-                CreateReadyHandler(kServerFD,
-                                   IOHandler::kModeOutput,
-                                   proxy_.write_server_callback_.get()))
+                CreateReadyHandler(kServerFD, IOHandler::kModeOutput,
+                                   CallbackEq(proxy_.write_server_callback_)))
         .WillOnce(ReturnNew<IOHandler>());
     ExpectRepeatedInputTimeout();
   }