Change over IgnoreReturn to IgnoreResult. remove IgnoreReturn.

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"
@@ skipping 203 matching lines @@
 
   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,
-      base::IgnoreReturn<HRESULT>(
-          base::Bind(&vtable_patch::PatchInterfaceMethods, &factory_,
-                     &IClassFactory_PatchInfo[0])));
+      base::Bind(base::IgnoreResult(&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, base::IgnoreReturn<BOOL>(base::Bind(::SetEvent, event.Get())));
+      FROM_HERE, base::Bind(base::IgnoreResult(::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 14 matching lines @@
 
   // 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,
-      base::IgnoreReturn<HRESULT>(
-          base::Bind(&vtable_patch::UnpatchInterfaceMethods,
-                     &IClassFactory_PatchInfo[0])));
+      base::Bind(base::IgnoreResult(&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, base::IgnoreReturn<BOOL>(base::Bind(::SetEvent, event.Get())));
+      FROM_HERE, base::Bind(base::IgnoreResult(::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));
 }