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 176 matching lines @@
   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) {
+    bool mark_acknowledged,
+    bool is_initial_load) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(crx_file::id_util::IdIsValid(id));
 
   if (Manifest::IsExternalLocation(location)) {
     // All extensions that are not user specific can be cached.
     extensions::ExtensionsBrowserClient::Get()->GetExtensionCache()
         ->AllowCaching(id);
   }
 
   const Extension* extension = GetExtensionById(id, true);
@@ skipping 13 matching lines @@
   if (!pending_extension_manager()->AddFromExternalUpdateUrl(
           id,
           install_parameter,
           update_url,
           location,
           creation_flags,
           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 extensions::ExternalProviderInterface* provider,
+    const std::set<std::string>& removed_extensions) {
+  if (updater_) {
+    // Empty params will cause pending extensions to be updated.
+    extensions::ExtensionUpdater::CheckParams empty_params;
+    updater_->CheckNow(empty_params);

[asargent_no_longer_on_chrome, 2016/01/20 22:49:00]

It seems a little unfortunate to kick off an update check unconditionally (and
furthermore one that checks for all currently installed extensions), when
presumably we could know beforehand whether or not we have a new extension to
install via update url, and what its id is.

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

This should not kick off update check for all currently installed
extensions, only the ones pending_install_manager knows about, which
would be the new ones. b/c OnExternalExtensionUpdateUrlFound() skips
the extensions that are currently installed.

, when
It is possible to get those ids if Provider stores a copy of the registry and
calculates the "diff".
But that requires more code changes.

In that scenario:
When provider sees a registry change, compares it to the
current registry, calculate newly found ids and removed ids,
then pass them to this function here.

for each newly found items,
call OnExternal(ExtensionUpdateUrl|File)Found() with those ids.
Note that we probably need to store/retrieve the params of those functions
somehow in this
case, these include:
update_url,
ExternalProviderImpl::crx_location_,
creation_flags,
ExternalProviderImpl::auto_acknowledge_
ExternalProviderImpl::install_immediately_
install_parameter,
ExternalProviderImpl::download_location_,
ExternalProviderImpl::auto_acknowledge_
We can package these in a struct and send them as params instead of just ids.

In terms of actual work done, this is roughly equivalent to what we have in this
CL
though.

Thoughts?

+  }
+
+  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 2220 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);
   }
 }