Add ModuleInspector

chrome/browser/conflicts/module_database_win_unittest.cc

 // Copyright 2017 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/browser/conflicts/module_database_win.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/strings/utf_string_conversions.h"
+#include "base/test/scoped_task_scheduler.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // A simple mechanism for running a single task on a separate thread.
 class SingleTaskRunner : public base::SimpleThread {
  public:
   explicit SingleTaskRunner(base::Closure task)
       : base::SimpleThread("SingleTaskRunner"), task_(std::move(task)) {}
@@ skipping 47 matching lines @@
   using ModuleDatabase::InsertLoadAddress;
   using ModuleDatabase::RemoveLoadAddressById;
   using ModuleDatabase::RemoveLoadAddressByIndex;
 };
 
 class ModuleDatabaseTest : public testing::Test {
  protected:
   ModuleDatabaseTest()
       : dll1_(kDll1),
         dll2_(kDll2),
-        message_loop_(base::MakeUnique<base::MessageLoop>()),
-        module_database_(
-            base::MakeUnique<ModuleDatabase>(message_loop_->task_runner())) {}
-
-  void RunLoopUntilIdle() { base::RunLoop().RunUntilIdle(); }
+        module_database_(base::MakeUnique<ModuleDatabase>(
+            base::SequencedTaskRunnerHandle::Get())) {}
 
   const ModuleDatabase::ModuleMap& modules() {
     return module_database_->modules_;
   }
 
   const ModuleDatabase::ProcessMap& processes() {
     return module_database_->processes_;
   }
 
+  ModuleDatabase* module_database() { return module_database_.get(); }
+
   static uint32_t ProcessTypeToBit(content::ProcessType process_type) {
     return ModuleDatabase::ProcessTypeToBit(process_type);
   }
 
   // Counts the occurrences of the given |module_id| in the given collection of
   // |load_addresses|.
   static size_t ModuleIdCount(
       ModuleId module_id,
       const ModuleDatabase::ModuleLoadAddresses& load_addresses) {
     return std::count_if(
         load_addresses.begin(), load_addresses.end(),
         [module_id](const auto& x) { return module_id == x.first; });
   }
 
- protected:
   const base::FilePath dll1_;
   const base::FilePath dll2_;
 
-  std::unique_ptr<base::MessageLoop> message_loop_;
+ private:
+  // Must be before |module_database_|.
+  base::test::ScopedTaskScheduler scoped_task_scheduler_;
+
   std::unique_ptr<ModuleDatabase> module_database_;
 
- private:
   DISALLOW_COPY_AND_ASSIGN(ModuleDatabaseTest);
 };
 
 TEST_F(ModuleDatabaseTest, LoadAddressVectorOperations) {
   using TMD = TestModuleDatabase;
-  TestModuleDatabase::ModuleLoadAddresses la;
+  TMD::ModuleLoadAddresses la;
 
   // Finds should fail in an empty collection.
   EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0, la));
   EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0x04000000, la));
 
   // A first insert should work. Don't start with ModuleId 0 so that later
   // inserts can insert that module.
   TMD::InsertLoadAddress(10, 0x04000000, &la);
   EXPECT_EQ(1u, la.size());
   EXPECT_EQ(10, la[0].first);
@@ skipping 128 matching lines @@
   EXPECT_EQ(10, la[0].first);
   EXPECT_EQ(0x04000000u, la[0].second);
 
   // Remove the only remaining element.
   TMD::RemoveLoadAddressByIndex(0, &la);
   EXPECT_TRUE(la.empty());
 }
 
 TEST_F(ModuleDatabaseTest, LoadAddressVectorStressTest) {
   using TMD = TestModuleDatabase;
-  TestModuleDatabase::ModuleLoadAddresses la;
+  TMD::ModuleLoadAddresses la;
 
   for (size_t n = 1; n < 200; ++n) {
     // Will keep track of which elements have been inserted.
     std::vector<bool> inserted(n);
     size_t inserted_count = 0;
 
     // Generate a shuffled list of IDs. This will be the insertion order.
     // More insertions than elements will occur so that rewrites occur.,
     std::vector<ModuleId> ids(11 * n / 10);
     for (size_t i = 0; i < 11 * n / 10; ++i)
@@ skipping 34 matching lines @@
     // Do the deletions.
     for (auto id : ids) {
       --inserted_count;
       TMD::RemoveLoadAddressById(id, &la);
       EXPECT_EQ(inserted_count, la.size());
     }
   }
 }
 
 TEST_F(ModuleDatabaseTest, TasksAreBounced) {
-  // Run a task on the current thread. This should not be bounced, so no
-  // task should be scheduled on the task runner.
-  module_database_->OnProcessStarted(kPid1, kCreateTime1,
-                                     content::PROCESS_TYPE_BROWSER);
-  EXPECT_TRUE(message_loop_->IsIdleForTesting());
-  module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
-                                 kGoodAddress1);
-  EXPECT_TRUE(message_loop_->IsIdleForTesting());
-  module_database_->OnProcessEnded(kPid1, kCreateTime1);
-  EXPECT_TRUE(message_loop_->IsIdleForTesting());
+  // Run a task on the current thread. This should not be bounced, so their
+  // results should be immediately available.
+  module_database()->OnProcessStarted(kPid1, kCreateTime1,
+                                      content::PROCESS_TYPE_BROWSER);
+  EXPECT_EQ(1u, processes().size());
+  module_database()->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
+                                  kGoodAddress1);
+  EXPECT_EQ(1u, modules().size());
+  module_database()->OnProcessEnded(kPid1, kCreateTime1);
+  EXPECT_EQ(0u, processes().size());
 
   // Indicate another process start on this thread. This call can't be
   // bounced.
-  module_database_->OnProcessStarted(kPid2, kCreateTime2,
-                                     content::PROCESS_TYPE_BROWSER);
+  module_database()->OnProcessStarted(kPid2, kCreateTime2,
+                                      content::PROCESS_TYPE_BROWSER);
+  EXPECT_EQ(1u, processes().size());
 
-  // Run similar tasks on another thread. These should be bounced.
+  // Run similar tasks on another thread with another module. These should be
+  // bounced.
   RunTask(base::Bind(&ModuleDatabase::OnModuleLoad,
-                     base::Unretained(module_database_.get()), kPid2,
-                     kCreateTime2, dll1_, kSize1, kTime1, kGoodAddress1));
-  EXPECT_FALSE(message_loop_->IsIdleForTesting());
-  RunLoopUntilIdle();
+                     base::Unretained(module_database()), kPid2, kCreateTime2,
+                     dll2_, kSize1, kTime1, kGoodAddress1));
+  EXPECT_EQ(1u, modules().size());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(2u, modules().size());
 
   RunTask(base::Bind(&ModuleDatabase::OnProcessEnded,
-                     base::Unretained(module_database_.get()), kPid2,
-                     kCreateTime2));
-  EXPECT_FALSE(message_loop_->IsIdleForTesting());
-  RunLoopUntilIdle();
+                     base::Unretained(module_database()), kPid2, kCreateTime2));
+  EXPECT_EQ(1u, processes().size());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(0u, processes().size());
 }
 
 TEST_F(ModuleDatabaseTest, EventsWithoutProcessIgnore) {
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(0u, processes().size());
 
-  module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
-                                 kGoodAddress1);
+  module_database()->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
+                                  kGoodAddress1);
 
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(0u, processes().size());
 }
 
 TEST_F(ModuleDatabaseTest, OrphanedUnloadIgnored) {
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(0u, processes().size());
 
   // Start a process.
-  module_database_->OnProcessStarted(kPid1, kCreateTime1,
-                                     content::PROCESS_TYPE_BROWSER);
+  module_database()->OnProcessStarted(kPid1, kCreateTime1,
+                                      content::PROCESS_TYPE_BROWSER);
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(1u, processes().size());
   auto p1 = processes().begin();
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(0u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
 
   // Indicate a module unload. This should do nothing because there's no
   // corresponding module.
-  module_database_->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress1);
+  module_database()->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress1);
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(1u, processes().size());
   EXPECT_EQ(0u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
 }
 
 TEST_F(ModuleDatabaseTest, DatabaseIsConsistent) {
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(0u, processes().size());
 
   // Start a process.
-  module_database_->OnProcessStarted(kPid1, kCreateTime1,
-                                     content::PROCESS_TYPE_BROWSER);
+  module_database()->OnProcessStarted(kPid1, kCreateTime1,
+                                      content::PROCESS_TYPE_BROWSER);
   EXPECT_EQ(0u, modules().size());
   EXPECT_EQ(1u, processes().size());
   auto p1 = processes().begin();
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(0u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
 
   // Load a module.
-  module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
-                                 kGoodAddress1);
+  module_database()->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
+                                  kGoodAddress1);
   EXPECT_EQ(1u, modules().size());
   EXPECT_EQ(1u, processes().size());
 
   // Ensure that the process and module sets are up to date.
   auto m1 = modules().begin();
   EXPECT_EQ(dll1_, m1->first.module_path);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m1->second.process_types);
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(1u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
   EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules));
 
   // Provide a redundant load message for that module.
-  module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
-                                 kGoodAddress1);
+  module_database()->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1,
+                                  kGoodAddress1);
   EXPECT_EQ(1u, modules().size());
   EXPECT_EQ(1u, processes().size());
 
   // Ensure that the process and module sets haven't changed.
   EXPECT_EQ(dll1_, m1->first.module_path);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m1->second.process_types);
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(1u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
   EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules));
 
   // Load a second module into the process.
-  module_database_->OnModuleLoad(kPid1, kCreateTime1, dll2_, kSize2, kTime2,
-                                 kGoodAddress2);
+  module_database()->OnModuleLoad(kPid1, kCreateTime1, dll2_, kSize2, kTime2,
+                                  kGoodAddress2);
   EXPECT_EQ(2u, modules().size());
   EXPECT_EQ(1u, processes().size());
 
   // Ensure that the process and module sets are up to date.
   auto m2 = modules().rbegin();
   EXPECT_EQ(dll2_, m2->first.module_path);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m2->second.process_types);
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(2u, p1->second.loaded_modules.size());
   EXPECT_EQ(0u, p1->second.unloaded_modules.size());
   EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules));
   EXPECT_EQ(1u, ModuleIdCount(m2->first.module_id, p1->second.loaded_modules));
 
   // Unload the second module.
-  module_database_->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress2);
+  module_database()->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress2);
   EXPECT_EQ(2u, modules().size());
   EXPECT_EQ(1u, processes().size());
 
   // Ensure that the process and module sets are up to date.
   EXPECT_EQ(dll2_, m2->first.module_path);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m2->second.process_types);
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type);
   EXPECT_EQ(1u, p1->second.loaded_modules.size());
   EXPECT_EQ(1u, p1->second.unloaded_modules.size());
   EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules));
   EXPECT_EQ(1u,
             ModuleIdCount(m2->first.module_id, p1->second.unloaded_modules));
 
   // Start a process.
-  module_database_->OnProcessStarted(kPid2, kCreateTime2,
-                                     content::PROCESS_TYPE_RENDERER);
+  module_database()->OnProcessStarted(kPid2, kCreateTime2,
+                                      content::PROCESS_TYPE_RENDERER);
   EXPECT_EQ(2u, modules().size());
   EXPECT_EQ(2u, processes().size());
   auto p2 = processes().rbegin();
   EXPECT_EQ(kPid2, p2->first.process_id);
   EXPECT_EQ(kCreateTime2, p2->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_RENDERER, p2->first.process_type);
   EXPECT_EQ(0u, p2->second.loaded_modules.size());
   EXPECT_EQ(0u, p2->second.unloaded_modules.size());
 
   // Load the dummy.dll in the second process as well.
-  module_database_->OnModuleLoad(kPid2, kCreateTime2, dll1_, kSize1, kTime1,
-                                 kGoodAddress1);
+  module_database()->OnModuleLoad(kPid2, kCreateTime2, dll1_, kSize1, kTime1,
+                                  kGoodAddress1);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) |
                 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER),
             m1->second.process_types);
   EXPECT_EQ(kPid2, p2->first.process_id);
   EXPECT_EQ(kCreateTime2, p2->first.creation_time);
   EXPECT_EQ(content::PROCESS_TYPE_RENDERER, p2->first.process_type);
   EXPECT_EQ(1u, p2->second.loaded_modules.size());
   EXPECT_EQ(0u, p2->second.unloaded_modules.size());
   EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p2->second.loaded_modules));
 
   // End the second process without an explicit unload. This invalidates |p2|.
-  module_database_->OnProcessEnded(kPid2, kCreateTime2);
+  module_database()->OnProcessEnded(kPid2, kCreateTime2);
   EXPECT_EQ(2u, modules().size());
   EXPECT_EQ(1u, processes().size());
   EXPECT_EQ(kPid1, p1->first.process_id);
   EXPECT_EQ(kCreateTime1, p1->first.creation_time);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) |
                 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER),
             m1->second.process_types);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m2->second.process_types);
 
   // End the first process without an explicit unload. This invalidates |p1|.
-  module_database_->OnProcessEnded(kPid1, kCreateTime1);
+  module_database()->OnProcessEnded(kPid1, kCreateTime1);
   EXPECT_EQ(2u, modules().size());
   EXPECT_EQ(0u, processes().size());
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) |
                 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER),
             m1->second.process_types);
   EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER),
             m2->second.process_types);
 }