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 55 matching lines @@
 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.
+const char* test_trusted_id = NULL;
+
+bool IsTrustedForSilentInstall(const std::string& id) {
+  return (test_trusted_id && id == std::string(test_trusted_id)) ||
+      id == std::string("jgoepmocgafhnchmokaimcmlojpnlkhp") ||

[Aaron Boodman, 2011/11/01 17:24:34]

Nit: I don't think you need the std::string wrappers -- std::string can compare
to const char* and char[] directly.

[jstritar, 2011/11/01 19:43:05]

Done.

+      id == std::string("cpembckmhnjipbgbnfiocbgnkpjdokdd") ||
+      id == std::string("boemmnepglcoinjcdlfcpcbmhiecichi") ||
+      id == std::string("flibmgiapaohcbondaoopaalfejliklp") ||
+      id == std::string("dlppkpafhbajpcmmoheippocdidnckmm") ||
+      id == std::string("hmglfmpefabcafaimbpldpambdfomanl") ||
+      id == std::string("idfijlieiecpfcjckpkliefekpokhhnd") ||
+      id == std::string("jaokjbijaokooelpahnlmbciccldmfla") ||
+      id == std::string("kdjeommiakphmeionoojjljlecmpaldd") ||
+      id == std::string("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::SetTrustedIDForTesting(const char* extension_id) {
+  test_trusted_id = extension_id;
+}
+
 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())) {
+    SetResult(PERMISSION_DENIED);
+    return false;
+  }
+
+  DictionaryValue* details = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
+  CHECK(details);
+
+  EXTENSION_FUNCTION_VALIDATE(details->GetString(kIdKey, &id_));
+  if (!IsTrustedForSilentInstall(id_)) {
+    SetResult(INVALID_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);
+
+  // Map from WebstoreInstallHelper's result codes to ours.
+  if (WebstoreInstallHelper::Delegate::MANIFEST_ERROR)

[Aaron Boodman, 2011/11/01 17:24:34]

I think this will always be true.

[jstritar, 2011/11/01 19:43:05]

Oops, I meant to compare that to result_code. Done.

+    SetResult(MANIFEST_ERROR);
+  else
+    SetResult(UNKNOWN_ERROR);
+
+  error_ = error_message;
+  SendResponse(false);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
+void SilentlyInstallFunction::OnExtensionInstallSuccess(const std::string& id) {
+  CHECK_EQ(id_, id);
+  SetResult(ERROR_NONE);
+  SendResponse(true);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
+void SilentlyInstallFunction::OnExtensionInstallFailure(
+    const std::string& id, const std::string& error) {
+  CHECK_EQ(id_, id);
+  SetResult(UNKNOWN_ERROR);
+  error_ = error;
+  SendResponse(false);
+
+  Release();  // Matches the AddRef() in RunImpl().
+}
+
+void SilentlyInstallFunction::SetResult(ResultCode code) {
+  switch (code) {
+    case ERROR_NONE:
+      result_.reset(Value::CreateStringValue(""));
+      break;
+    case UNKNOWN_ERROR:
+      result_.reset(Value::CreateStringValue("unknown_error"));

[Aaron Boodman, 2011/11/01 17:24:34]

We don't usually send both a result and an error. In the case of error, we
usually just send a null value for the result.

[jstritar, 2011/11/01 19:43:05]

I did this to be consistent with BeginInstallWithManifest. I'm fine with
removing the result codes though (then I can get rid of SetResult).

[Aaron Boodman, 2011/11/02 04:16:55]

Less code sgtm

+      break;
+    case INVALID_ID:
+      result_.reset(Value::CreateStringValue("invalid_id"));
+      break;
+    case PERMISSION_DENIED:
+      result_.reset(Value::CreateStringValue("permission_denied"));
+      break;
+    default:
+      CHECK(false);
+  }
+}
+
 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;
 }