Add the ThirdPartyModules.Uninstallable histogram.

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"
+#include "chrome/browser/conflicts/module_database_observer_win.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)),
       // ModuleDatabase owns |module_inspector_|, so it is safe to use
       // base::Unretained().
       module_inspector_(base::Bind(&ModuleDatabase::OnModuleInspected,
                                    base::Unretained(this))),
+      third_party_metrics_(this),
       weak_ptr_factory_(this) {}
 
 ModuleDatabase::~ModuleDatabase() {
   if (this == g_instance)
     g_instance = nullptr;
 }
 
 // static
 ModuleDatabase* ModuleDatabase::GetInstance() {
   return g_instance;
@@ skipping 102 matching lines @@
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ModuleDatabase::OnProcessEnded,
                    weak_ptr_factory_.GetWeakPtr(), process_id, creation_time));
     return;
   }
 
   DeleteProcessInfo(process_id, creation_time);
 }
 
+void ModuleDatabase::AddObserver(ModuleDatabaseObserver* observer) {
+  observer_list_.AddObserver(observer);
+  for (const auto& module : modules_) {
+    if (module.second.inspection_result)
+      observer->OnNewModuleFound(module.first, module.second);
+  }
+}
+
+void ModuleDatabase::RemoveObserver(ModuleDatabaseObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 // static
 uint32_t ModuleDatabase::ProcessTypeToBit(content::ProcessType process_type) {
   uint32_t bit_index =
       static_cast<uint32_t>(process_type) - kFirstValidProcessType;
   DCHECK_GE(31u, bit_index);
   uint32_t bit = (1 << bit_index);
   return bit;
 }
 
 // static
@@ skipping 165 matching lines @@
   ProcessInfoKey key(process_id, creation_time, content::PROCESS_TYPE_UNKNOWN);
   processes_.erase(key);
 }
 
 void ModuleDatabase::OnModuleInspected(
     const ModuleInfoKey& module_key,
     std::unique_ptr<ModuleInspectionResult> inspection_result) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   auto it = modules_.find(module_key);
-  if (it != modules_.end())
-    it->second.inspection_result = std::move(inspection_result);
+  if (it == modules_.end())
+    return;
+
+  it->second.inspection_result = std::move(inspection_result);
+
+  for (auto& observer : observer_list_)
+    observer.OnNewModuleFound(it->first, it->second);
 }
 
 // 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);
+  return std::tie(process_id, creation_time) <

[chrisha, 2017/05/02 21:28:25]

I always forget about 'tie'....

+         std::tie(pik.process_id, pik.creation_time);
 }
 
 // ModuleDatabase::ProcessInfoData ---------------------------------------------
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData() = default;
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData(const ProcessInfoData& other) =
     default;
 
 ModuleDatabase::ProcessInfoData::~ProcessInfoData() = default;