Add a iconUrl parameter to webstorePrivate.beginInstallWithManifest2

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 <vector>
 
 #include "base/scoped_temp_dir.h"
@@ skipping 12 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
+#include "content/common/url_fetcher.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#include "net/url_request/url_request_status.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 const char kAppInstallBubbleKey[] = "appInstallBubble";
 const char kIconDataKey[] = "iconData";
+const char kIconUrlKey[] = "iconUrl";
 const char kIdKey[] = "id";
 const char kLocalizedNameKey[] = "localizedName";
 const char kLoginKey[] = "login";
 const char kManifestKey[] = "manifest";
 const char kTokenKey[] = "token";
 
+const char kCannotSpecifyIconDataAndUrlError[] =
+    "You cannot specify both icon data and an icon url";
 const char kImageDecodeError[] = "Image decode failed";
+const char kInvalidIconUrlError[] = "Invalid icon url";
 const char kInvalidIdError[] = "Invalid id";
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kNoPreviousBeginInstallError[] =
     "* does not match a previous call to beginInstall";
 const char kUserCancelledError[] = "User cancelled install";
 const char kUserGestureRequiredError[] =
     "This function must be called during a user gesture";
 
 ProfileSyncService* test_sync_service = NULL;
 BrowserSignin* test_signin = NULL;
@@ skipping 87 matching lines @@
   }
 
   // This gets cleared in CrxInstaller::ConfirmInstall(). TODO(asargent) - in
   // the future we may also want to add time-based expiration, where a whitelist
   // entry is only valid for some number of minutes.
   CrxInstaller::SetWhitelistedInstallId(id);
   return true;
 }
 
 // This is a class to help BeginInstallWithManifestFunction manage sending
-// JSON manifests and base64-encoded icon data to the utility process for
-// parsing.
-class SafeBeginInstallHelper : public UtilityProcessHost::Client {
+// work to the utility process for parsing manifests and fetching/decoding
+// icon data.
+class SafeBeginInstallHelper : public UtilityProcessHost::Client,
+                               public URLFetcher::Delegate {
  public:
+  // Only one of icon_data or icon_url should be non-empty. If icon_url is
+  // non-empty, context_getter should be filled in, but otherwise NULL.
   SafeBeginInstallHelper(BeginInstallWithManifestFunction* client,
+                         const std::string& manifest,
                          const std::string& icon_data,
-                         const std::string& manifest)
+                         const GURL& icon_url,
+                         net::URLRequestContextGetter* context_getter)
       : client_(client),
-        icon_data_(icon_data),
         manifest_(manifest),
+        icon_base64_data_(icon_data),
+        icon_url_(icon_url),
+        context_getter_(context_getter),
         utility_host_(NULL),
         icon_decode_complete_(false),
         manifest_parse_complete_(false),
         parse_error_(BeginInstallWithManifestFunction::UNKNOWN_ERROR) {}
 
   void Start() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    CHECK(icon_base64_data_.empty() || icon_url_.is_empty());
+
+    if (icon_base64_data_.empty() && icon_url_.is_empty())
+      icon_decode_complete_ = true;
+
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         NewRunnableMethod(this,
                           &SafeBeginInstallHelper::StartWorkOnIOThread));
+
+    if (!icon_url_.is_empty()) {
+      CHECK(context_getter_);
+      url_fetcher_.reset(new URLFetcher(icon_url_, URLFetcher::GET, this));
+      url_fetcher_->set_request_context(context_getter_);
+
+      url_fetcher_->Start();
+      // We'll get called back in OnURLFetchComplete.
+    }
   }
 
   void StartWorkOnIOThread() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     utility_host_ = new UtilityProcessHost(this, BrowserThread::IO);
     utility_host_->StartBatchMode();
-    if (icon_data_.empty())
-      icon_decode_complete_ = true;
-    else
-      utility_host_->Send(new ChromeUtilityMsg_DecodeImageBase64(icon_data_));
+
+    if (!icon_base64_data_.empty())
+      utility_host_->Send(
+          new ChromeUtilityMsg_DecodeImageBase64(icon_base64_data_));
+
     utility_host_->Send(new ChromeUtilityMsg_ParseJSON(manifest_));
   }
 
+  // Implementing the URLFetcher::Delegate interface.
+  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    CHECK(source == url_fetcher_.get());
+    if (source->status().status() != net::URLRequestStatus::SUCCESS ||
+        source->response_code() != 200) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          NewRunnableMethod(this,
+                            &SafeBeginInstallHelper::OnDecodeImageFailed));
+    } else {
+      std::string response_data;
+      source->GetResponseAsString(&response_data);
+      fetched_icon_data_.insert(fetched_icon_data_.begin(),
+                                response_data.begin(),
+                                response_data.end());
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          NewRunnableMethod(this,
+                            &SafeBeginInstallHelper::StartFetchedImageDecode));
+    }
+    url_fetcher_.reset();
+  }
+
+  void StartFetchedImageDecode() {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    CHECK(utility_host_);
+    utility_host_->Send(new ChromeUtilityMsg_DecodeImage(fetched_icon_data_));
+  }
+
   // Implementing pieces of the UtilityProcessHost::Client interface.
-  virtual bool OnMessageReceived(const IPC::Message& message) {
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(SafeBeginInstallHelper, message)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Succeeded,
                           OnDecodeImageSucceeded)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Failed,
                           OnDecodeImageFailed)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Succeeded,
                           OnJSONParseSucceeded)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Failed,
                           OnJSONParseFailed)
@@ skipping 63 matching lines @@
     else
       client_->OnParseFailure(parse_error_, error_);
   }
 
  private:
   ~SafeBeginInstallHelper() {}
 
   // The client who we'll report results back to.
   BeginInstallWithManifestFunction* client_;
 
-  // The data to parse.
-  std::string icon_data_;
+  // The manifest to parse.
   std::string manifest_;
 
+  // Only one of these should be non-empty. If |icon_base64_data_| is non-emtpy,
+  // it's a base64-encoded string that needs to be parsed into an SkBitmap. If
+  // |icon_url_| is non-empty, it needs to be fetched and decoded into an
+  // SkBitmap.
+  std::string icon_base64_data_;
+  GURL icon_url_;
+  std::vector<unsigned char> fetched_icon_data_;
+
+  // For fetching the icon, if needed.
+  scoped_ptr<URLFetcher> url_fetcher_;
+  net::URLRequestContextGetter* context_getter_; // Only usable on UI thread.
+
   UtilityProcessHost* utility_host_;
 
   // Flags for whether we're done doing icon decoding and manifest parsing.
   bool icon_decode_complete_;
   bool manifest_parse_complete_;
 
   // The results of succesful decoding/parsing.
   SkBitmap icon_;
   scoped_ptr<DictionaryValue> parsed_manifest_;
 
@@ skipping 28 matching lines @@
 
   EXTENSION_FUNCTION_VALIDATE(details->GetString(kIdKey, &id_));
   if (!Extension::IdIsValid(id_)) {
     SetResult(INVALID_ID);
     error_ = kInvalidIdError;
     return false;
   }
 
   EXTENSION_FUNCTION_VALIDATE(details->GetString(kManifestKey, &manifest_));
 
+  if (details->HasKey(kIconDataKey) && details->HasKey(kIconUrlKey)) {
+    SetResult(ICON_ERROR);
+    error_ = kCannotSpecifyIconDataAndUrlError;
+    return false;
+  }
+
   if (details->HasKey(kIconDataKey))
     EXTENSION_FUNCTION_VALIDATE(details->GetString(kIconDataKey, &icon_data_));
 
+  GURL icon_url;
+  if (details->HasKey(kIconUrlKey)) {
+    std::string tmp_url;
+    EXTENSION_FUNCTION_VALIDATE(details->GetString(kIconUrlKey, &tmp_url));
+    icon_url = source_url().Resolve(tmp_url);
+    if (!icon_url.is_valid()) {
+      SetResult(INVALID_ICON_URL);
+      error_ = kInvalidIconUrlError;
+      return false;
+    }
+  }
+
   if (details->HasKey(kLocalizedNameKey))
     EXTENSION_FUNCTION_VALIDATE(details->GetString(kLocalizedNameKey,
                                                    &localized_name_));
 
   if (details->HasKey(kAppInstallBubbleKey))
     EXTENSION_FUNCTION_VALIDATE(details->GetBoolean(
         kAppInstallBubbleKey, &use_app_installed_bubble_));
 
-  scoped_refptr<SafeBeginInstallHelper> helper =
-      new SafeBeginInstallHelper(this, icon_data_, manifest_);
-  // The helper will call us back via OnParseSucces or OnParseFailure.
+  net::URLRequestContextGetter* context_getter = NULL;
+  if (!icon_url.is_empty())
+    context_getter = profile()->GetRequestContext();
+
+  scoped_refptr<SafeBeginInstallHelper> helper = new SafeBeginInstallHelper(
+      this, manifest_, icon_data_, icon_url, context_getter);
+
+  // The helper will call us back via OnParseSuccess or OnParseFailure.
   helper->Start();
 
-  // Matched with a Release in OnSuccess/OnFailure.
+  // Matched with a Release in OnParseSuccess/OnParseFailure.
   AddRef();
 
-  // The response is sent asynchronously in OnSuccess/OnFailure.
+  // The response is sent asynchronously in OnParseSuccess/OnParseFailure.
   return true;
 }
 
 
 void BeginInstallWithManifestFunction::SetResult(ResultCode code) {
   switch (code) {
     case ERROR_NONE:
       result_.reset(Value::CreateStringValue(""));
       break;
     case UNKNOWN_ERROR:
@@ skipping 10 matching lines @@
       break;
     case INVALID_ID:
       result_.reset(Value::CreateStringValue("invalid_id"));
       break;
     case PERMISSION_DENIED:
       result_.reset(Value::CreateStringValue("permission_denied"));
       break;
     case NO_GESTURE:
       result_.reset(Value::CreateStringValue("no_gesture"));
       break;
+    case INVALID_ICON_URL:
+      result_.reset(Value::CreateStringValue("invalid_icon_url"));
+      break;
     default:
       CHECK(false);
   }
 }
 
 // static
 void BeginInstallWithManifestFunction::SetIgnoreUserGestureForTests(
     bool ignore) {
   ignore_user_gesture_for_tests = ignore;
 }
@@ skipping 282 matching lines @@
   }
 
   DCHECK(waiting_for_token_);
 
   result_.reset(CreateLoginResult(profile_->GetOriginalProfile()));
   SendResponse(true);
 
   // Matches the AddRef in RunImpl().
   Release();
 }