base::Bind: Low-hanging fruit conversions of NewRunnableFunction.

chrome_frame/vtable_patch_manager_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.
 
 #include "chrome_frame/vtable_patch_manager.h"
 
 #include <unknwn.h>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/win/scoped_handle.h"
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
 
 namespace {
 // GMock names we use.
 using testing::_;
 using testing::Return;
@@ skipping 191 matching lines @@
   // lock is held.
   base::Thread background("Background Test Thread");
 
   EXPECT_TRUE(background.Start());
   base::win::ScopedHandle event(::CreateEvent(NULL, TRUE, FALSE, NULL));
 
   // Grab the patch lock.
   vtable_patch::patch_lock_.Acquire();
 
   // Instruct the background thread to patch factory_.
-  background.message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(&vtable_patch::PatchInterfaceMethods,
-                          &factory_,
-                          &IClassFactory_PatchInfo[0]));
+  background.message_loop()->PostTask(
+      FROM_HERE,
+      base::IgnoreReturn<HRESULT>(
+          base::Bind(&vtable_patch::PatchInterfaceMethods, &factory_,
+                     &IClassFactory_PatchInfo[0])));
 
   // And subsequently to signal the event. Neither of these actions should
   // occur until we've released the patch lock.
-  background.message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(::SetEvent, event.Get()));
+  background.message_loop()->PostTask(
+      FROM_HERE, base::IgnoreReturn<BOOL>(base::Bind(::SetEvent, event.Get())));
 
   // Wait for a little while, to give the background thread time to process.
   // We expect this wait to time out, as the background thread should end up
   // blocking on the patch lock.
   EXPECT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(event.Get(), 50));
 
   // Verify that patching did not take place yet.
   EXPECT_CALL(factory_, LockServer(TRUE))
       .WillOnce(Return(S_FALSE));
   EXPECT_EQ(S_FALSE, factory_.LockServer(TRUE));
@@ skipping 12 matching lines @@
       .WillOnce(Return(S_FALSE));
   EXPECT_EQ(S_FALSE, factory_.LockServer(TRUE));
 
   // Same deal for unpatching.
   ::ResetEvent(event.Get());
 
   // Grab the patch lock.
   vtable_patch::patch_lock_.Acquire();
 
   // Instruct the background thread to unpatch.
-  background.message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(&vtable_patch::UnpatchInterfaceMethods,
-                          &IClassFactory_PatchInfo[0]));
+  background.message_loop()->PostTask(
+      FROM_HERE,
+      base::IgnoreReturn<HRESULT>(
+          base::Bind(&vtable_patch::UnpatchInterfaceMethods,
+                     &IClassFactory_PatchInfo[0])));
 
   // And subsequently to signal the event. Neither of these actions should
   // occur until we've released the patch lock.
-  background.message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(::SetEvent, event.Get()));
+  background.message_loop()->PostTask(
+      FROM_HERE, base::IgnoreReturn<BOOL>(base::Bind(::SetEvent, event.Get())));
 
   // Wait for a little while, to give the background thread time to process.
   // We expect this wait to time out, as the background thread should end up
   // blocking on the patch lock.
   EXPECT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(event.Get(), 50));
 
   // We should still be patched.
   EXPECT_CALL(factory_, LockServer(TRUE))
       .Times(0);
   EXPECT_CALL(*this, LockServerPatch(_, &factory_, TRUE))
       .WillOnce(Return(S_FALSE));
   EXPECT_EQ(S_FALSE, factory_.LockServer(TRUE));
 
   // Release the patch lock and wait on the event.
   vtable_patch::patch_lock_.Release();
   EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(event.Get(), INFINITE));
 
   // Verify that unpatching took place.
   EXPECT_CALL(factory_, LockServer(TRUE))
       .WillOnce(Return(S_FALSE));
   EXPECT_EQ(S_FALSE, factory_.LockServer(TRUE));
 }