Extend the CloseHandle interception to all DLLs loaded in the process.

base/win/iat_patch_function.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 "base/win/iat_patch_function.h"
 
 #include "base/logging.h"
 #include "base/win/pe_image.h"
 
 namespace base {
@@ skipping 217 matching lines @@
   if (NULL != intercept_function_) {
     DWORD error = Unpatch();
     DCHECK_EQ(static_cast<DWORD>(NO_ERROR), error);
   }
 }
 
 DWORD IATPatchFunction::Patch(const wchar_t* module,
                               const char* imported_from_module,
                               const char* function_name,
                               void* new_function) {
-  DCHECK_EQ(static_cast<void*>(NULL), original_function_);
-  DCHECK_EQ(static_cast<IMAGE_THUNK_DATA*>(NULL), iat_thunk_);
-  DCHECK_EQ(static_cast<void*>(NULL), intercept_function_);
-
   HMODULE module_handle = LoadLibraryW(module);
-
   if (module_handle == NULL) {
     NOTREACHED();
     return GetLastError();
   }
 
-  DWORD error = InterceptImportedFunction(module_handle,
+  DWORD error = PatchFromModule(module_handle, imported_from_module,
+                                function_name, new_function);
+  if (NO_ERROR == error) {
+    module_handle_ = module_handle;
+  } else {
+    FreeLibrary(module_handle);
+  }
+
+  return error;
+}
+
+DWORD IATPatchFunction::PatchFromModule(HMODULE module,
+                                        const char* imported_from_module,
+                                        const char* function_name,
+                                        void* new_function) {
+  DCHECK_EQ(static_cast<void*>(NULL), original_function_);
+  DCHECK_EQ(static_cast<IMAGE_THUNK_DATA*>(NULL), iat_thunk_);
+  DCHECK_EQ(static_cast<void*>(NULL), intercept_function_);
+  DCHECK(module);
+
+  DWORD error = InterceptImportedFunction(module,
                                           imported_from_module,
                                           function_name,
                                           new_function,
                                           &original_function_,
                                           &iat_thunk_);
 
   if (NO_ERROR == error) {
     DCHECK_NE(original_function_, intercept_function_);
-    module_handle_ = module_handle;
     intercept_function_ = new_function;
-  } else {
-    FreeLibrary(module_handle);
   }
 
   return error;
 }
 
 DWORD IATPatchFunction::Unpatch() {
   DWORD error = RestoreImportedFunction(intercept_function_,
                                         original_function_,
                                         iat_thunk_);
   DCHECK_EQ(static_cast<DWORD>(NO_ERROR), error);
@@ skipping 14 matching lines @@
   return error;
 }
 
 void* IATPatchFunction::original_function() const {
   DCHECK(is_patched());
   return original_function_;
 }
 
 }  // namespace win
 }  // namespace base