base::Bind: Convert Tasks in ipc_sync_channel_unittest.cc.

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
@@ skipping 1014 matching lines @@
 // Crashes flakily, http://crbug.com/70075.
 TEST_F(IPCSyncChannelTest, DISABLED_SendWithTimeoutMixedOKAndTimeout) {
   SendWithTimeoutMixedOKAndTimeout(false);
   SendWithTimeoutMixedOKAndTimeout(true);
 }
 
 //------------------------------------------------------------------------------
 
 namespace {
 
-class NestedTask : public Task {
- public:
-  explicit NestedTask(Worker* server) : server_(server) {}
-  void Run() {
-    // Sleep a bit so that we wake up after the reply has been received.
-    base::PlatformThread::Sleep(250);
-    server_->SendAnswerToLife(true, base::kNoTimeout, true);
-  }
+void NestedCallback(Worker* server) {
+  // Sleep a bit so that we wake up after the reply has been received.
+  base::PlatformThread::Sleep(250);
+  server->SendAnswerToLife(true, base::kNoTimeout, true);
+}
 
-  Worker* server_;
-};
+bool timeout_occurred = false;
 
-static bool timeout_occured = false;
-
-class TimeoutTask : public Task {
- public:
-  void Run() {
-    timeout_occured = true;
-  }
-};
+void TimeoutCallback() {
+  timeout_occurred = true;
+}
 
 class DoneEventRaceServer : public Worker {
  public:
   DoneEventRaceServer()
       : Worker(Channel::MODE_SERVER, "done_event_race_server") { }
 
   void Run() {
-    MessageLoop::current()->PostTask(FROM_HERE, new NestedTask(this));
-    MessageLoop::current()->PostDelayedTask(FROM_HERE, new TimeoutTask(), 9000);
+    MessageLoop::current()->PostTask(FROM_HERE,
+                                     base::Bind(&NestedCallback, this));
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&TimeoutCallback), 9000);
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
     SendAnswerToLife(true, 10000, true);
-    DCHECK(!timeout_occured);
+    DCHECK(!timeout_occurred);
     Done();
   }
 };
 
 }  // namespace
 
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
 TEST_F(IPCSyncChannelTest, DoneEventRace) {
@@ skipping 256 matching lines @@
   std::vector<Worker*> workers;
   workers.push_back(new NonRestrictedDispatchServer);
   workers.push_back(server);
   workers.push_back(
       new RestrictedDispatchClient(&sent_ping_event, server, &success));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }
 
 }  // namespace IPC