Adds a webstorePrivate method for silently installing extensions.

chrome/browser/extensions/extension_webstore_private_api.cc

 // Copyright (c) 2011 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_webstore_private_api.h"
 
 #include <string>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 34 matching lines @@
 const char kTokenKey[] = "token";
 
 const char kCannotSpecifyIconDataAndUrlError[] =
     "You cannot specify both icon data and an icon url";
 const char kInvalidIconUrlError[] = "Invalid icon url";
 const char kInvalidIdError[] = "Invalid id";
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kNoPreviousBeginInstallWithManifestError[] =
     "* does not match a previous call to beginInstallWithManifest3";
 const char kUserCancelledError[] = "User cancelled install";
+const char kPermissionDeniedError[] =
+    "You do not have permission to use this method.";
 
 ProfileSyncService* test_sync_service = NULL;
 
 // Returns either the test sync service, or the real one from |profile|.
 ProfileSyncService* GetSyncService(Profile* profile) {
   if (test_sync_service)
     return test_sync_service;
   else
     return profile->GetProfileSyncService();
 }
 
 bool IsWebStoreURL(Profile* profile, const GURL& url) {
   ExtensionService* service = profile->GetExtensionService();
   const Extension* store = service->GetWebStoreApp();
   if (!store) {
     NOTREACHED();
     return false;
   }
   return (service->GetExtensionByWebExtent(url) == store);
 }
 
+// Whitelists extension IDs for use by webstorePrivate.silentlyInstall.
+bool trust_test_ids = false;
+
+bool IsTrustedForSilentInstall(const std::string& id) {
+  // Trust the extensions in api_test/webstore_private/bundle when the flag
+  // is set.
+  if (trust_test_ids &&
+      (id == "begfmnajjkbjdgmffnjaojchoncnmngg" ||
+       id == "bmfoocgfinpmkmlbjhcbofejhkhlbchk" ||
+       id == "mpneghmdnmaolkljkipbhaienajcflfe"))
+    return true;
+
+  return
+      id == "jgoepmocgafhnchmokaimcmlojpnlkhp" ||  // +1 Extension
+      id == "cpembckmhnjipbgbnfiocbgnkpjdokdd" ||  // +1 Extension - dev
+      id == "boemmnepglcoinjcdlfcpcbmhiecichi" ||  // Notifications
+      id == "flibmgiapaohcbondaoopaalfejliklp" ||  // Notifications - dev
+      id == "dlppkpafhbajpcmmoheippocdidnckmm" ||  // Remaining are placeholders
+      id == "hmglfmpefabcafaimbpldpambdfomanl" ||
+      id == "idfijlieiecpfcjckpkliefekpokhhnd" ||
+      id == "jaokjbijaokooelpahnlmbciccldmfla" ||
+      id == "kdjeommiakphmeionoojjljlecmpaldd" ||
+      id == "lpdeojkfhenboeibhkjhiancceeboknd";
+}
+
 // Helper to create a dictionary with login and token properties set from
 // the appropriate values in the passed-in |profile|.
 DictionaryValue* CreateLoginResult(Profile* profile) {
   DictionaryValue* dictionary = new DictionaryValue();
   std::string username = profile->GetPrefs()->GetString(
       prefs::kGoogleServicesUsername);
   dictionary->SetString(kLoginKey, username);
   if (!username.empty()) {
     CommandLine* cmdline = CommandLine::ForCurrentProcess();
     TokenService* token_service = profile->GetTokenService();
@@ skipping 16 matching lines @@
     ProfileSyncService* service) {
   test_sync_service = service;
 }
 
 // static
 void WebstorePrivateApi::SetWebstoreInstallerDelegateForTesting(
     WebstoreInstaller::Delegate* delegate) {
   test_webstore_installer_delegate = delegate;
 }
 
+// static
+void WebstorePrivateApi::SetTrustTestIDsForTesting(bool allow) {
+  trust_test_ids = allow;
+}
+
 BeginInstallWithManifestFunction::BeginInstallWithManifestFunction()
   : use_app_installed_bubble_(false) {}
 
 BeginInstallWithManifestFunction::~BeginInstallWithManifestFunction() {}
 
 bool BeginInstallWithManifestFunction::RunImpl() {
   if (!IsWebStoreURL(profile_, source_url())) {
     SetResult(PERMISSION_DENIED);
     return false;
   }
@@ skipping 216 matching lines @@
   // permissions install dialog.
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
       profile(), test_webstore_installer_delegate,
       &(dispatcher()->delegate()->GetAssociatedTabContents()->controller()),
       id, WebstoreInstaller::FLAG_NONE);
   installer->Start();
 
   return true;
 }
 
+SilentlyInstallFunction::SilentlyInstallFunction() {}
+SilentlyInstallFunction::~SilentlyInstallFunction() {}
+
+bool SilentlyInstallFunction::RunImpl() {
+  if (!IsWebStoreURL(profile_, source_url())) {
+    error_ = kPermissionDeniedError;
+    return false;
+  }
+
+  DictionaryValue* details = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
+  CHECK(details);
+
+  EXTENSION_FUNCTION_VALIDATE(details->GetString(kIdKey, &id_));
+  if (!IsTrustedForSilentInstall(id_)) {
+    error_ = kInvalidIdError;
+    return false;
+  }
+
+  EXTENSION_FUNCTION_VALIDATE(details->GetString(kManifestKey, &manifest_));
+
+  // Matched in OnWebstoreParseFailure, OnExtensionInstall{Success,Failure}.
+  AddRef();
+
+  scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
+      this, id_, manifest_, std::string(), GURL(), NULL);
+  helper->Start();
+
+  return true;
+}
+
+void SilentlyInstallFunction::OnWebstoreParseSuccess(
+    const std::string& id,
+    const SkBitmap& icon,
+    base::DictionaryValue* parsed_manifest) {
+  CHECK_EQ(id_, id);
+
+  // This lets CrxInstaller bypass the permission confirmation UI for the
+  // extension. The whitelist entry gets cleared in
+  // CrxInstaller::ConfirmInstall.
+  CrxInstaller::WhitelistEntry* entry = new CrxInstaller::WhitelistEntry;
+  entry->parsed_manifest.reset(parsed_manifest);
+  entry->use_app_installed_bubble = false;
+  entry->skip_post_install_ui = true;
+  CrxInstaller::SetWhitelistEntry(id_, entry);
+
+  scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
+      profile(), this,
+      &(dispatcher()->delegate()->GetAssociatedTabContents()->controller()),
+      id_, WebstoreInstaller::FLAG_NONE);
+  installer->Start();
+}
+
+void SilentlyInstallFunction::OnWebstoreParseFailure(
+    const std::string& id,
+    InstallHelperResultCode result_code,
+    const std::string& error_message) {
+  CHECK_EQ(id_, id);
+
+  error_ = error_message;
+  SendResponse(false);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
+void SilentlyInstallFunction::OnExtensionInstallSuccess(const std::string& id) {
+  CHECK_EQ(id_, id);
+
+  SendResponse(true);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
+void SilentlyInstallFunction::OnExtensionInstallFailure(
+    const std::string& id, const std::string& error) {
+  CHECK_EQ(id_, id);
+
+  error_ = error;
+  SendResponse(false);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
 bool GetBrowserLoginFunction::RunImpl() {
   if (!IsWebStoreURL(profile_, source_url()))
     return false;
   result_.reset(CreateLoginResult(profile_->GetOriginalProfile()));
   return true;
 }
 
 bool GetStoreLoginFunction::RunImpl() {
   if (!IsWebStoreURL(profile_, source_url()))
     return false;
@@ skipping 11 matching lines @@
 bool SetStoreLoginFunction::RunImpl() {
   if (!IsWebStoreURL(profile_, source_url()))
     return false;
   std::string login;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &login));
   ExtensionService* service = profile_->GetExtensionService();
   ExtensionPrefs* prefs = service->extension_prefs();
   prefs->SetWebStoreLogin(login);
   return true;
 }