Add/resurrect support for bundles of WebStore items.

chrome/browser/extensions/api/webstore_private/webstore_private_api.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/api/webstore_private/webstore_private_api.h"
 
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/app_list/app_list_util.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/crx_file/id_util.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/extension.h"
+#include "url/gurl.h"
 
 namespace extensions {
 
 namespace BeginInstallWithManifest3 =
     api::webstore_private::BeginInstallWithManifest3;
 namespace CompleteInstall = api::webstore_private::CompleteInstall;
 namespace GetBrowserLogin = api::webstore_private::GetBrowserLogin;
 namespace GetEphemeralAppsEnabled =
     api::webstore_private::GetEphemeralAppsEnabled;
 namespace GetIsLauncherEnabled = api::webstore_private::GetIsLauncherEnabled;
 namespace GetStoreLogin = api::webstore_private::GetStoreLogin;
 namespace GetWebGLStatus = api::webstore_private::GetWebGLStatus;
+namespace InstallBundle = api::webstore_private::InstallBundle;
 namespace IsInIncognitoMode = api::webstore_private::IsInIncognitoMode;
 namespace LaunchEphemeralApp = api::webstore_private::LaunchEphemeralApp;
 namespace SetStoreLogin = api::webstore_private::SetStoreLogin;
 namespace ShowPermissionPromptForDelegatedInstall =
     api::webstore_private::ShowPermissionPromptForDelegatedInstall;
 
 namespace {
 
 // Holds the Approvals between the time we prompt and start the installs.
 class PendingApprovals {
@@ skipping 92 matching lines @@
   NOTREACHED();
   return api::webstore_private::RESULT_NONE;
 }
 
 static base::LazyInstance<PendingApprovals> g_pending_approvals =
     LAZY_INSTANCE_INITIALIZER;
 
 // A preference set by the web store to indicate login information for
 // purchased apps.
 const char kWebstoreLogin[] = "extensions.webstore_login";
+
+// Error messages that can be returned by the API.
 const char kAlreadyInstalledError[] = "This item is already installed";
 const char kCannotSpecifyIconDataAndUrlError[] =
     "You cannot specify both icon data and an icon url";
+const char kInvalidBundleError[] = "Invalid bundle";
 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";
 
-WebstoreInstaller::Delegate* test_webstore_installer_delegate = NULL;
+WebstoreInstaller::Delegate* test_webstore_installer_delegate = nullptr;
 
 // We allow the web store to set a string containing login information when a
 // purchase is made, so that when a user logs into sync with a different
 // account we can recognize the situation. The Get function returns the login if
 // there was previously stored data, or an empty string otherwise. The Set will
 // overwrite any previous login.
 std::string GetWebstoreLogin(Profile* profile) {
   if (profile->GetPrefs()->HasPrefPath(kWebstoreLogin))
     return profile->GetPrefs()->GetString(kWebstoreLogin);
   return std::string();
@@ skipping 83 matching lines @@
     }
   }
 
   std::string icon_data = params_->details.icon_data ?
       *params_->details.icon_data : std::string();
 
   ExtensionFunction::ResponseValue response = RunExtraForResponse();
   if (response)
     return RespondNow(response.Pass());
 
-  net::URLRequestContextGetter* context_getter = NULL;
+  net::URLRequestContextGetter* context_getter = nullptr;
   if (!icon_url.is_empty())
     context_getter = browser_context()->GetRequestContext();
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
       this, params_->details.id, params_->details.manifest, icon_data, icon_url,
       context_getter);
 
   // The helper will call us back via OnWebstoreParseSuccess or
   // OnWebstoreParseFailure.
   helper->Start();
@@ skipping 299 matching lines @@
   install_prompt->ConfirmPermissionsForDelegatedInstall(
       this, dummy_extension().get(), params().details.delegated_user, &icon());
 }
 
 scoped_ptr<base::ListValue>
 WebstorePrivateShowPermissionPromptForDelegatedInstallFunction::CreateResults(
     api::webstore_private::Result result) const {
   return ShowPermissionPromptForDelegatedInstall::Results::Create(result);
 }
 
+WebstorePrivateInstallBundleFunction::WebstorePrivateInstallBundleFunction()
+  : chrome_details_(this) {
+}
+
+WebstorePrivateInstallBundleFunction::~WebstorePrivateInstallBundleFunction() {
+}
+
+ExtensionFunction::ResponseAction WebstorePrivateInstallBundleFunction::Run() {
+  params_ = InstallBundle::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_);
+
+  if (!crx_file::id_util::IdIsValid(params_->details.id))
+    return RespondNow(Error(kInvalidIdError));
+
+  if (params_->details.icon_data && params_->details.icon_url)
+    return RespondNow(Error(kCannotSpecifyIconDataAndUrlError));

[asargent_no_longer_on_chrome, 2015/03/16 17:48:22]

FYI, we're phasing out the icon_data parameter from the webstore install APIs
since the webstore has only ever actually used the icon_url, and continuing to
have support for the base64-encoded icon_data was making a refactor of image
decoding more complicated than it needed to be. See this in-progress CL for
details:

 https://codereview.chromium.org/931993002/

I'm going to be coming through here and doing any remaining needed cleanup, but
in the meantime wherever it is convenient you can write your code assuming
icon_data will never be passed. 

[Marc Treib, 2015/03/17 12:18:27]

Thanks for the heads-up!
If you'll be doing a cleanup pass anyway, then I will leave this as is for now.
(OTOH, if the cleanup lands before this, then I'll clean it up before landing!)

+
+  GURL icon_url;
+  if (params_->details.icon_url) {
+    icon_url = source_url().Resolve(*params_->details.icon_url);
+    if (!icon_url.is_valid())
+      return RespondNow(Error(kInvalidIconUrlError));
+  }
+
+  if (params_->contents.empty())
+    return RespondNow(Error(kInvalidBundleError));
+
+  std::string icon_data = params_->details.icon_data ?
+      *params_->details.icon_data : std::string();
+
+  net::URLRequestContextGetter* context_getter = nullptr;
+  if (!icon_url.is_empty())
+    context_getter = browser_context()->GetRequestContext();
+
+  scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
+      this, params_->details.id, std::string(), icon_data, icon_url,
+      context_getter);
+
+  // The helper will call us back via OnWebstoreParseSuccess or
+  // OnWebstoreParseFailure.
+  helper->Start();
+
+  // Matched with a Release in OnWebstoreParseSuccess, OnWebstoreParseFailure,
+  // OnInstallApproval, or OnInstallComplete.
+  AddRef();
+
+  // The response is sent asynchronously in OnWebstoreParseSuccess,
+  // OnWebstoreParseFailure, OnInstallApproval, or OnInstallComplete.
+  return RespondLater();
+}
+
+void WebstorePrivateInstallBundleFunction::OnWebstoreParseSuccess(
+    const std::string& id,
+    const SkBitmap& icon,
+    base::DictionaryValue* parsed_manifest) {
+  InstallTracker* tracker = InstallTracker::Get(browser_context());
+  DCHECK(tracker);
+
+  std::string authuser;
+  if (params_->details.authuser)
+    authuser = *params_->details.authuser;
+
+  BundleInstaller::ItemList items;
+  for (const auto& entry : params_->contents) {
+    // Skip already-installed items.
+    if (util::IsExtensionInstalledPermanently(entry->id, browser_context()) ||
+        tracker->GetActiveInstall(entry->id)) {
+      continue;
+    }
+    BundleInstaller::Item item;
+    item.id = entry->id;
+    item.manifest = entry->manifest;
+    item.localized_name = entry->localized_name;
+    if (entry->icon_url)
+      item.icon_url = source_url().Resolve(*entry->icon_url);
+    if (entry->icon_data)
+      item.icon_data = *entry->icon_data;
+    items.push_back(item);
+  }
+  if (items.empty()) {
+    Respond(Error(kAlreadyInstalledError));
+    Release();
+    return;
+  }
+  bundle_.reset(new BundleInstaller(chrome_details_.GetCurrentBrowser(),
+                                    params_->details.localized_name,
+                                    icon,
+                                    authuser,
+                                    items));
+
+  // The bundle installer will call us back via OnInstallApproval.
+  bundle_->PromptForApproval(
+      base::Bind(&WebstorePrivateInstallBundleFunction::OnInstallApproval,
+                 base::Unretained(this)));
+}
+
+void WebstorePrivateInstallBundleFunction::OnWebstoreParseFailure(
+    const std::string& id,
+    WebstoreInstallHelper::Delegate::InstallHelperResultCode result_code,
+    const std::string& error_message) {
+  Respond(Error(error_message));
+  Release();
+}
+
+void WebstorePrivateInstallBundleFunction::OnInstallApproval(
+    BundleInstaller::ApprovalState state) {
+  if (state != BundleInstaller::APPROVED) {
+    Respond(Error(state == BundleInstaller::USER_CANCELED
+                      ? kUserCancelledError
+                      : kInvalidBundleError));
+    Release();
+    return;
+  }
+
+  // The bundle installer will call us back via OnInstallComplete.
+  bundle_->CompleteInstall(
+      chrome_details_.GetAssociatedWebContents(),
+      base::Bind(&WebstorePrivateInstallBundleFunction::OnInstallComplete,
+                 base::Unretained(this)));
+}
+
+void WebstorePrivateInstallBundleFunction::OnInstallComplete() {
+  Respond(NoArguments());
+  Release();
+}
+

[asargent_no_longer_on_chrome, 2015/03/16 17:48:22]

Quite a bit of the code here looks similar to what we already have in the
templatized WebstorePrivateFunctionWithPermissionPrompt methods above - could we
just modify that to include virtual functions to specialize in whatever few ways
your code here is different?

[Marc Treib, 2015/03/17 12:18:26]

I've looked at that, but the code is actually not that similar. Much of
WebstorePrivateFunctionWithPermissionPrompt deals with the
ExtensionInstallPrompt, which InstallBundle doesn't use. The only really similar
part is the parsing/validation of the Params. That could maybe be extracted into
a helper function, but InstallBundle uses a different format for the return
values, so that's also awkward... (InstallBundle has either an error or a return
value (like CompleteInstall), but WithPermissionPrompt has both. Which you're
not supposed to do, see the comment here:
https://code.google.com/p/chromium/codesearch#chromium/src/extensions/browser...)

[asargent_no_longer_on_chrome, 2015/03/24 23:34:00]

Sorry, I guess I was referring to the ::Run method most - it looks like 80% of
the lines in it are identical to
WebstorePrivateFunctionWithPermissionPrompt<Params>::Run

[Marc Treib, 2015/03/25 11:21:59]

I just removed the bundle ID (since it wasn't used for anything). The icon_data
will also be removed soon, and after http://crrev.com/931993002 I won't be using
a WebstoreInstallHelper anymore here. Then the only (mostly) common code will be
the few lines for getting and resolving the icon_url. I don't think those
warrant a helper function.

 WebstorePrivateEnableAppLauncherFunction::
     WebstorePrivateEnableAppLauncherFunction() : chrome_details_(this) {}
 
 WebstorePrivateEnableAppLauncherFunction::
     ~WebstorePrivateEnableAppLauncherFunction() {}
 
 ExtensionFunction::ResponseAction
 WebstorePrivateEnableAppLauncherFunction::Run() {
   AppListService* app_list_service = AppListService::Get(
       GetHostDesktopTypeForWebContents(
@@ skipping 160 matching lines @@
 WebstorePrivateGetEphemeralAppsEnabledFunction::
     ~WebstorePrivateGetEphemeralAppsEnabledFunction() {}
 
 ExtensionFunction::ResponseAction
 WebstorePrivateGetEphemeralAppsEnabledFunction::Run() {
   return RespondNow(ArgumentList(GetEphemeralAppsEnabled::Results::Create(
       EphemeralAppLauncher::IsFeatureEnabled())));
 }
 
 }  // namespace extensions