chrome/browser/extensions/webstore_install_helper.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/webstore_install_helper.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "base/values.h"
  12 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
  13 #include "chrome/common/chrome_utility_messages.h"
  14 #include "chrome/common/extensions/chrome_utility_extensions_messages.h"
  15 #include "chrome/grit/generated_resources.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/utility_process_host.h"
  18 #include "net/base/load_flags.h"
  19 #include "net/url_request/url_request.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21
  22 using content::BrowserThread;
  23 using content::UtilityProcessHost;
  24
  25 namespace {
  26
  27 const char kImageDecodeError[] = "Image decode failed";
  28
  29 }  // namespace
  30
  31 namespace extensions {
  32
  33 WebstoreInstallHelper::WebstoreInstallHelper(
  34     Delegate* delegate,
  35     const std::string& id,
  36     const std::string& manifest,
  37     const GURL& icon_url,
  38     net::URLRequestContextGetter* context_getter)
  39     : delegate_(delegate),
  40       id_(id),
  41       manifest_(manifest),
  42       icon_url_(icon_url),
  43       context_getter_(context_getter),
  44       icon_decode_complete_(false),
  45       manifest_parse_complete_(false),
  46       parse_error_(Delegate::UNKNOWN_ERROR) {
  47 }
  48
  49 WebstoreInstallHelper::~WebstoreInstallHelper() {}
  50
  51 void WebstoreInstallHelper::Start() {
  52   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  53
  54   if (icon_url_.is_empty()) {
  55     icon_decode_complete_ = true;
  56   } else {
  57     // No existing |icon_fetcher_| to avoid unbalanced AddRef().
  58     CHECK(!icon_fetcher_.get());
  59     AddRef();  // Balanced in OnFetchComplete().
  60     icon_fetcher_.reset(new chrome::BitmapFetcher(icon_url_, this));
  61     icon_fetcher_->Start(
  62         context_getter_, std::string(),
  63         net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
  64         net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_DO_NOT_SEND_COOKIES);
  65   }
  66
  67   BrowserThread::PostTask(
  68       BrowserThread::IO,
  69       FROM_HERE,
  70       base::Bind(&WebstoreInstallHelper::StartWorkOnIOThread, this));
  71 }
  72
  73 void WebstoreInstallHelper::StartWorkOnIOThread() {
  74   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  75   utility_host_ = UtilityProcessHost::Create(
  76       this, base::ThreadTaskRunnerHandle::Get().get())->AsWeakPtr();
  77   utility_host_->SetName(l10n_util::GetStringUTF16(
  78       IDS_UTILITY_PROCESS_JSON_PARSER_NAME));
  79   utility_host_->StartBatchMode();
  80
  81   utility_host_->Send(new ChromeUtilityMsg_ParseJSON(manifest_));
  82 }
  83
  84 bool WebstoreInstallHelper::OnMessageReceived(const IPC::Message& message) {
  85   bool handled = true;
  86   IPC_BEGIN_MESSAGE_MAP(WebstoreInstallHelper, message)
  87     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Succeeded,
  88                         OnJSONParseSucceeded)
  89     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Failed,
  90                         OnJSONParseFailed)
  91     IPC_MESSAGE_UNHANDLED(handled = false)
  92   IPC_END_MESSAGE_MAP()
  93   return handled;
  94 }
  95
  96 void WebstoreInstallHelper::OnFetchComplete(const GURL& url,
  97                                             const SkBitmap* image) {
  98   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  99   // OnFetchComplete should only be called as icon_fetcher_ delegate to avoid
 100   // unbalanced Release().
 101   CHECK(icon_fetcher_.get());
 102
 103   if (image)
 104     icon_ = *image;
 105   icon_decode_complete_ = true;
 106   if (icon_.empty()) {
 107     error_ = kImageDecodeError;
 108     parse_error_ = Delegate::ICON_ERROR;
 109   }
 110   icon_fetcher_.reset();
 111   BrowserThread::PostTask(
 112       BrowserThread::IO,
 113       FROM_HERE,
 114       base::Bind(&WebstoreInstallHelper::ReportResultsIfComplete, this));
 115   Release();  // Balanced in Start().
 116 }
 117
 118 void WebstoreInstallHelper::OnJSONParseSucceeded(
 119     const base::ListValue& wrapper) {
 120   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 121   manifest_parse_complete_ = true;
 122   const base::Value* value = NULL;
 123   CHECK(wrapper.Get(0, &value));
 124   if (value->IsType(base::Value::TYPE_DICTIONARY)) {
 125     parsed_manifest_.reset(
 126         static_cast<const base::DictionaryValue*>(value)->DeepCopy());
 127   } else {
 128     parse_error_ = Delegate::MANIFEST_ERROR;
 129   }
 130   ReportResultsIfComplete();
 131 }
 132
 133 void WebstoreInstallHelper::OnJSONParseFailed(
 134     const std::string& error_message) {
 135   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 136   manifest_parse_complete_ = true;
 137   error_ = error_message;
 138   parse_error_ = Delegate::MANIFEST_ERROR;
 139   ReportResultsIfComplete();
 140 }
 141
 142 void WebstoreInstallHelper::ReportResultsIfComplete() {
 143   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 144
 145   if (!icon_decode_complete_ || !manifest_parse_complete_)
 146     return;
 147
 148   // The utility_host_ will take care of deleting itself after this call.
 149   if (utility_host_.get()) {
 150     utility_host_->EndBatchMode();
 151     utility_host_.reset();
 152   }
 153
 154   BrowserThread::PostTask(
 155       BrowserThread::UI,
 156       FROM_HERE,
 157       base::Bind(&WebstoreInstallHelper::ReportResultFromUIThread, this));
 158 }
 159
 160 void WebstoreInstallHelper::ReportResultFromUIThread() {
 161   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 162   if (error_.empty() && parsed_manifest_)
 163     delegate_->OnWebstoreParseSuccess(id_, icon_, parsed_manifest_.release());
 164   else
 165     delegate_->OnWebstoreParseFailure(id_, parse_error_, error_);
 166 }
 167
 168 }  // namespace extensions