[Win] Create ModuleWatcher.

chrome/common/conflicts/module_watcher_win_unittest.cc

Index: chrome/common/conflicts/module_watcher_win_unittest.cc
diff --git a/chrome/common/conflicts/module_watcher_win_unittest.cc b/chrome/common/conflicts/module_watcher_win_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..aa3c1ad992e83114120115f5405e702a33f306b5
--- /dev/null
+++ b/chrome/common/conflicts/module_watcher_win_unittest.cc
@@ -0,0 +1,109 @@
+// 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 <memory>
+
+#include "base/bind.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace conflicts {
+
+class ModuleWatcherTest : public testing::Test {
+ public:
+  ModuleWatcherTest()
+      : module_(nullptr),
+        module_event_count_(0),
+        module_already_loaded_event_count_(0),
+        module_loaded_event_count_(0),
+        module_unloaded_event_count_(0) {}
+
+  void OnModuleEvent(const mojom::ModuleEvent& event) {
+    module_event_count_++;
+    switch (event.event_type) {
+      case mojom::ModuleEventType::MODULE_ALREADY_LOADED:
+        module_already_loaded_event_count_++;
+        break;
+      case mojom::ModuleEventType::MODULE_LOADED:
+        module_loaded_event_count_++;
+        break;
+      case mojom::ModuleEventType::MODULE_UNLOADED:
+        module_unloaded_event_count_++;
+        break;
+    }
+  }
+
+  void TearDown() override {
+    UnloadModule();
+  }
+
+  void LoadModule() {
+    if (module_)
+      return;
+    // This module should not be a static dependency of the unit-test
+    // executable, but should be a build-system dependency or a module that is
+    // present on any Windows machine.
+    static const wchar_t kModuleName[] = L"chrome.dll";
+    // The module should not already be loaded.
+    ASSERT_FALSE(::GetModuleHandle(kModuleName));
+    // It should load successfully.
+    module_ = ::LoadLibrary(kModuleName);
+    ASSERT_TRUE(module_);
+  }
+
+  void UnloadModule() {
+    if (!module_)
+      return;
+    ::FreeLibrary(module_);
+    module_ = nullptr;
+  }
+
+  // Holds a handle to a loaded module.
+  HMODULE module_;
+
+  // Total number of module events seen.
+  size_t module_event_count_;
+  // Total number of MODULE_ALREADY_LOADED events seen.
+  size_t module_already_loaded_event_count_;
+  // Total number of MODULE_LOADED events seen.
+  size_t module_loaded_event_count_;
+  // Total number of MODULE_UNLOADED events seen.
+  size_t module_unloaded_event_count_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ModuleWatcherTest);
+};
+
+TEST_F(ModuleWatcherTest, ModuleEvents) {
+  // Create the module watcher. This should immediately enumerate all already
+  // loaded modules.
+  std::unique_ptr<ModuleWatcher> mw(new ModuleWatcher(
+      base::Bind(&ModuleWatcherTest::OnModuleEvent, base::Unretained(this))));
+  EXPECT_LT(0u, module_event_count_);
+  EXPECT_LT(0u, module_already_loaded_event_count_);
+  EXPECT_EQ(0u, module_loaded_event_count_);
+  EXPECT_EQ(0u, module_unloaded_event_count_);
+
+  // Dynamically load a module and ensure it a notification is received for it.
+  LoadModule();
+  EXPECT_EQ(1u, module_loaded_event_count_);
+
+  // Unload the module and ensure another notification is received.
+  UnloadModule();
+  EXPECT_EQ(1u, module_unloaded_event_count_);
+
+  // Dynamically load a module and ensure it a notification is received for it.
+  LoadModule();
+  EXPECT_EQ(2u, module_loaded_event_count_);
+
+  // Destroy the module watcher.
+  mw.reset();
+
+  // Unload the module and ensure no notification is received this time.
+  UnloadModule();
+  EXPECT_EQ(1u, module_unloaded_event_count_);
+}
+
+}  // namespace conflicts