Enforce the 'requirements' field in manifests.

chrome/browser/extensions/crx_installer.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/crx_installer.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
+#include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/convert_user_script.h"
 #include "chrome/browser/extensions/convert_web_app.h"
 #include "chrome/browser/extensions/default_apps_trial.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/permissions_updater.h"
+#include "chrome/browser/extensions/requirements_checker.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
@@ skipping 52 matching lines @@
       create_app_shortcut_(false),
       frontend_weak_(frontend_weak),
       profile_(frontend_weak->profile()),
       client_(client),
       apps_require_extension_mime_type_(false),
       allow_silent_install_(false),
       install_cause_(extension_misc::INSTALL_CAUSE_UNSET),
       creation_flags_(Extension::NO_FLAGS),
       off_store_install_allow_reason_(OffStoreInstallDisallowed),
       did_handle_successfully_(true),
-      record_oauth2_grant_(false) {
+      record_oauth2_grant_(false),
+      error_on_unsported_requirements_(false),
+      requirements_checker_(new extensions::RequirementsChecker()) {
   if (!approval)
     return;
 
   CHECK(profile_->IsSameProfile(approval->profile));
   client_->install_ui()->SetUseAppInstalledBubble(
       approval->use_app_installed_bubble);
   client_->install_ui()->SetSkipPostInstallUI(approval->skip_post_install_ui);
 
   if (approval->skip_install_dialog) {
     // Mark the extension as approved, but save the expected manifest and ID
@@ skipping 262 matching lines @@
     return;
   }
 
   if (client_) {
     Extension::DecodeIcon(extension_.get(),
                           ExtensionIconSet::EXTENSION_ICON_LARGE,
                           ExtensionIconSet::MATCH_BIGGER,
                           &install_icon_);
   }
 
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(&CrxInstaller::RunRequirementsChecker, this));
+}
+
+void CrxInstaller::RunRequirementsChecker() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  requirements_checker_->Check(extension_,
+                               base::Bind(&CrxInstaller::RequirementsChecked,

[Aaron Boodman, 2012/08/01 03:58:54]

Why run this on the file thread? It seems like this is just introducing more
thread hops. If you have it call back on UI thread, then RequirementsCheck can
just directly call ConfirmInstall() rather than PostTask'ing to it.

[eaugusti, 2012/08/03 01:06:26]

Done.

+                                          this),
+                               BrowserThread::FILE);
+}
+
+void CrxInstaller::RequirementsChecked(std::vector<std::string> errors) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  if (!errors.empty()) {
+    if (error_on_unsported_requirements_) {
+      ReportFailureFromFileThread(CrxInstallerError(
+          UTF8ToUTF16(JoinString(errors, ' '))));
+      return;
+    }
+    requirement_errors_.swap(errors);
+  }
+
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&CrxInstaller::ConfirmInstall, this)))
     NOTREACHED();
 }
 
 void CrxInstaller::ConfirmInstall() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!frontend_weak_.get())
     return;
@@ skipping 116 matching lines @@
   // TODO(rdevlin.cronin): Continue removing std::string errors and replacing
   // with string16
   std::string error;
   extension_ = extension_file_util::LoadExtension(
       version_dir,
       install_source_,
       extension_->creation_flags() | Extension::REQUIRE_KEY,
       &error);
   CHECK(error.empty()) << error;
 
+  if (!requirement_errors_.empty()) {
+    extensions::Extension::InstallWarningVector install_warnings;
+    std::vector<std::string>::iterator it;

[Aaron Boodman, 2012/08/01 03:58:54]

Since you don't need |it| outside the for loop define it there.

[eaugusti, 2012/08/03 01:06:26]

Done.

+    for (it = requirement_errors_.begin(); it != requirement_errors_.end();
+         ++it) {
+      install_warnings.push_back(Extension::InstallWarning(
+          Extension::InstallWarning::FORMAT_TEXT, *it));
+    }
+    const_cast<Extension*>(extension_.get())->AddInstallWarnings(

[Aaron Boodman, 2012/08/01 03:58:54]

You can avoid this const_cast by de-consting extension_ and following that
thread. It ends not to far away at SandboxedUnpacker::Client::OnUnpackSucceeded.
The Extension* that is passed into that is non-const.

None of these actually need to be const at this point in extension's lifetime.
We only need it to be const when it gets added to ExtensionService because at
that point it can be modified on multiple threads concurrently.

[Aaron Boodman, 2012/08/01 04:03:57]

s/modified/accessed/

[eaugusti, 2012/08/03 01:06:26]

Done.

+        install_warnings);
+  }
+
   ReportSuccessFromFileThread();
 }
 
 void CrxInstaller::ReportFailureFromFileThread(const CrxInstallerError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&CrxInstaller::ReportFailureFromUIThread, this, error))) {
     NOTREACHED();
   }
@@ skipping 62 matching lines @@
   // We update the extension's granted permissions if the user already approved
   // the install (client_ is non NULL), or we are allowed to install this
   // silently.
   if (client_ || allow_silent_install_) {
     PermissionsUpdater perms_updater(profile());
     perms_updater.GrantActivePermissions(extension_, record_oauth2_grant_);
   }
 
   // Tell the frontend about the installation and hand off ownership of
   // extension_ to it.
-  frontend_weak_->OnExtensionInstalled(extension_, is_gallery_install(),
-                                       page_ordinal_);
+  frontend_weak_->OnExtensionInstalled(extension_,
+                                       is_gallery_install(),
+                                       page_ordinal_,
+                                       requirement_errors_);
 
   NotifyCrxInstallComplete(extension_.get());
 
   extension_ = NULL;
 
   // We're done. We don't post any more tasks to ourselves so we are deleted
   // soon.
 }
 
 void CrxInstaller::NotifyCrxInstallComplete(const Extension* extension) {
   // Some users (such as the download shelf) need to know when a
   // CRXInstaller is done.  Listening for the EXTENSION_* events
   // is problematic because they don't know anything about the
   // extension before it is unpacked, so they cannot filter based
   // on the extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::Source<CrxInstaller>(this),
       content::Details<const Extension>(extension));
 }
 
 }  // namespace extensions