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 91 matching lines @@
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using extensions::APIPermission;
 using extensions::AppSorting;
 using extensions::CrxInstaller;
+using extensions::ExternalExtensionInstallInfoFile;
+using extensions::ExternalExtensionInstallInfoUpdateUrl;
 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) {
+    ExternalExtensionInstallInfoUpdateUrl* 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<ExternalExtensionInstallInfoUpdateUrl>&
+        update_url_extensions,
+    const ScopedVector<ExternalExtensionInstallInfoFile>& file_extensions,
+    const std::set<std::string>& removed_extensions) {
+  if (!update_url_extensions.empty() || !file_extensions.empty()) {
+    // 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_) {

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

Does the extension updater need to run if we only had entries in
|file_extensions| but not in |update_url_extensions| ? Off the top of my head I
would have guessed not.

[lazyboy, 2016/01/26 05:20:04]

Ah right, the CRX download is handled differently.
Fixed.

+      // 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);

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

Can we move the handling of uninstalls a few lines up to be before the run of
the extension updater? It would be nice to avoid the edge case of beginning to
download an update for an extension that we are going to uninstall anyway.

[lazyboy, 2016/01/26 05:20:04]

Moved.
It would be nice to avoid the edge case of beginning to
From a single provider, this shouldn't happen though, ids from
|removed_extensions| shouldn't be specified in either |update_url_extensions| or
|file_extensions|. I've added a DCHECK for that.

[asargent_no_longer_on_chrome, 2016/01/26 17:48:07]

You're right, from a single provider this should not happen. I was thinking of
the case where the item was already installed for some other reason, such as
manually by the user, or from some other external installer. (When you kick off
the extension updater, usually it asks for updates for all items.)

+
+  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) {
+    ExternalExtensionInstallInfoFile* 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);
   }
 }