Observe adding external extensions via windows registry.

chrome/browser/extensions/external_registry_loader_win.cc

Index: chrome/browser/extensions/external_registry_loader_win.cc
diff --git a/chrome/browser/extensions/external_registry_loader_win.cc b/chrome/browser/extensions/external_registry_loader_win.cc
index 0b5a67f83687c838b7723790af6f0953dc435e9f..bdda83fc1f8ac7871cedafe6c5c56bb4b3356dd1 100644
--- a/chrome/browser/extensions/external_registry_loader_win.cc
+++ b/chrome/browser/extensions/external_registry_loader_win.cc
@@ -61,9 +61,8 @@ void ExternalRegistryLoader::StartLoading() {
       base::Bind(&ExternalRegistryLoader::LoadOnFileThread, this));
 }
 
-void ExternalRegistryLoader::LoadOnFileThread() {
+void ExternalRegistryLoader::LoadPrefsOnFileThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  base::TimeTicks start_time = base::TimeTicks::Now();
   scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
 
   // A map of IDs, to weed out duplicates between HKCU and HKLM.
@@ -183,11 +182,74 @@ void ExternalRegistryLoader::LoadOnFileThread() {
   }
 
   prefs_.reset(prefs.release());
+}
+
+void ExternalRegistryLoader::LoadOnFileThread() {
+  base::TimeTicks start_time = base::TimeTicks::Now();
+  LoadPrefsOnFileThread();
   LOCAL_HISTOGRAM_TIMES("Extensions.ExternalRegistryLoaderWin",
                         base::TimeTicks::Now() - start_time);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalRegistryLoader::LoadFinished, this));
+      base::Bind(
+          &ExternalRegistryLoader::CompleteLoadAndStartWatchingRegistry, this));
+}
+
+void ExternalRegistryLoader::CompleteLoadAndStartWatchingRegistry() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LoadFinished();
+
+  // Start watching registry.
+  // TODO(lazyboy): Is using KEY_WOW64_32KEY correct?
+  if (hklm_key_.Create(HKEY_LOCAL_MACHINE,
+                       kRegistryExtensions,
+                       KEY_NOTIFY | KEY_WOW64_32KEY) == ERROR_SUCCESS) {

[scottmg, 2016/01/21 21:16:16]

How are these keys set? Is this because the installer is 32-bit only? Otherwise
I'd just expect the registry to want to retrieve it's natural bitness.

[lazyboy, 2016/01/21 21:24:47]

I'm not sure about this one (as the TODO suggests):
Two clues I've used to specify this:
1) Line 73 above uses this while iterating through HKLM keys.
2) The documentation in
https://developer.chrome.com/extensions/external_extensions#registry
suggests adding registry entries under ..\WOW6432Node\

[asargent_no_longer_on_chrome, 2016/01/25 18:50:52]

These registry entries are written by third party programs (eg antivirus or
other programs that have a companion chrome extension they want to offer to the
user), so maybe it could be the case that their installer is 32 bit even if
chrome is 64 bit. Also it's possible we used to only tell developers "write to
HKLM\Software\Google\Chrome\Extensions" and later added the advice about the
Wow6432Node registry path, so some 64 bit installers might have used the 32 bit
path.

[lazyboy, 2016/01/26 05:20:04]

I'll drop by to talk to you person about this one and fix.

[lazyboy, 2016/01/26 23:44:43]

After chatting /w asargent@, I've removed the TODO because it seems we need
WOW64_32KEY.
Chrome extension's external provider mechanism always reads the 32-bit registry:
https://developer.chrome.com/extensions/external_extensions#registry
Also the code at line #73 agrees with that, i.e. the initial registry reading
also reads the key from 32-bit.

+    base::win::RegKey::ChangeCallback callback =
+        base::Bind(&ExternalRegistryLoader::OnRegistryKeyChanged,
+                   base::Unretained(this),
+                   base::Unretained(&hklm_key_));
+    hklm_key_.StartWatching(callback);
+  } else {
+    // TODO(lazyboy): Error handling.
+    LOG(ERROR) << "Error observing HKLM.";
+  }
+
+  if (hkcu_key_.Create(HKEY_CURRENT_USER,
+                       kRegistryExtensions,
+                       KEY_NOTIFY) == ERROR_SUCCESS) {
+    base::win::RegKey::ChangeCallback callback =
+        base::Bind(&ExternalRegistryLoader::OnRegistryKeyChanged,
+                   base::Unretained(this),
+                   base::Unretained(&hkcu_key_));
+    hkcu_key_.StartWatching(callback);
+  } else {
+    // TODO(lazyboy): Error handling.
+    LOG(ERROR) << "Error observing HKCU.";
+  }
+}
+
+void ExternalRegistryLoader::OnRegistryKeyChanged(base::win::RegKey* key) {
+  // |OnRegistryKeyChanged| is removed as an observer when the ChangeCallback is
+  // called, so we need to re-register.
+  key->StartWatching(
+      base::Bind(&ExternalRegistryLoader::OnRegistryKeyChanged,
+                 base::Unretained(this),
+                 base::Unretained(key)));
+
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&ExternalRegistryLoader::UpdatePrefsOnFileThread, this));
+}
+
+void ExternalRegistryLoader::UpdatePrefsOnFileThread() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  base::TimeTicks start_time = base::TimeTicks::Now();
+  LoadPrefsOnFileThread();
+  LOCAL_HISTOGRAM_TIMES("Extensions.ExternalRegistryLoaderWinUpdate",
+                        base::TimeTicks::Now() - start_time);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&ExternalRegistryLoader::OnUpdated, this));
 }
 
 }  // namespace extensions