Revert of [win] Create ModuleDatabase and ModuleEventSinkImpl.

chrome/common/conflicts/module_watcher_win.cc

 // Copyright 2016 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/common/conflicts/module_watcher_win.h"
 
 #include <windows.h>
 #include <tlhelp32.h>
 #include <winternl.h>  // For UNICODE_STRING.
 
 #include <string>
-#include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
-#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/win/scoped_handle.h"
 
 // These structures and functions are documented in MSDN, see
 // http://msdn.microsoft.com/en-us/library/gg547638(v=vs.85).aspx
 // there are however no headers or import libraries available in the
 // Platform SDK. They are declared outside of the anonymous namespace to
 // allow them to be forward declared in the header file.
 enum {
@@ skipping 64 matching lines @@
 // Global pointer to the singleton ModuleWatcher, if one exists. Under
 // |module_watcher_lock|.
 ModuleWatcher* g_module_watcher_instance = nullptr;
 
 // Names of the DLL notification registration functions. These are exported by
 // ntdll.
 constexpr wchar_t kNtDll[] = L"ntdll.dll";
 constexpr char kLdrRegisterDllNotification[] = "LdrRegisterDllNotification";
 constexpr char kLdrUnregisterDllNotification[] = "LdrUnregisterDllNotification";
 
-// Helper function for converting a UNICODE_STRING to a FilePath.
-base::FilePath ToFilePath(const UNICODE_STRING* str) {
-  return base::FilePath(
-      base::StringPiece16(str->Buffer, str->Length / sizeof(wchar_t)));
+// Helper function for converting a UNICODE_STRING to a UTF8 std::string.
+std::string ToString(const UNICODE_STRING* str) {
+  std::string s;
+  base::WideToUTF8(str->Buffer, str->Length / sizeof(wchar_t), &s);
+  return s;
 }
 
 template <typename NotificationDataType>
 void OnModuleEvent(mojom::ModuleEventType event_type,
                    const NotificationDataType& notification_data,
                    const ModuleWatcher::OnModuleEventCallback& callback) {
-  ModuleWatcher::ModuleEvent event(
-      event_type, ToFilePath(notification_data.FullDllName),
-      notification_data.DllBase, notification_data.SizeOfImage);
+  mojom::ModuleEvent event;
+  event.event_type = event_type;
+  event.module_path = ToString(notification_data.FullDllName);
+  event.load_address = reinterpret_cast<uintptr_t>(notification_data.DllBase);
+  event.size = notification_data.SizeOfImage;
   callback.Run(event);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<ModuleWatcher> ModuleWatcher::Create(
-    OnModuleEventCallback callback) {
+    const OnModuleEventCallback& callback) {
   // If a ModuleWatcher already exists then bail out.
   base::AutoLock lock(g_module_watcher_lock.Get());
   if (g_module_watcher_instance)
     return nullptr;
 
   // This thread acquired the right to create a ModuleWatcher, so do so.
-  g_module_watcher_instance = new ModuleWatcher(std::move(callback));
+  g_module_watcher_instance = new ModuleWatcher(callback);
   return base::WrapUnique(g_module_watcher_instance);
 }
 
 ModuleWatcher::~ModuleWatcher() {
   // As soon as |g_module_watcher_instance| is null any dispatched callbacks
   // will be silently absorbed by LoaderNotificationCallback.
   base::AutoLock lock(g_module_watcher_lock.Get());
   DCHECK_EQ(g_module_watcher_instance, this);
   g_module_watcher_instance = nullptr;
   UnregisterDllNotificationCallback();
@@ skipping 27 matching lines @@
     if (snap.IsValid())
       break;
     if (::GetLastError() != ERROR_BAD_LENGTH)
       return;
   }
   if (!snap.IsValid())
     return;
 
   // Walk the module list.
   MODULEENTRY32 module = {sizeof(module)};
+  std::string path;
   for (BOOL result = ::Module32First(snap.Get(), &module); result != FALSE;
        result = ::Module32Next(snap.Get(), &module)) {
-    ModuleEvent event(mojom::ModuleEventType::MODULE_ALREADY_LOADED,
-                      base::FilePath(module.szExePath), module.modBaseAddr,
-                      module.modBaseSize);
+    base::WideToUTF8(module.szExePath, ::wcslen(module.szExePath), &path);
+    mojom::ModuleEvent event;
+    event.event_type = mojom::ModuleEventType::MODULE_ALREADY_LOADED;
+    event.module_path = path;
+    event.load_address = reinterpret_cast<uintptr_t>(module.modBaseAddr);
+    event.size = module.modBaseSize;
     callback_.Run(event);
   }
 
   return;
 }
 
 // static
 ModuleWatcher::OnModuleEventCallback ModuleWatcher::GetCallbackForContext(
     void* context) {
   base::AutoLock lock(g_module_watcher_lock.Get());
@@ skipping 22 matching lines @@
                     notification_data->Unloaded, callback);
       break;
 
     default:
       // This is unexpected, but not a reason to crash.
       NOTREACHED() << "Unknown LDR_DLL_NOTIFICATION_REASON: "
                    << notification_reason;
   }
 }
 
-ModuleWatcher::ModuleWatcher(OnModuleEventCallback callback)
-    : callback_(std::move(callback)) {
+ModuleWatcher::ModuleWatcher(const OnModuleEventCallback& callback)
+    : callback_(callback) {
   RegisterDllNotificationCallback();
   EnumerateAlreadyLoadedModules();
 }