Enforce the 'requirements' field in manifests.

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 45 matching lines @@
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/external_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/permissions_updater.h"
+#include "chrome/browser/extensions/requirements_provider.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/history/history_extension_api.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
@@ skipping 33 matching lines @@
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chrome/browser/chromeos/extensions/file_browser_event_router.h"
 #include "chrome/browser/chromeos/extensions/input_method_event_router.h"
 #include "chrome/browser/chromeos/extensions/media_player_event_router.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
-#include "chrome/browser/extensions/extension_input_ime_api.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #endif
 
 using base::Time;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::PluginService;
@@ skipping 206 matching lines @@
       app_notification_manager_(new AppNotificationManager(profile)),
       apps_promo_(profile->GetPrefs()),
       event_routers_initialized_(false),
       update_once_all_providers_are_ready_(false),
       app_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       extension_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       extension_warnings_(profile),
       api_resource_controller_(NULL),
       app_shortcut_manager_(profile) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
+  requirements_provider_.reset(new extensions::RequirementsProvider());
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
@@ skipping 245 matching lines @@
   }
 
   // Bookmark apps being updated is kind of a contradiction, but that's because
   // we mark the default apps as bookmark apps, and they're hosted in the web
   // store, thus they can get updated. See http://crbug.com/101605 for more
   // details.
   if (extension && extension->from_bookmark())
     creation_flags |= Extension::FROM_BOOKMARK;
 
   installer->set_creation_flags(creation_flags);
-
   installer->set_delete_source(true);
   installer->set_download_url(download_url);
   installer->set_install_cause(extension_misc::INSTALL_CAUSE_UPDATE);
   installer->InstallCrx(extension_path);
 
   if (out_crx_installer)
     *out_crx_installer = installer;
 
   return true;
 }
@@ skipping 253 matching lines @@
 
   SyncExtensionChangeIfNeeded(*extension);
 
   // Deactivating one extension might have solved the problems of others.
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
 }
 
+void ExtensionService::UnsupportedRequirements(const std::string& extension_id,
+                                               const string16& error,
+                                               bool disable_extension) {
+  if (disable_extension)
+    DisableExtension(extension_id, Extension::DISABLE_UNSUPPORTED_REQUIREMENTS);
+  Extension::InstallWarningVector warnings;
+  warnings.push_back(Extension::InstallWarning(
+      Extension::InstallWarning::FORMAT_TEXT, UTF16ToUTF8(error)));
+  const Extension* extension = GetExtensionById(extension_id, true);
+  if (extension)
+    const_cast<Extension*>(extension)->AddInstallWarnings(warnings);
+}
+
 void ExtensionService::GrantPermissionsAndEnableExtension(
     const Extension* extension, bool record_oauth2_grant) {
   CHECK(extension);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_ReEnable");
   extensions::PermissionsUpdater perms_updater(profile());
   perms_updater.GrantActivePermissions(extension, record_oauth2_grant);
   extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
   EnableExtension(extension->id());
 }
@@ skipping 1021 matching lines @@
 
   // If the extension was disabled for a reload, then enable it.
   if (disabled_extension_paths_.erase(extension->id()) > 0)
     EnableExtension(extension->id());
 
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
   InitializePermissions(extension);
 
   bool disabled = extension_prefs_->IsExtensionDisabled(extension->id());
+
+  std::list<string16> errors;
+  bool async;
+  if (!requirements_provider_->Supports(extension, &errors, &async, this)) {

[Aaron Boodman, 2012/07/22 17:46:25]

I think that this is going to result in a GPU process getting created at each
browser startup, which seems undesirable. Can you verify?

In any case, we're also going to need to check at install time so that we can
make installation throw an error, rather than installing successfully and then
going into disabled state.

+    disabled = true;
+    Extension::InstallWarningVector warnings;
+    std::list<string16>::iterator it;
+    for (it = errors.begin(); it != errors.end(); ++it) {
+      warnings.push_back(Extension::InstallWarning(
+          Extension::InstallWarning::FORMAT_TEXT, UTF16ToUTF8(*it)));
+    }
+    const_cast<Extension*>(extension)->AddInstallWarnings(warnings);
+  }
+
   if (disabled) {
     disabled_extensions_.Insert(scoped_extension);
     SyncExtensionChangeIfNeeded(*extension);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
 
     if (extension_prefs_->GetDisableReason(extension->id()) ==
         Extension::DISABLE_PERMISSIONS_INCREASE) {
@@ skipping 616 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }