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"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/apps/ephemeral_app_launcher.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_ui_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/gpu/gpu_feature_checker.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/safe_image_fetcher.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #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 80 matching lines @@
       return RespondNow(BuildResponse(
           api::webstore_private::RESULT_INVALID_ICON_URL,
           kInvalidIconUrlError));
     }
   }
 
   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_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_);
+
+  GURL icon_url;
+  if (params_->details.icon_url) {
+    icon_url = source_url().Resolve(*params_->details.icon_url);

[asargent_no_longer_on_chrome, 2015/03/26 18:12:50]

FYI, I think the icon_url we're passed is probably always an absolute URL, so we
don't really need to resolve it as a relative URL. But I suppose having this
doesn't hurt anything, as the Resolve method handles absolute URLs just fine,
and perhaps someday could come in handy if we did want to use relative URLs. 
 

[Marc Treib, 2015/03/27 11:52:12]

Acknowledged.

+    if (!icon_url.is_valid())
+      return RespondNow(Error(kInvalidIconUrlError));
+  }
+
+  if (params_->contents.empty())
+    return RespondNow(Error(kInvalidBundleError));
+
+  // The image fetcher will call us back via OnIconFetched.
+  icon_fetcher_.reset(new SafeImageFetcher(
+      icon_url, browser_context()->GetRequestContext(),
+      base::Bind(&WebstorePrivateInstallBundleFunction::OnIconFetched,
+                 base::Unretained(this))));
+
+  // Matched with a Release in OnIconFetched, OnInstallApproval, or
+  // OnInstallComplete.
+  AddRef();

[asargent_no_longer_on_chrome, 2015/03/26 18:12:50]

Instead of doing manual AddRef/Release calls and using base::Unretained for the
various callbacks we pass to the SafeImageFetcher above here and BundleInstaller
calls below, would it make more sense to just let the callbacks take care of the
refcounting for us?

[Marc Treib, 2015/03/27 11:52:12]

Indeed, that's much nicer, thanks! Done.

+
+  // The response is sent asynchronously in OnIconFetched, OnInstallApproval, or
+  // OnInstallComplete.
+  return RespondLater();
+}
+
+void WebstorePrivateInstallBundleFunction::OnIconFetched(const SkBitmap& icon) {
+  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);
+    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::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();
+}
+
 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