Remove dependency on base/win/win_util.cc from crashpad.

components/crash/content/app/crashpad.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 "components/crash/content/app/crashpad.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #if BUILDFLAG(ENABLE_KASKO)
@@ skipping 24 matching lines @@
 #include "third_party/crashpad/crashpad/client/settings.h"
 #include "third_party/crashpad/crashpad/client/simple_string_dictionary.h"
 #include "third_party/crashpad/crashpad/client/simulate_crash.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif  // OS_POSIX
 
 #if BUILDFLAG(ENABLE_KASKO)
 #include "base/win/scoped_handle.h"
-#include "base/win/win_util.h"
 #include "third_party/crashpad/crashpad/snapshot/api/module_annotations_win.h"
 #endif
 
 namespace crash_reporter {
 
 namespace {
 
 crashpad::SimpleStringDictionary* g_simple_string_dictionary;
 crashpad::CrashReportDatabase* g_database;
 
@@ skipping 42 matching lines @@
   // Rather than including the code to force the crash here, allow the caller to
   // do it.
   return false;
 }
 
 void DumpWithoutCrashing() {
   CRASHPAD_SIMULATE_CRASH();
 }
 
 #if BUILDFLAG(ENABLE_KASKO)
+// TODO(ananta)
+// We cannot depend on functionality in base which pulls in dependencies on
+// user32 directly or indirectly. The GetLoadedModulesSnapshot is a copy of the
+// function in base/win/win_util.cc. Depending on the base function pulls in
+// dependencies on user32 due to other functionality in win_util.cc. This
+// function should be removed when KASKO is removed.
+bool GetLoadedModulesSnapshot(HANDLE process, std::vector<HMODULE>* snapshot) {
+  DCHECK(snapshot);
+  DCHECK_EQ(0u, snapshot->size());
+  snapshot->resize(128);
+
+  // We will retry at least once after first determining |bytes_required|. If
+  // the list of modules changes after we receive |bytes_required| we may retry
+  // more than once.
+  int retries_remaining = 5;
+  do {
+    DWORD bytes_required = 0;
+    // EnumProcessModules returns 'success' even if the buffer size is too
+    // small.
+    DCHECK_GE(std::numeric_limits<DWORD>::max(),
+      snapshot->size() * sizeof(HMODULE));
+    if (!::EnumProcessModules(
+      process, &(*snapshot)[0],
+      static_cast<DWORD>(snapshot->size() * sizeof(HMODULE)),
+      &bytes_required)) {
+      DPLOG(ERROR) << "::EnumProcessModules failed.";
+      return false;
+    }
+    DCHECK_EQ(0u, bytes_required % sizeof(HMODULE));
+    size_t num_modules = bytes_required / sizeof(HMODULE);
+    if (num_modules <= snapshot->size()) {
+      // Buffer size was too big, presumably because a module was unloaded.
+      snapshot->erase(snapshot->begin() + num_modules, snapshot->end());
+      return true;
+    } else if (num_modules == 0) {
+      DLOG(ERROR) << "Can't determine the module list size.";
+      return false;
+    } else {
+      // Buffer size was too small. Try again with a larger buffer. A little
+      // more room is given to avoid multiple expensive calls to
+      // ::EnumProcessModules() just because one module has been added.
+      snapshot->resize(num_modules + 8, NULL);
+    }
+  } while (--retries_remaining);
+
+  DLOG(ERROR) << "Failed to enumerate modules.";
+  return false;
+}
+
 HMODULE GetModuleInProcess(base::ProcessHandle process,
                            const wchar_t* module_name) {
   std::vector<HMODULE> modules_snapshot;
-  if (!base::win::GetLoadedModulesSnapshot(process, &modules_snapshot))
+  if (!GetLoadedModulesSnapshot(process, &modules_snapshot))
     return nullptr;
 
   for (HMODULE module : modules_snapshot) {
     wchar_t current_module_name[MAX_PATH];
     if (!::GetModuleBaseName(process, module, current_module_name, MAX_PATH))
       continue;
 
     if (std::wcscmp(module_name, current_module_name) == 0)
       return module;
   }
@@ skipping 285 matching lines @@
                                    base::UTF16ToUTF8(value));
 }
 
 void __declspec(dllexport) __cdecl ClearCrashKeyValueImpl(const wchar_t* key) {
   crash_reporter::ClearCrashKey(base::UTF16ToUTF8(key));
 }
 
 }  // extern "C"
 
 #endif  // OS_WIN