Observe adding external extensions via windows registry.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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/extension_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 96 matching lines @@
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using extensions::APIPermission;
 using extensions::AppSorting;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
+using extensions::ExternalProviderInterface;
 using extensions::FeatureSwitch;
 using extensions::InstallVerifier;
 using extensions::ManagementPolicy;
 using extensions::Manifest;
 using extensions::PermissionID;
 using extensions::PermissionIDSet;
 using extensions::PermissionSet;
 using extensions::SharedModuleInfo;
 using extensions::SharedModuleService;
 using extensions::UnloadedExtensionInfo;
@@ skipping 40 matching lines @@
 void ExtensionService::SetFileTaskRunnerForTesting(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   file_task_runner_ = task_runner;
 }
 
 void ExtensionService::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
 
 void ExtensionService::AddProviderForTesting(
-    extensions::ExternalProviderInterface* test_provider) {
+    ExternalProviderInterface* test_provider) {
   CHECK(test_provider);
   external_extension_providers_.push_back(
-      linked_ptr<extensions::ExternalProviderInterface>(test_provider));
+      linked_ptr<ExternalProviderInterface>(test_provider));
 }
 
 void ExtensionService::BlacklistExtensionForTest(
     const std::string& extension_id) {
   ExtensionIdSet blacklisted;
   ExtensionIdSet unchanged;
   blacklisted.insert(extension_id);
   UpdateBlacklistedExtensions(blacklisted, unchanged);
 }
 
 bool ExtensionService::OnExternalExtensionUpdateUrlFound(
-    const std::string& id,
-    const std::string& install_parameter,
-    const GURL& update_url,
-    Manifest::Location location,
-    int creation_flags,
-    bool mark_acknowledged) {
+    ExternalProviderInterface::UpdateUrlExtensionInfo* info,
+    bool is_initial_load) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(crx_file::id_util::IdIsValid(id));
+  CHECK(crx_file::id_util::IdIsValid(info->extension_id));
 
-  if (Manifest::IsExternalLocation(location)) {
+  if (Manifest::IsExternalLocation(info->download_location)) {
     // All extensions that are not user specific can be cached.
-    extensions::ExtensionsBrowserClient::Get()->GetExtensionCache()
-        ->AllowCaching(id);
+    extensions::ExtensionsBrowserClient::Get()
+        ->GetExtensionCache()
+        ->AllowCaching(info->extension_id);
   }
 
-  const Extension* extension = GetExtensionById(id, true);
+  const Extension* extension = GetExtensionById(info->extension_id, true);
   if (extension) {
     // Already installed. Skip this install if the current location has
-    // higher priority than |location|.
+    // higher priority than |info->download_location|.
     Manifest::Location current = extension->location();
-    if (current == Manifest::GetHigherPriorityLocation(current, location))
+    if (current ==
+        Manifest::GetHigherPriorityLocation(current, info->download_location)) {
       return false;
+    }
     // Otherwise, overwrite the current installation.
   }
 
-  // Add |id| to the set of pending extensions.  If it can not be added,
-  // then there is already a pending record from a higher-priority install
-  // source.  In this case, signal that this extension will not be
+  // Add |info->extension_id| to the set of pending extensions.  If it can not
+  // be added, then there is already a pending record from a higher-priority
+  // install source.  In this case, signal that this extension will not be
   // installed by returning false.
   if (!pending_extension_manager()->AddFromExternalUpdateUrl(
-          id,
-          install_parameter,
-          update_url,
-          location,
-          creation_flags,
-          mark_acknowledged)) {
+          info->extension_id, info->install_parameter, *info->update_url,
+          info->download_location, info->creation_flags,
+          info->mark_acknowledged)) {
     return false;
   }
 
-  update_once_all_providers_are_ready_ = true;
+  if (is_initial_load)
+    update_once_all_providers_are_ready_ = true;
   return true;
 }
 
+void ExtensionService::OnExternalProviderUpdateComplete(
+    const ExternalProviderInterface* provider,
+    const ScopedVector<ExternalProviderInterface::UpdateUrlExtensionInfo>&
+        update_url_extensions,
+    const ScopedVector<ExternalProviderInterface::FileExtensionInfo>&
+        file_extensions,
+    const std::set<std::string>& removed_extensions) {
+  if (!update_url_extensions.empty() || !file_extensions.empty()) {

[lazyboy, 2016/01/22 07:52:41]

@asargent: I've added this guard we talked about offline.

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

Acknowledged.

+    // Update pending_extension_manager() with the new extensions first.
+    for (const auto& extension : update_url_extensions)
+      OnExternalExtensionUpdateUrlFound(extension, false);
+    for (const auto& extension : file_extensions)
+      OnExternalExtensionFileFound(extension);
+
+    if (updater_) {
+      // Empty params will cause pending extensions to be updated.
+      extensions::ExtensionUpdater::CheckParams empty_params;
+      updater_->CheckNow(empty_params);
+    }
+  }
+
+  for (const std::string& id : removed_extensions)
+    CheckExternalUninstall(id);
+
+  error_controller_->ShowErrorIfNeeded();
+  external_install_manager_->UpdateExternalExtensionAlert();
+}
+
 // static
 // This function is used to uninstall an extension via sync.  The LOG statements
 // within this function are used to inform the user if the uninstall cannot be
 // done.
 bool ExtensionService::UninstallExtensionHelper(
     ExtensionService* extensions_service,
     const std::string& extension_id,
     extensions::UninstallReason reason) {
   // We can't call UninstallExtension with an invalid extension ID.
   if (!extensions_service->GetInstalledExtension(extension_id)) {
@@ skipping 118 matching lines @@
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
 
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
-    extensions::ExternalProviderInterface* provider = i->get();
+    ExternalProviderInterface* provider = i->get();
     provider->ServiceShutdown();
   }
 }
 
 void ExtensionService::Shutdown() {
   extensions::ExtensionManagementFactory::GetInstance()
       ->GetForBrowserContext(profile())
       ->RemoveObserver(this);
 }
 
@@ skipping 883 matching lines @@
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
-    extensions::ExternalProviderInterface* provider = i->get();
+    ExternalProviderInterface* provider = i->get();
     provider->VisitRegisteredExtension();
   }
 
   // Do any required work that we would have done after completion of all
   // providers.
   if (external_extension_providers_.empty())
     OnAllExternalProvidersReady();
 }
 
 void ExtensionService::OnExternalProviderReady(
-    const extensions::ExternalProviderInterface* provider) {
+    const ExternalProviderInterface* provider) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(provider->IsReady());
 
   // An external provider has finished loading.  We only take action
   // if all of them are finished. So we check them first.
   if (AreAllExternalProvidersReady())
     OnAllExternalProvidersReady();
 }
 
 bool ExtensionService::AreAllExternalProvidersReady() const {
@@ skipping 702 matching lines @@
         content::Details<const Extension>(extension));
   }
 }
 
 const Extension* ExtensionService::GetInstalledExtension(
     const std::string& id) const {
   return registry_->GetExtensionById(id, ExtensionRegistry::EVERYTHING);
 }
 
 bool ExtensionService::OnExternalExtensionFileFound(
-         const std::string& id,
-         const Version* version,
-         const base::FilePath& path,
-         Manifest::Location location,
-         int creation_flags,
-         bool mark_acknowledged,
-         bool install_immediately) {
+    ExternalProviderInterface::FileExtensionInfo* info) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(crx_file::id_util::IdIsValid(id));
-  if (extension_prefs_->IsExternalExtensionUninstalled(id))
+  CHECK(crx_file::id_util::IdIsValid(info->extension_id));
+  if (extension_prefs_->IsExternalExtensionUninstalled(info->extension_id))
     return false;
 
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get
   // installed on every startup.
-  const Extension* existing = GetExtensionById(id, true);
+  const Extension* existing = GetExtensionById(info->extension_id, true);
 
   if (existing) {
     // The default apps will have the location set as INTERNAL. Since older
     // default apps are installed as EXTERNAL, we override them. However, if the
     // app is already installed as internal, then do the version check.
     // TODO(grv) : Remove after Q1-2013.
     bool is_default_apps_migration =
-        (location == Manifest::INTERNAL &&
+        (info->crx_location == Manifest::INTERNAL &&
          Manifest::IsExternalLocation(existing->location()));
 
     if (!is_default_apps_migration) {
-      DCHECK(version);
+      DCHECK(info->version.get());
 
-      switch (existing->version()->CompareTo(*version)) {
+      switch (existing->version()->CompareTo(*info->version)) {
         case -1:  // existing version is older, we should upgrade
           break;
         case 0:  // existing version is same, do nothing
           return false;
         case 1:  // existing version is newer, uh-oh
-          LOG(WARNING) << "Found external version of extension " << id
+          LOG(WARNING) << "Found external version of extension "
+                       << info->extension_id
                        << "that is older than current version. Current version "
                        << "is: " << existing->VersionString() << ". New "
-                       << "version is: " << version->GetString()
+                       << "version is: " << info->version->GetString()
                        << ". Keeping current version.";
           return false;
       }
     }
   }
 
   // If the extension is already pending, don't start an install.
   if (!pending_extension_manager()->AddFromExternalFile(
-          id, location, *version, creation_flags, mark_acknowledged)) {
+          info->extension_id, info->crx_location, *info->version,
+          info->creation_flags, info->mark_acknowledged)) {
     return false;
   }
 
   // no client (silent install)
   scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(this));
-  installer->set_install_source(location);
-  installer->set_expected_id(id);
-  installer->set_expected_version(*version,
+  installer->set_install_source(info->crx_location);
+  installer->set_expected_id(info->extension_id);
+  installer->set_expected_version(*info->version,
                                   true /* fail_install_if_unexpected */);
   installer->set_install_cause(extension_misc::INSTALL_CAUSE_EXTERNAL_FILE);
-  installer->set_install_immediately(install_immediately);
-  installer->set_creation_flags(creation_flags);
+  installer->set_install_immediately(info->install_immediately);
+  installer->set_creation_flags(info->creation_flags);
 #if defined(OS_CHROMEOS)
-  extensions::InstallLimiter::Get(profile_)->Add(installer, path);
+  extensions::InstallLimiter::Get(profile_)->Add(installer, info->path);
 #else
-  installer->InstallCrx(path);
+  installer->InstallCrx(info->path);
 #endif
 
   // Depending on the source, a new external extension might not need a user
   // notification on installation. For such extensions, mark them acknowledged
   // now to suppress the notification.
-  if (mark_acknowledged)
-    external_install_manager_->AcknowledgeExternalExtension(id);
+  if (info->mark_acknowledged)
+    external_install_manager_->AcknowledgeExternalExtension(info->extension_id);
 
   return true;
 }
 
 void ExtensionService::DidCreateRenderViewForBackgroundPage(
     extensions::ExtensionHost* host) {
   OrphanedDevTools::iterator iter =
       orphaned_dev_tools_.find(host->extension_id());
   if (iter == orphaned_dev_tools_.end())
     return;
@@ skipping 373 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }