Make image_decoder a Leaky LazyInstance

chrome/browser/extensions/webstore_install_helper.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/webstore_install_helper.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/values.h"
@@ skipping 14 matching lines @@
 const char kImageDecodeError[] = "Image decode failed";
 
 }  // namespace
 
 namespace extensions {
 
 WebstoreInstallHelper::WebstoreInstallHelper(
     Delegate* delegate,
     const std::string& id,
     const std::string& manifest,
-    const std::string& icon_data,
     const GURL& icon_url,
     net::URLRequestContextGetter* context_getter)
     : delegate_(delegate),
       id_(id),
       manifest_(manifest),
-      icon_base64_data_(icon_data),
       icon_url_(icon_url),
       context_getter_(context_getter),
       icon_decode_complete_(false),
       manifest_parse_complete_(false),
       parse_error_(Delegate::UNKNOWN_ERROR) {}
 
 WebstoreInstallHelper::~WebstoreInstallHelper() {}
 
 void WebstoreInstallHelper::Start() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(icon_base64_data_.empty() || icon_url_.is_empty());
 
-  if (icon_base64_data_.empty() && icon_url_.is_empty())
+  if (icon_url_.is_empty())
     icon_decode_complete_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&WebstoreInstallHelper::StartWorkOnIOThread, this));
 
   if (!icon_url_.is_empty()) {
     CHECK(context_getter_);
     url_fetcher_.reset(net::URLFetcher::Create(
         icon_url_, net::URLFetcher::GET, this));
     url_fetcher_->SetRequestContext(context_getter_);
     url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                                net::LOAD_DO_NOT_SEND_COOKIES);
 
     url_fetcher_->Start();
     // We'll get called back in OnURLFetchComplete.
   }
 }
 
 void WebstoreInstallHelper::StartWorkOnIOThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   utility_host_ = UtilityProcessHost::Create(
       this, base::MessageLoopProxy::current().get())->AsWeakPtr();
   utility_host_->StartBatchMode();
 
-  if (!icon_base64_data_.empty())
-    utility_host_->Send(
-        new ChromeUtilityMsg_DecodeImageBase64(icon_base64_data_));
-
   utility_host_->Send(new ChromeUtilityMsg_ParseJSON(manifest_));
 }
 
 void WebstoreInstallHelper::OnURLFetchComplete(
     const net::URLFetcher* source) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(source == url_fetcher_.get());
   int response_code =
       source->GetStatus().is_success() ? source->GetResponseCode() : 0;
   if (!source->GetStatus().is_success() ||
       response_code / 100 == 4 || response_code / 100 == 5) {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
+        BrowserThread::IO, FROM_HERE,
         base::Bind(&WebstoreInstallHelper::OnDecodeImageFailed, this));
   } 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,
         base::Bind(&WebstoreInstallHelper::StartFetchedImageDecode, this));
   }
   url_fetcher_.reset();
 }
 
 void WebstoreInstallHelper::StartFetchedImageDecode() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  CHECK(utility_host_.get());
-  utility_host_->Send(new ChromeUtilityMsg_DecodeImage(fetched_icon_data_,
-                                                       false));
+  ImageDecoder::GetInstance()->Start(
+      this, std::string(fetched_icon_data_.begin(), fetched_icon_data_.end()),

[asargent_no_longer_on_chrome, 2015/03/12 21:40:08]

I think we should just change fetched_icon_data_ to be a std::string instead of
std::vector<unsigned char>, and up in ::OnURLFetchComplete around line 94 we can
grab the response from the URLFetch and put it directly into fetched_icon_data_
instead of the response_data temporary. 

That might also save a copy of the bytes into the temporary std::string here on
line 109 (I'm not sure off the top of my head whether the compiler would be
smart enough to optimize that away or not). 

[Theresa, 2015/03/12 22:19:10]

Good catch :) Instead of doing that, I removed this method
(StartFetchedImageDecode) and call ImageDecoder::GetInstance()->Start directly
from OnURLFetchComplete. StartFetchedImageDecode used to be needed because
interaction with the utility process had to happen on the IO thread, but calling
ImageDecoder::GetInstance()->Start can happen from any thread. This change also
removed the need for fetched_icon_data_ so I delete that variable as well.

+      ImageDecoder::DEFAULT_CODEC,
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO),
+      false);
 }
 
-
 bool WebstoreInstallHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebstoreInstallHelper, 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)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-
-void WebstoreInstallHelper::OnDecodeImageSucceeded(
-    const SkBitmap& decoded_image) {
+void WebstoreInstallHelper::OnImageDecoded(const SkBitmap& decoded_image) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   icon_ = decoded_image;
   icon_decode_complete_ = true;
   ReportResultsIfComplete();
 }
 
 void WebstoreInstallHelper::OnDecodeImageFailed() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   icon_decode_complete_ = true;
   error_ = kImageDecodeError;
@@ skipping 45 matching lines @@
 
 void WebstoreInstallHelper::ReportResultFromUIThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (error_.empty() && parsed_manifest_)
     delegate_->OnWebstoreParseSuccess(id_, icon_, parsed_manifest_.release());
   else
     delegate_->OnWebstoreParseFailure(id_, parse_error_, error_);
 }
 
 }  // namespace extensions