Remove some LazyInstance use in base/

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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
-#include "base/lazy_instance.h"
 #include "base/macros.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"
 
 namespace {
 
 typedef BOOL (WINAPI* CloseHandleType) (HANDLE handle);
 
@@ skipping 164 matching lines @@
 
 // Keeps track of all the hooks needed to intercept functions which could
 // possibly close handles.
 class HandleHooks {
  public:
   HandleHooks() {}
   ~HandleHooks() {}
 
   void AddIATPatch(HMODULE module);
   void AddEATPatch();
-  void Unpatch();
 
  private:
   std::vector<base::win::IATPatchFunction*> hooks_;
   DISALLOW_COPY_AND_ASSIGN(HandleHooks);
 };
-base::LazyInstance<HandleHooks> g_hooks = LAZY_INSTANCE_INITIALIZER;
 
 void HandleHooks::AddIATPatch(HMODULE module) {
   if (!module)
     return;
 
   base::win::IATPatchFunction* patch = NULL;
   patch = IATPatch(module, "CloseHandle", &CloseHandleHook,
                    reinterpret_cast<void**>(&g_close_function));
   if (!patch)
     return;
   hooks_.push_back(patch);
 
   patch = IATPatch(module, "DuplicateHandle", &DuplicateHandleHook,
                    reinterpret_cast<void**>(&g_duplicate_function));
   if (!patch)
     return;
   hooks_.push_back(patch);
 }
 
 void HandleHooks::AddEATPatch() {
   // An attempt to restore the entry on the table at destruction is not safe.
   EATPatch(GetModuleHandleA("kernel32.dll"), "CloseHandle",
            &CloseHandleHook, reinterpret_cast<void**>(&g_close_function));
   EATPatch(GetModuleHandleA("kernel32.dll"), "DuplicateHandle",
            &DuplicateHandleHook,
            reinterpret_cast<void**>(&g_duplicate_function));
 }
 
-void HandleHooks::Unpatch() {
-  for (std::vector<base::win::IATPatchFunction*>::iterator it = hooks_.begin();
-       it != hooks_.end(); ++it) {
-    (*it)->Unpatch();
-    delete *it;
-  }
-}
-
 void PatchLoadedModules(HandleHooks* hooks) {
   const DWORD kSize = 256;
   DWORD returned;
   std::unique_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() {
-  HandleHooks* hooks = g_hooks.Pointer();
+  static HandleHooks* hooks = new HandleHooks();
 
   // 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