Move CloseHandle hook into base/debug.

base/debug/close_handle_hook_win.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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 "chrome/app/close_handle_hook_win.h"
+#include "base/debug/close_handle_hook_win.h"
 
 #include <Windows.h>
 #include <psapi.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/iat_patch_function.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
 #include "build/build_config.h"
-#include "chrome/common/channel_info.h"
-#include "components/version_info/version_info.h"
 
 namespace {
 
 typedef BOOL (WINAPI* CloseHandleType) (HANDLE handle);
 
 typedef BOOL (WINAPI* DuplicateHandleType)(HANDLE source_process,
                                            HANDLE source_handle,
                                            HANDLE target_process,
                                            HANDLE* target_handle,
                                            DWORD desired_access,
@@ skipping 21 matching lines @@
   if ((options & DUPLICATE_CLOSE_SOURCE) &&
       (GetProcessId(source_process) == ::GetCurrentProcessId())) {
     base::win::OnHandleBeingClosed(source_handle);
   }
 
   return g_duplicate_function(source_process, source_handle, target_process,
                               target_handle, desired_access, inherit_handle,
                               options);
 }
 
+}  // namespace
+
+namespace base {
+namespace debug {
+
+namespace {
+
 // Provides a simple way to temporarily change the protection of a memory page.
 class AutoProtectMemory {
  public:
   AutoProtectMemory()
       : changed_(false), address_(NULL), bytes_(0), old_protect_(0) {}
 
   ~AutoProtectMemory() {
     RevertProtection();
   }
 
@@ skipping 154 matching lines @@
 }
 
 void HandleHooks::Unpatch() {
   for (std::vector<base::win::IATPatchFunction*>::iterator it = hooks_.begin();
        it != hooks_.end(); ++it) {
     (*it)->Unpatch();
     delete *it;
   }
 }
 
-bool UseHooks() {
-#if defined(ARCH_CPU_X86_64)
-  return false;
-#elif defined(NDEBUG)
-  version_info::Channel channel = chrome::GetChannel();
-  if (channel == version_info::Channel::CANARY ||
-      channel == version_info::Channel::DEV) {
-    return true;
-  }
-
-  return false;
-#else  // NDEBUG
-  return true;
-#endif
-}
-
 void PatchLoadedModules(HandleHooks* hooks) {
   const DWORD kSize = 256;
   DWORD returned;
   scoped_ptr<HMODULE[]> modules(new HMODULE[kSize]);
   if (!EnumProcessModules(GetCurrentProcess(), modules.get(),
                           kSize * sizeof(HMODULE), &returned)) {
     return;
   }
   returned /= sizeof(HMODULE);
   returned = std::min(kSize, returned);
 
   for (DWORD current = 0; current < returned; current++) {
     hooks->AddIATPatch(modules[current]);
   }
 }
 
 }  // namespace
 
 void InstallHandleHooks() {
-  if (UseHooks()) {
-    HandleHooks* hooks = g_hooks.Pointer();
+  HandleHooks* hooks = g_hooks.Pointer();
 
-    // Performing EAT interception first is safer in the presence of other
-    // threads attempting to call CloseHandle.
-    hooks->AddEATPatch();
-    PatchLoadedModules(hooks);
-  } else {
-    base::win::DisableHandleVerifier();
-  }
+  // Performing EAT interception first is safer in the presence of other
+  // threads attempting to call CloseHandle.
+  hooks->AddEATPatch();
+  PatchLoadedModules(hooks);
 }
 
 void RemoveHandleHooks() {
   // We are partching all loaded modules without forcing them to stay in memory,
   // removing patches is not safe.
 }
+
+}  // namespace debug
+}  // namespace base