Add ModuleInspector

chrome/browser/conflicts/module_database_win.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 <tuple>
 
 #include "base/bind.h"
 
 namespace {
 
 // Document the assumptions made on the ProcessType enum in order to convert
 // them to bits.
 static_assert(content::PROCESS_TYPE_UNKNOWN == 1,
               "assumes unknown process type has value 1");
 static_assert(content::PROCESS_TYPE_BROWSER == 2,
               "assumes browser process type has value 2");
 constexpr uint32_t kFirstValidProcessType = content::PROCESS_TYPE_BROWSER;
 
 ModuleDatabase* g_instance = nullptr;
 
 }  // namespace
 
 ModuleDatabase::ModuleDatabase(
     scoped_refptr<base::SequencedTaskRunner> task_runner)
-    : task_runner_(std::move(task_runner)), weak_ptr_factory_(this) {}
+    : task_runner_(std::move(task_runner)),
+      module_inspector_(this),
+      weak_ptr_factory_(this) {}
 
 ModuleDatabase::~ModuleDatabase() {
   if (this == g_instance)
     g_instance = nullptr;
 }
 
 // static
 ModuleDatabase* ModuleDatabase::GetInstance() {
   return g_instance;
 }
@@ skipping 247 matching lines @@
 ModuleDatabase::ModuleInfo* ModuleDatabase::FindOrCreateModuleInfo(
     const base::FilePath& module_path,
     uint32_t module_size,
     uint32_t module_time_date_stamp) {
   auto result = modules_.emplace(
       std::piecewise_construct,
       std::forward_as_tuple(module_path, module_size, module_time_date_stamp,
                             modules_.size()),
       std::forward_as_tuple());
 
+  // New modules must be inspected.
+  if (result.second)
+    module_inspector_.AddModule(result.first->first);
+
   return &(*result.first);
 }
 
 ModuleDatabase::ProcessInfo* ModuleDatabase::GetProcessInfo(
     uint32_t process_id,
     uint64_t creation_time) {
   ProcessInfoKey key(process_id, creation_time, content::PROCESS_TYPE_UNKNOWN);
   auto it = processes_.find(key);
   if (it == processes_.end())
     return nullptr;
   return &(*it);
 }
 
 void ModuleDatabase::CreateProcessInfo(uint32_t process_id,
                                        uint64_t creation_time,
                                        content::ProcessType process_type) {
   processes_.emplace(std::piecewise_construct,
                      std::forward_as_tuple(ProcessInfoKey(
                          process_id, creation_time, process_type)),
                      std::forward_as_tuple(ProcessInfoData()));
 }
 
 void ModuleDatabase::DeleteProcessInfo(uint32_t process_id,
                                        uint64_t creation_time) {
   ProcessInfoKey key(process_id, creation_time, content::PROCESS_TYPE_UNKNOWN);
   processes_.erase(key);
 }
 
+void ModuleDatabase::OnModuleInspected(const ModuleInfoKey& module_key,
+                                       const ModuleInfoData& module_data) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  // Received the data. Copy it.
+  auto it = modules_.find(module_key);
+  if (it != modules_.end())
+    it->second.CopyInspectionData(module_data);
+}
+
 // ModuleDatabase::ProcessInfoKey ----------------------------------------------
 
 ModuleDatabase::ProcessInfoKey::ProcessInfoKey(
     uint32_t process_id,
     uint64_t creation_time,
     content::ProcessType process_type)
     : process_id(process_id),
       creation_time(creation_time),
       process_type(process_type) {}
 
 ModuleDatabase::ProcessInfoKey::~ProcessInfoKey() = default;
 
 bool ModuleDatabase::ProcessInfoKey::operator<(
     const ProcessInfoKey& pik) const {
   // The key consists of the pair of (process_id, creation_time).
   // Use the std::tuple lexicographic comparison operator.
   return std::make_tuple(process_id, creation_time) <
          std::make_tuple(pik.process_id, pik.creation_time);
 }
 
 // ModuleDatabase::ProcessInfoData ---------------------------------------------
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData() = default;
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData(const ProcessInfoData& other) =
     default;
 
 ModuleDatabase::ProcessInfoData::~ProcessInfoData() = default;