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 102 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.
 
+  ScopedVector<ExternalExtensionInstallInfoUpdateUrl>
+      external_update_url_extensions;
+  ScopedVector<ExternalExtensionInstallInfoFile> external_file_extensions;
+
+  RetrieveExtensionsFromPrefs(&external_update_url_extensions,
+                              &external_file_extensions);
+  for (const auto& extension : external_update_url_extensions)
+    service_->OnExternalExtensionUpdateUrlFound(extension, true);
+
+  for (const auto& extension : external_file_extensions)
+    service_->OnExternalExtensionFileFound(extension);
+
+  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);
+
+  ScopedVector<ExternalExtensionInstallInfoUpdateUrl>
+      external_update_url_extensions;
+  ScopedVector<ExternalExtensionInstallInfoFile> external_file_extensions;
+  RetrieveExtensionsFromPrefs(&external_update_url_extensions,
+                              &external_file_extensions);
+
+  // Notify ExtensionService about completion of finding incremental updates
+  // from this provider.
+  // Provide the list of added and removed extensions.
+  service_->OnExternalProviderUpdateComplete(
+      this, external_update_url_extensions, external_file_extensions,
+      removed_extensions);
+}
+
+void ExternalProviderImpl::RetrieveExtensionsFromPrefs(
+    ScopedVector<ExternalExtensionInstallInfoUpdateUrl>*
+        external_update_url_extensions,
+    ScopedVector<ExternalExtensionInstallInfoFile>* external_file_extensions) {
   // 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.
+  // Discover 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 "
                    << extension_id.c_str() << " is not a valid id.";
       continue;
     }
 
@@ skipping 145 matching lines @@
       if (!path.IsAbsolute()) {
         base::FilePath base_path = loader_->GetBaseCrxFilePath();
         if (base_path.empty()) {
           LOG(WARNING) << "File path " << external_crx.c_str()
                        << " is relative.  An absolute path is required.";
           continue;
         }
         path = base_path.Append(external_crx);
       }
 
-      Version version(external_version);
-      if (!version.IsValid()) {
+      scoped_ptr<Version> version(new Version(external_version));
+      if (!version->IsValid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Invalid version string \""
                      << external_version << "\".";
         continue;
       }
-      service_->OnExternalExtensionFileFound(extension_id, &version, path,
-                                             crx_location_, creation_flags,
-                                             auto_acknowledge_,
-                                             install_immediately_);
+      external_file_extensions->push_back(new ExternalExtensionInstallInfoFile(
+          extension_id, std::move(version), path, crx_location_, creation_flags,
+          auto_acknowledge_, install_immediately_));
     } else {  // if (has_external_update_url)
       CHECK(has_external_update_url);  // Checking of keys above ensures this.
       if (download_location_ == Manifest::INVALID_LOCATION) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from update URLs.";
         continue;
       }
-      GURL update_url(external_update_url);
-      if (!update_url.is_valid()) {
+      scoped_ptr<GURL> update_url(new GURL(external_update_url));
+      if (!update_url->is_valid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << 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_);
+      external_update_url_extensions->push_back(
+          new ExternalExtensionInstallInfoUpdateUrl(
+              extension_id, install_parameter, std::move(update_url),
+              download_location_, creation_flags, auto_acknowledge_));
     }
   }
 
   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