Allow IAT patches to fail when patching for Active Verifier.

base/debug/close_handle_hook_win.cc

 // Copyright 2015 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 "base/debug/close_handle_hook_win.h"
 
 #include <Windows.h>
 #include <psapi.h>
 
 #include <algorithm>
@@ skipping 185 matching lines @@
 };
 base::LazyInstance<HandleHooks> g_hooks = LAZY_INSTANCE_INITIALIZER;
 
 bool HandleHooks::AddIATPatch(HMODULE module) {
   if (!module)
     return false;
 
   base::win::IATPatchFunction* patch = NULL;
   patch = IATPatch(module, "CloseHandle", &CloseHandleHook,
                    reinterpret_cast<void**>(&g_close_function));
-  if (!patch)
-    return false;
-  hooks_.push_back(patch);
+  if (patch)
+    hooks_.push_back(patch);
 
   patch = IATPatch(module, "DuplicateHandle", &DuplicateHandleHook,
                    reinterpret_cast<void**>(&g_duplicate_function));
-  if (!patch)
-    return false;
-  hooks_.push_back(patch);
+  if (patch)
+    hooks_.push_back(patch);
+
   return true;
 }
 
 bool HandleHooks::AddEATPatch() {
    // An attempt to restore the entry on the table at destruction is not safe.
   // An attempt to restore the entry on the table at destruction is not safe.
   return (EATPatch(GetModuleHandleA("kernel32.dll"), "CloseHandle",
                    &CloseHandleHook,
                    reinterpret_cast<void**>(&g_close_function)) &&
           EATPatch(GetModuleHandleA("kernel32.dll"), "DuplicateHandle",
@@ skipping 17 matching lines @@
   const DWORD kSize = 256;
   DWORD returned;
   scoped_ptr<HMODULE[]> modules(new HMODULE[kSize]);
   if (!EnumProcessModules(GetCurrentProcess(), modules.get(),
                           kSize * sizeof(HMODULE), &returned)) {
     return false;
   }
   returned /= sizeof(HMODULE);
   returned = std::min(kSize, returned);
 
-  bool success = false;
-
   for (DWORD current = 0; current < returned; current++) {
-    success = hooks->AddIATPatch(modules[current]);
-    if (!success)
-      break;
+    if (!hooks->AddIATPatch(modules[current]))
+      return false;
   }
 
-  return success;
+  return true;
 }
 
 }  // namespace
 
 namespace base {
 namespace debug {
 
 bool InstallHandleHooks() {
   HandleHooks* hooks = g_hooks.Pointer();
 
   // Performing EAT interception first is safer in the presence of other
   // threads attempting to call CloseHandle.
   return (hooks->AddEATPatch() && PatchLoadedModules(hooks));
 }
 
 void RemoveHandleHooks() {
   // We are patching all loaded modules without forcing them to stay in memory,
   // removing patches is not safe.
 }
 
 }  // namespace debug
 }  // namespace base