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) {

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

This is a little hard to review - can you un-move these for this CL (or at least
early patch sets) so we can see the diff clearly?

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

Done.

+  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::ServiceShutdown() {
+  service_ = NULL;
+}
+
+bool ExternalProviderImpl::IsReady() const {
+  return ready_;
+}
+
+bool ExternalProviderImpl::HasExtension(
+    const std::string& id) const {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(prefs_.get());
+  CHECK(ready_);
+  return prefs_->HasKey(id);
+}
+
+bool ExternalProviderImpl::GetExtensionDetails(
+    const std::string& id, Manifest::Location* location,
+    scoped_ptr<Version>* version) const {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(prefs_.get());
+  CHECK(ready_);
+  base::DictionaryValue* extension = NULL;
+  if (!prefs_->GetDictionary(id, &extension))
+    return false;
+
+  Manifest::Location loc = Manifest::INVALID_LOCATION;
+  if (extension->HasKey(kExternalUpdateUrl)) {
+    loc = download_location_;
+
+  } else if (extension->HasKey(kExternalCrx)) {
+    loc = crx_location_;
+
+    std::string external_version;
+    if (!extension->GetString(kExternalVersion, &external_version))
+      return false;
+
+    if (version)
+      version->reset(new Version(external_version));
+
+  } else {
+    NOTREACHED();  // Chrome should not allow prefs to get into this state.
+    return false;
+  }
+
+  if (location)
+    *location = loc;
+
+  return true;
+}
+
+bool ExternalProviderImpl::HandleMinProfileVersion(
+    const base::DictionaryValue* extension,
+    const std::string& extension_id,
+    std::set<std::string>* unsupported_extensions) {
+  std::string min_profile_created_by_version;
+  if (profile_ &&
+      extension->GetString(kMinProfileCreatedByVersion,
+                           &min_profile_created_by_version)) {
+    Version profile_version(
+        profile_->GetPrefs()->GetString(prefs::kProfileCreatedByVersion));
+    Version min_version(min_profile_created_by_version);
+    if (min_version.IsValid() && profile_version.CompareTo(min_version) < 0) {
+      unsupported_extensions->insert(extension_id);
+      VLOG(1) << "Skip installing (or uninstall) external extension: "
+              << extension_id
+              << " profile.created_by_version: " << profile_version.GetString()
+              << " min_profile_created_by_version: "
+              << min_profile_created_by_version;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ExternalProviderImpl::HandleDoNotInstallForEnterprise(
+    const base::DictionaryValue* extension,
+    const std::string& extension_id,
+    std::set<std::string>* unsupported_extensions) {
+  bool do_not_install_for_enterprise = false;
+  if (extension->GetBoolean(kDoNotInstallForEnterprise,
+                            &do_not_install_for_enterprise) &&
+      do_not_install_for_enterprise) {
+    const policy::ProfilePolicyConnector* const connector =
+        policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile_);
+    if (connector->IsManaged()) {
+      unsupported_extensions->insert(extension_id);
+      VLOG(1) << "Skip installing (or uninstall) external extension "
+              << extension_id << " restricted for managed user";
+      return false;
+    }
+  }
+  return true;
+}
+
+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_;
-}
-
-bool ExternalProviderImpl::HasExtension(
-    const std::string& id) const {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(prefs_.get());
-  CHECK(ready_);
-  return prefs_->HasKey(id);
-}
-
-bool ExternalProviderImpl::GetExtensionDetails(
-    const std::string& id, Manifest::Location* location,
-    scoped_ptr<Version>* version) const {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(prefs_.get());
-  CHECK(ready_);
-  base::DictionaryValue* extension = NULL;
-  if (!prefs_->GetDictionary(id, &extension))
-    return false;
-
-  Manifest::Location loc = Manifest::INVALID_LOCATION;
-  if (extension->HasKey(kExternalUpdateUrl)) {
-    loc = download_location_;
-
-  } else if (extension->HasKey(kExternalCrx)) {
-    loc = crx_location_;
-
-    std::string external_version;
-    if (!extension->GetString(kExternalVersion, &external_version))
-      return false;
-
-    if (version)
-      version->reset(new Version(external_version));
-
-  } else {
-    NOTREACHED();  // Chrome should not allow prefs to get into this state.
-    return false;
-  }
-
-  if (location)
-    *location = loc;
-
-  return true;
-}
-
-bool ExternalProviderImpl::HandleMinProfileVersion(
-    const base::DictionaryValue* extension,
-    const std::string& extension_id,
-    std::set<std::string>* unsupported_extensions) {
-  std::string min_profile_created_by_version;
-  if (profile_ &&
-      extension->GetString(kMinProfileCreatedByVersion,
-                           &min_profile_created_by_version)) {
-    Version profile_version(
-        profile_->GetPrefs()->GetString(prefs::kProfileCreatedByVersion));
-    Version min_version(min_profile_created_by_version);
-    if (min_version.IsValid() && profile_version.CompareTo(min_version) < 0) {
-      unsupported_extensions->insert(extension_id);
-      VLOG(1) << "Skip installing (or uninstall) external extension: "
-              << extension_id
-              << " profile.created_by_version: " << profile_version.GetString()
-              << " min_profile_created_by_version: "
-              << min_profile_created_by_version;
-      return false;
-    }
-  }
-  return true;
-}
-
-bool ExternalProviderImpl::HandleDoNotInstallForEnterprise(
-    const base::DictionaryValue* extension,
-    const std::string& extension_id,
-    std::set<std::string>* unsupported_extensions) {
-  bool do_not_install_for_enterprise = false;
-  if (extension->GetBoolean(kDoNotInstallForEnterprise,
-                            &do_not_install_for_enterprise) &&
-      do_not_install_for_enterprise) {
-    const policy::ProfilePolicyConnector* const connector =
-        policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile_);
-    if (connector->IsManaged()) {
-      unsupported_extensions->insert(extension_id);
-      VLOG(1) << "Skip installing (or uninstall) external extension "
-              << extension_id << " restricted for managed user";
-      return false;
-    }
-  }
-  return true;
 }
 
 // static
 void ExternalProviderImpl::CreateExternalProviders(
     VisitorInterface* service,
     Profile* profile,
     ProviderCollection* provider_list) {
   TRACE_EVENT0("browser,startup",
                "ExternalProviderImpl::CreateExternalProviders");
   scoped_refptr<ExternalLoader> external_loader;
@@ skipping 251 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