Extract renderer-side favicon downloading code into separate helper class

chrome/renderer/chrome_render_view_observer.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/renderer/chrome_render_view_observer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/icon_messages.h"
+#include "chrome/common/favicon_url.h"
 #include "chrome/common/prerender_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/external_host_bindings.h"
+#include "chrome/renderer/favicon_helper.h"
 #include "chrome/renderer/frame_sniffer.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/translate_helper.h"
 #include "chrome/renderer/webview_color_overlay.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "net/base/data_url.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 158 matching lines @@
   replacements.ClearRef();
   return url.ReplaceComponents(replacements);
 }
 }  // namespace
 
 ChromeRenderViewObserver::ChromeRenderViewObserver(
     content::RenderView* render_view,
     ContentSettingsObserver* content_settings,
     ChromeRenderProcessObserver* chrome_render_process_observer,
     extensions::Dispatcher* extension_dispatcher,
-    TranslateHelper* translate_helper)
+    TranslateHelper* translate_helper,
+    FaviconHelper* favicon_helper)
     : content::RenderViewObserver(render_view),
       chrome_render_process_observer_(chrome_render_process_observer),
       extension_dispatcher_(extension_dispatcher),
       content_settings_(content_settings),
       translate_helper_(translate_helper),
       phishing_classifier_(NULL),
+      favicon_helper_(favicon_helper),
       last_indexed_page_id_(-1),
       allow_displaying_insecure_content_(false),
       allow_running_insecure_content_(false),
       capture_timer_(false, false) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   render_view->GetWebView()->setPermissionClient(this);
   if (!command_line.HasSwitch(switches::kDisableClientSidePhishingDetection))
     OnSetClientSidePhishingDetection(true);
 }
 
 ChromeRenderViewObserver::~ChromeRenderViewObserver() {
 }
 
 bool ChromeRenderViewObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeRenderViewObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_WebUIJavaScript, OnWebUIJavaScript)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_CaptureSnapshot, OnCaptureSnapshot)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_HandleMessageFromExternalHost,
                         OnHandleMessageFromExternalHost)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_JavaScriptStressTestControl,
                         OnJavaScriptStressTestControl)
-    IPC_MESSAGE_HANDLER(IconMsg_DownloadFavicon, OnDownloadFavicon)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowDisplayingInsecureContent,
                         OnSetAllowDisplayingInsecureContent)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowRunningInsecureContent,
                         OnSetAllowRunningInsecureContent)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetClientSidePhishingDetection,
                         OnSetClientSidePhishingDetection)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetVisuallyDeemphasized,
                         OnSetVisuallyDeemphasized)
 #if defined(OS_CHROMEOS)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_StartFrameSniffer, OnStartFrameSniffer)
@@ skipping 54 matching lines @@
 
 void ChromeRenderViewObserver::OnJavaScriptStressTestControl(int cmd,
                                                              int param) {
   if (cmd == kJavaScriptStressTestSetStressRunType) {
     v8::Testing::SetStressRunType(static_cast<v8::Testing::StressType>(param));
   } else if (cmd == kJavaScriptStressTestPrepareStressRun) {
     v8::Testing::PrepareStressRun(param);
   }
 }
 
-void ChromeRenderViewObserver::OnDownloadFavicon(int id,
-                                                 const GURL& image_url,
-                                                 int image_size) {
-  bool data_image_failed = false;
-  if (image_url.SchemeIs("data")) {
-    SkBitmap data_image = ImageFromDataUrl(image_url);
-    data_image_failed = data_image.empty();
-    if (!data_image_failed) {
-      std::vector<SkBitmap> images(1, data_image);
-      Send(new IconHostMsg_DidDownloadFavicon(
-          routing_id(), id, image_url, false, image_size, images));
-    }
-  }
-
-  if (data_image_failed ||
-      !DownloadFavicon(id, image_url, image_size)) {
-    Send(new IconHostMsg_DidDownloadFavicon(
-        routing_id(), id, image_url, true, image_size,
-        std::vector<SkBitmap>()));
-  }
-}
-
 void ChromeRenderViewObserver::OnSetAllowDisplayingInsecureContent(bool allow) {
   allow_displaying_insecure_content_ = allow;
   WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (main_frame)
     main_frame->reload();
 }
 
 void ChromeRenderViewObserver::OnSetAllowRunningInsecureContent(bool allow) {
   allow_running_insecure_content_ = allow;
   OnSetAllowDisplayingInsecureContent(allow);
@@ skipping 367 matching lines @@
     icon_types |= WebIconURL::TypeTouchPrecomposed | WebIconURL::TypeTouch;
 
   WebVector<WebIconURL> icon_urls =
       render_view()->GetWebView()->mainFrame()->iconURLs(icon_types);
   std::vector<FaviconURL> urls;
   for (size_t i = 0; i < icon_urls.size(); i++) {
     WebURL url = icon_urls[i].iconURL();
     if (!url.isEmpty())
       urls.push_back(FaviconURL(url, ToFaviconType(icon_urls[i].iconType())));
   }
-  if (!urls.empty()) {
-    Send(new IconHostMsg_UpdateFaviconURL(
-        routing_id(), render_view()->GetPageId(), urls));
-  }
+  favicon_helper_->SendUpdateFaviconURL(
+      routing_id(), render_view()->GetPageId(), urls);
 }
 
 void ChromeRenderViewObserver::DidChangeIcon(WebFrame* frame,
                                              WebIconURL::Type icon_type) {
   if (frame->parent())
     return;
 
   if (!chrome::kEnableTouchIcon &&
       icon_type != WebIconURL::TypeFavicon)
     return;
 
   WebVector<WebIconURL> icon_urls = frame->iconURLs(icon_type);
   std::vector<FaviconURL> urls;
   for (size_t i = 0; i < icon_urls.size(); i++) {
     urls.push_back(FaviconURL(icon_urls[i].iconURL(),
                               ToFaviconType(icon_urls[i].iconType())));
   }
-  Send(new IconHostMsg_UpdateFaviconURL(
-      routing_id(), render_view()->GetPageId(), urls));
+  favicon_helper_->SendUpdateFaviconURL(
+      routing_id(), render_view()->GetPageId(), urls);
 }
 
 void ChromeRenderViewObserver::DidCommitProvisionalLoad(
     WebFrame* frame, bool is_new_navigation) {
   if (!is_new_navigation)
     return;
 
   CapturePageInfoLater(
       true,  // preliminary_capture
       base::TimeDelta::FromMilliseconds(kDelayForForcedCaptureMs));
@@ skipping 175 matching lines @@
 }
 
 ExternalHostBindings* ChromeRenderViewObserver::GetExternalHostBindings() {
   if (!external_host_bindings_.get()) {
     external_host_bindings_.reset(new ExternalHostBindings(
         render_view(), routing_id()));
   }
   return external_host_bindings_.get();
 }
 
-bool ChromeRenderViewObserver::DownloadFavicon(int id,
-                                               const GURL& image_url,
-                                               int image_size) {
-  // Make sure webview was not shut down.
-  if (!render_view()->GetWebView())
-    return false;
-  // Create an image resource fetcher and assign it with a call back object.
-  image_fetchers_.push_back(linked_ptr<MultiResolutionImageResourceFetcher>(
-      new MultiResolutionImageResourceFetcher(
-          image_url, render_view()->GetWebView()->mainFrame(), id,
-          WebURLRequest::TargetIsFavicon,
-          base::Bind(&ChromeRenderViewObserver::DidDownloadFavicon,
-                     base::Unretained(this), image_size))));
-  return true;
-}
-
-void ChromeRenderViewObserver::DidDownloadFavicon(
-    int requested_size,
-    MultiResolutionImageResourceFetcher* fetcher,
-    const std::vector<SkBitmap>& images) {
-  // Notify requester of image download status.
-  Send(new IconHostMsg_DidDownloadFavicon(routing_id(),
-                                          fetcher->id(),
-                                          fetcher->image_url(),
-                                          images.empty(),
-                                          requested_size,
-                                          images));
-
-  // Remove the image fetcher from our pending list. We're in the callback from
-  // MultiResolutionImageResourceFetcher, best to delay deletion.
-  ImageResourceFetcherList::iterator iter;
-  for (iter = image_fetchers_.begin(); iter != image_fetchers_.end(); ++iter) {
-    if (iter->get() == fetcher) {
-      iter->release();
-      image_fetchers_.erase(iter);
-      break;
-    }
-  }
-  MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
-}
-
-SkBitmap ChromeRenderViewObserver::ImageFromDataUrl(const GURL& url) const {
-  std::string mime_type, char_set, data;
-  if (net::DataURL::Parse(url, &mime_type, &char_set, &data) && !data.empty()) {
-    // Decode the favicon using WebKit's image decoder.
-    webkit_glue::ImageDecoder decoder(
-        gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize));
-    const unsigned char* src_data =
-        reinterpret_cast<const unsigned char*>(&data[0]);
-
-    return decoder.Decode(src_data, data.size());
-  }
-  return SkBitmap();
-}
-
 bool ChromeRenderViewObserver::IsStrictSecurityHost(const std::string& host) {
   return (strict_security_hosts_.find(host) != strict_security_hosts_.end());
 }