Implement install module verification metric.

chrome/browser/install_module_verifier_win.cc

Index: chrome/browser/install_module_verifier_win.cc
diff --git a/chrome/browser/install_module_verifier_win.cc b/chrome/browser/install_module_verifier_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cbda06414a62f228950bdcb1b40ce2b14a9bcebc
--- /dev/null
+++ b/chrome/browser/install_module_verifier_win.cc
@@ -0,0 +1,98 @@
+// Copyright (c) 2013 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/install_module_verifier_win.h"
+
+#include <set>
+#include <string>
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/metrics/sparse_histogram.h"
+#include "base/values.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/enumerate_modules_model_win.h"
+#include "chrome/browser/expected_install_modules_win.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+
+namespace {
+
+void OnModuleMatch(unsigned int module_id) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("InstallVerifier.ModuleMatch", module_id);
+}
+
+class InstallModuleVerifier : public content::NotificationObserver {
+ public:
+  InstallModuleVerifier() {
+    notification_registrar_.Add(this,
+                                chrome::NOTIFICATION_MODULE_LIST_ENUMERATED,
+                                content::NotificationService::AllSources());

[robertshield, 2013/09/13 17:26:05]

<ignore-this-comment>ugh, notifications</ignore-this-comment>

[erikwright (departed), 2013/09/16 20:04:55]

Done.

+  }
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE {
+    EnumerateModulesModel* model =
+        content::Source<EnumerateModulesModel>(source).ptr();
+    scoped_ptr<base::ListValue> module_list(model->GetModuleList());
+
+    if (module_list.get()) {
+      VerifyInstalledModules(module_list.get(), base::Bind(&OnModuleMatch));
+    }
+    delete this;
+  }
+
+ private:
+  content::NotificationRegistrar notification_registrar_;
+  DISALLOW_COPY_AND_ASSIGN(InstallModuleVerifier);
+};
+
+}  // namespace
+
+void InitiateInstalledModuleVerification() {
+  scoped_ptr<base::ListValue> module_list(
+      EnumerateModulesModel::GetInstance()->GetModuleList());
+  if (module_list.get()) {
+    VerifyInstalledModules(module_list.get(),
+                           base::Bind(&OnModuleMatch));
+  } else {
+    // Will delete itself when scan results are available.
+    new InstallModuleVerifier();
+    EnumerateModulesModel::GetInstance()->ScanNow();
+  }
+}
+
+void VerifyInstalledModules(
+    base::ListValue* module_list,
+    const base::Callback<void(unsigned int)>& delegate) {
+  std::set<std::string> module_name_digests;
+  for (size_t i = 0; i < module_list->GetSize(); ++i) {
+    base::DictionaryValue* module_dictionary = NULL;
+    if (!module_list->GetDictionary(i, &module_dictionary))
+      continue;
+    ModuleEnumerator::ModuleType module_type =
+        ModuleEnumerator::LOADED_MODULE;
+    if (!module_dictionary->GetInteger(
+            "type", reinterpret_cast<int*>(&module_type)) ||
+        module_type != ModuleEnumerator::LOADED_MODULE) {
+      continue;
+    }
+    std::string module_name;
+    if (!module_dictionary->GetString("name", &module_name))
+      continue;
+
+    std::string module_name_digest =
+        CalculateInstalledModuleDigest(module_name);
+    module_name_digests.insert(module_name_digest);
+  }
+  for (size_t i = 0; kExpectedInstallModuleDigests[i] != 0; ++i) {

[robertshield, 2013/09/13 17:26:05]

nit: i -> module_id

[MAD, 2013/09/13 20:15:33]

You could avoid having a 0 at the end if you compared with
arraysize(kExpectedInstallModuleDigests).

[erikwright (departed), 2013/09/13 20:19:56]

arraysize doesn't work with pointers like this. It might work if the header
defined the size of the array, but that's not practical here. See basictypes.h
and note that arraysize is a template that requires the size of the array to be
inferred from its type at compile time.

[MAD, 2013/09/13 20:34:39]

I don't understand. Why do you say that the size is not known at compile time? I
use arraysize for const char* arrays like this and it works fine... What am I
missing?

[erikwright (departed), 2013/09/16 20:04:55]

Done.

+    if (module_name_digests.find(kExpectedInstallModuleDigests[i]) !=
+        module_name_digests.end()) {
+      delegate.Run(i);
+    }
+  }
+}