Auto-install/uninstall shared module dependencies for extensions.

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 <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 62 matching lines @@
 #include "chrome/browser/ui/webui/ntp/thumbnail_source.h"
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
+#include "chrome/common/extensions/manifest_handlers/shared_module_info.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/startup_metric_utils.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 22 matching lines @@
 using content::PluginService;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
+using extensions::SharedModuleInfo;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // Histogram values for logging events related to externally installed
 // extensions.
 enum ExternalExtensionEvent {
   EXTERNAL_EXTENSION_INSTALLED = 0,
@@ skipping 15 matching lines @@
 const char* kNaClPluginMimeType = "application/x-nacl";
 
 static bool IsSyncableExtension(const Extension& extension) {
   return extension.GetSyncType() == Extension::SYNC_TYPE_EXTENSION;
 }
 
 static bool IsSyncableApp(const Extension& extension) {
   return extension.GetSyncType() == Extension::SYNC_TYPE_APP;
 }
 
+static bool IsSharedModule(const Extension& extension) {
+  return SharedModuleInfo::IsSharedModule(&extension);
+}
+
 }  // namespace
 
 ExtensionService::ExtensionRuntimeData::ExtensionRuntimeData()
     : background_page_ready(false),
       being_upgraded(false),
       has_used_webrequest(false) {
 }
 
 ExtensionService::ExtensionRuntimeData::~ExtensionRuntimeData() {
 }
@@ skipping 687 matching lines @@
       sync_change.sync_data().GetDataType() == syncer::APPS) {
     app_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   } else if (extension_sync_bundle_.HasExtensionId(extension_id) &&
              sync_change.sync_data().GetDataType() == syncer::EXTENSIONS) {
     extension_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   }
 
   delayed_updates_for_idle_.Remove(extension_id);
   delayed_installs_.Remove(extension_id);
 
+  PruneSharedModulesOnUninstall(extension);
+
   // Track the uninstallation.
   UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionUninstalled", 1, 2);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
   if (extensions_.Contains(extension_id) ||
       terminated_extensions_.Contains(extension_id)) {
@@ skipping 1136 matching lines @@
       content::NotificationService::NoDetails());
 }
 
 void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_)
     updater_->Start();
 
   OnBlacklistUpdated();
 
   SetReadyAndNotifyListeners();
+
+  CheckImportsOnAllExtensions();
 }
 
 void ExtensionService::AddExtension(const Extension* extension) {
   // TODO(jstritar): We may be able to get rid of this branch by overriding the
   // default extension state to DISABLED when the --disable-extensions flag
   // is set (http://crbug.com/29067).
   if (!extensions_enabled() &&
       !extension->is_theme() &&
       extension->location() != Manifest::COMPONENT &&
       !Manifest::IsExternalLocation(extension->location())) {
@@ skipping 229 matching lines @@
       extension_ids.insert(extension->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionService::ScheduleLaunchOnLoad(const std::string& extension_id) {
   on_load_events_[extension_id] = EVENT_LAUNCHED;
 }
 
+bool ExtensionService::CheckImports(const Extension* extension) {
+  bool import_failed = false;
+  if (SharedModuleInfo::ImportsModules(extension)) {
+    const std::vector<SharedModuleInfo::ImportInfo>& imports =
+        SharedModuleInfo::GetImports(extension);
+    std::vector<SharedModuleInfo::ImportInfo>::const_iterator i;
+    for (i = imports.begin(); i != imports.end(); ++i) {
+      Version version_required(i->minimum_version);
+      const Extension* imported_module =
+          GetExtensionById(i->extension_id, true);
+      if (!imported_module ||
+          (version_required.IsValid() &&
+           imported_module->version()->CompareTo(version_required) < 0)) {
+        import_failed = true;
+        if (extension->from_webstore()) {
+          if (pending_extension_manager()->AddFromExtensionImport(

[asargent_no_longer_on_chrome, 2013/05/17 17:13:49]

in the implementation of PendingExtensionManager::AddFromExtensionImport, I
notice you log an error if the dependent module is already installed. But you
get into this code path even if the dependent module *is* installed but just not
a new enough version. Maybe you want to skip calling
PendingExtensionManager::AddFromExtensionImport if it's already installed, and
just pull the call to CheckForUpdatesSoon out of the if statement body here?

+                   i->extension_id,
+                   extension_urls::GetWebstoreUpdateUrl(),
+                   IsSharedModule)) {
+            CheckForUpdatesSoon();
+          }
+        }
+      }
+      if (imported_module &&
+          !SharedModuleInfo::IsSharedModule(imported_module)) {
+        import_failed = true;
+      }
+    }
+  }
+  const std::string& id = extension->id();
+  if (import_failed) {
+    extension_prefs_->AddDisableReason(
+        id, Extension::DISABLE_MISSING_IMPORT);
+  } else if (extension_prefs_->GetDisableReasons(id) ==
+      Extension::DISABLE_MISSING_IMPORT) {
+    EnableExtension(id);
+  }
+  return !import_failed;
+}
+
+void ExtensionService::CheckImportsOnAllExtensions() {
+  std::vector<const Extension*> extensions_to_check;
+  for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
+       iter != disabled_extensions_.end(); ++iter) {
+    extensions_to_check.push_back(*iter);
+  }
+  for (ExtensionSet::const_iterator iter = extensions_.begin();
+       iter != extensions_.end(); ++iter) {
+    extensions_to_check.push_back(*iter);
+  }
+  std::vector<const Extension*>::const_iterator iter;
+  for (iter = extensions_to_check.begin();
+       iter != extensions_to_check.end();
+       ++iter) {
+    CheckImports(*iter);
+  }
+}
+
+void ExtensionService::PruneSharedModulesOnUninstall(
+    const Extension* extension) {
+  if (SharedModuleInfo::ImportsModules(extension)) {
+    const std::vector<SharedModuleInfo::ImportInfo>& imports =
+        SharedModuleInfo::GetImports(extension);
+    std::vector<SharedModuleInfo::ImportInfo>::const_iterator i;
+    for (i = imports.begin(); i != imports.end(); ++i) {
+      const Extension* imported_module =
+          GetExtensionById(i->extension_id, true);
+      if (!imported_module)
+        continue;
+      if (SharedModuleInfo::IsSharedModule(imported_module)) {
+        bool is_referenced = false;
+        for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
+             iter != disabled_extensions_.end(); ++iter) {
+          if (SharedModuleInfo::ImportsExtensionById(*iter, i->extension_id)) {
+            is_referenced = true;
+            break;
+          }
+        }
+        if (!is_referenced) {
+          for (ExtensionSet::const_iterator iter = extensions_.begin();
+               iter != extensions_.end(); ++iter) {
+            if (SharedModuleInfo::ImportsExtensionById(*iter,
+                                                       i->extension_id)) {
+              is_referenced = true;
+              break;
+            }
+          }
+        }
+        if (!is_referenced) {
+          UninstallExtension(i->extension_id, false, NULL);
+        }
+      }
+    }
+  }
+}
+
+
 void ExtensionService::OnExtensionInstalled(
     const Extension* extension,
     const syncer::StringOrdinal& page_ordinal,
     bool has_requirement_errors,
     bool wait_for_idle) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const std::string& id = extension->id();
   bool initial_enable = ShouldEnableOnInstall(extension);
   const extensions::PendingExtensionInfo* pending_extension_info = NULL;
@@ skipping 40 matching lines @@
         id, Extension::DISABLE_UNSUPPORTED_REQUIREMENT);
   // If the extension was disabled because of unsupported requirements but
   // now supports all requirements after an update and there are not other
   // disable reasons, enable it.
   } else if (extension_prefs_->GetDisableReasons(id) ==
       Extension::DISABLE_UNSUPPORTED_REQUIREMENT) {
     initial_enable = true;
     extension_prefs_->ClearDisableReasons(id);
   }
 
+  if (!CheckImports(extension)) {
+    initial_enable = false;
+  }
+
   if (!GetInstalledExtension(extension->id())) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallSource",
                               extension->location(), Manifest::NUM_LOCATIONS);
     RecordPermissionMessagesHistogram(
         extension, "Extensions.Permissions_Install");
   } else {
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateType",
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateSource",
                               extension->location(), Manifest::NUM_LOCATIONS);
   }
 
   // Certain extension locations are specific enough that we can
   // auto-acknowledge any extension that came from one of them.
   if (extension->location() == Manifest::EXTERNAL_POLICY_DOWNLOAD)
     AcknowledgeExternalExtension(extension->id());
   const Extension::State initial_state =
       initial_enable ? Extension::ENABLED : Extension::DISABLED;
   if (ShouldDelayExtensionUpdate(id, wait_for_idle)) {

[Matt Perry, 2013/05/16 19:17:55]

We have this concept of delaying an extension update until some conditions are
met. Perhaps we can generalize that to "delay extension install". The dependent
extension can be put in this limbo state until the dependencies are installed.

[asargent_no_longer_on_chrome, 2013/05/17 17:13:49]

I endorse Matt's suggestion here.

     extension_prefs_->SetDelayedInstallInfo(extension, initial_state,
                                             page_ordinal);
 
     // Transfer ownership of |extension|.
     delayed_updates_for_idle_.Insert(extension);
 
     // Notify extension of available update.
     extensions::RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
         profile_, id, extension->manifest()->value());
 
@@ skipping 86 matching lines @@
 
   // If this is a new external extension that was disabled, alert the user
   // so he can reenable it. We do this last so that it has already been
   // added to our list of extensions.
   if (unacknowledged_external) {
     UpdateExternalExtensionAlert();
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEvent",
                               EXTERNAL_EXTENSION_INSTALLED,
                               EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
   }
+
+  // Check extensions that may be disabled only because this shared module was
+  // not available.
+  if (SharedModuleInfo::IsSharedModule(extension)) {
+    // Build a list of extensions to check because they can't be checked
+    // within the loop iterating over disabled_extensions_ because contents
+    // of that set may change as we CheckImports.
+    std::vector<const Extension*> extensions_to_check;
+    for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
+         iter != disabled_extensions_.end(); ++iter) {
+      if (SharedModuleInfo::ImportsExtensionById((*iter), extension->id())) {
+        extensions_to_check.push_back(*iter);
+      }
+    }
+    std::vector<const Extension*>::const_iterator iter;
+    for (iter = extensions_to_check.begin();
+         iter != extensions_to_check.end();
+         ++iter) {
+      CheckImports(*iter);
+    }
+  }
 }
 
 const Extension* ExtensionService::GetPendingExtensionUpdate(
     const std::string& id) const {
   return delayed_updates_for_idle_.GetByID(id);
 }
 
 void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
   if (!terminated_extensions_.Contains(extension->id()))
     terminated_extensions_.Insert(make_scoped_refptr(extension));
@@ skipping 630 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }