Observe adding external extensions via windows registry.

chrome/browser/extensions/external_provider_impl.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_provider_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 101 matching lines @@
 
 void ExternalProviderImpl::SetPrefs(base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the service is still alive. It is possible that it went
   // away while |loader_| was working on the FILE thread.
   if (!service_) return;
 
   prefs_.reset(prefs);
   ready_ = true;  // Queries for extensions are allowed from this point.
+  NotifyExtensionsFromPrefs(true);
+  service_->OnExternalProviderReady(this);
+}
 
+void ExternalProviderImpl::UpdatePrefs(base::DictionaryValue* prefs) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // We only expect updates from windows registry.
+  CHECK(crx_location_ == Manifest::EXTERNAL_REGISTRY);
+
+  // Check if the service is still alive. It is possible that it went
+  // away while |loader_| was working on the FILE thread.
+  if (!service_)
+    return;
+
+  std::set<std::string> removed_extensions;
+  // Find extensions that were removed by this ExternalProvider.
+  for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) {
+    const std::string& extension_id = i.key();
+    // Don't bother about invalid ids.
+    if (!crx_file::id_util::IdIsValid(extension_id))
+      continue;
+    if (!prefs->HasKey(extension_id))
+      removed_extensions.insert(extension_id);
+  }
+
+  prefs_.reset(prefs);
+
+  // Notify ExtensionService about all the extension this provider has found
+  // "updates" for.
+  // For each update found, this will end up calling
+  // OnExternalExtensionUpdateUrlFound() or OnExternalExtensionFileFound().
+  NotifyExtensionsFromPrefs(false);
+  // Then notify about the completion of update, with list of extensions that
+  // were removed.
+  service_->OnExternalProviderUpdateComplete(this, removed_extensions);
+}
+
+void ExternalProviderImpl::NotifyExtensionsFromPrefs(bool is_initial_load) {
   // Set of unsupported extensions that need to be deleted from prefs_.
   std::set<std::string> unsupported_extensions;
 
   // Notify ExtensionService about all the extensions this provider has.
   for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) {
     const std::string& extension_id = i.key();
     const base::DictionaryValue* extension = NULL;
 
     if (!crx_file::id_util::IdIsValid(extension_id)) {
       LOG(WARNING) << "Malformed extension dictionary: key "
@@ skipping 180 matching lines @@
                      << extension_id.c_str() << ".  Key " << kExternalUpdateUrl
                      << " has value \"" << external_update_url
                      << "\", which is not a valid URL.";
         continue;
       }
       service_->OnExternalExtensionUpdateUrlFound(extension_id,
                                                   install_parameter,
                                                   update_url,
                                                   download_location_,
                                                   creation_flags,
-                                                  auto_acknowledge_);
+                                                  auto_acknowledge_,
+                                                  is_initial_load);
     }
   }
 
   for (std::set<std::string>::iterator it = unsupported_extensions.begin();
        it != unsupported_extensions.end(); ++it) {
     // Remove extension for the list of know external extensions. The extension
     // will be uninstalled later because provider doesn't provide it anymore.
     prefs_->Remove(*it, NULL);
   }
-
-  service_->OnExternalProviderReady(this);
 }
 
 void ExternalProviderImpl::ServiceShutdown() {
   service_ = NULL;
 }
 
 bool ExternalProviderImpl::IsReady() const {
   return ready_;
 }
 
@@ skipping 346 matching lines @@
       new ExternalProviderImpl(
           service,
           new ExternalComponentLoader(profile),
           profile,
           Manifest::INVALID_LOCATION,
           Manifest::EXTERNAL_COMPONENT,
           Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
 }
 
 }  // namespace extensions