Observe adding external extensions via windows registry.

chrome/browser/extensions/external_registry_loader_win.cc

 // Copyright (c) 2012 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/extensions/external_registry_loader_win.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
@@ skipping 43 matching lines @@
 
 namespace extensions {
 
 void ExternalRegistryLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       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.
   std::set<base::string16> keys;
   base::win::RegistryKeyIterator iterator_machine_key(
       HKEY_LOCAL_MACHINE,
       kRegistryExtensions,
       KEY_WOW64_32KEY);
   for (; iterator_machine_key.Valid(); ++iterator_machine_key)
     keys.insert(iterator_machine_key.Name());
@@ skipping 99 matching lines @@
         base::UTF16ToASCII(extension_version));
     prefs->SetString(
         MakePrefName(id, ExternalProviderImpl::kExternalCrx),
         extension_path_str);
     prefs->SetBoolean(
         MakePrefName(id, ExternalProviderImpl::kMayBeUntrusted),
         true);
   }
 
   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) {
+    base::win::RegKey::ChangeCallback callback =
+        base::Bind(&ExternalRegistryLoader::OnRegistryKeyChanged,
+                   base::Unretained(this),

[asargent_no_longer_on_chrome, 2016/01/20 22:49:00]

I know that reading from the registry must be done on the file thread because
the operations can possibly block - do you know whether the listener stuff can
be safely used on the UI thread without introducing long delays?

Unfortunately the comments in base/win/registry.h don't have much to say on the
matter, but it would be nice to find out from one of our windows experts like
scottmg (if you haven't already) and then update the comments there. 

[lazyboy, 2016/01/21 21:02:12]

I've based my changes on plugin_service_impl.cc, which seems to be
doing very similar stuff. 
+scottmg.

+                   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) {
+  key->StartWatching(

[Devlin, 2016/01/21 00:14:26]

Save the reader the lookup into win/registry.h with a comment like:
// This is removed as an observer when the ChangeCallback is called, so we need
to re-register.

[lazyboy, 2016/01/21 21:02:12]

Done.

+      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