Use hi-resolution favicon variants if available.

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"
@@ skipping 33 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "webkit/glue/image_decoder.h"
-#include "webkit/glue/image_resource_fetcher.h"
+#include "webkit/glue/multi_resolution_image_resource_fetcher.h"
 #include "webkit/glue/webkit_glue.h"
 #include "v8/include/v8-testing.h"
 
 using WebKit::WebAccessibilityObject;
 using WebKit::WebCString;
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebIconURL;
 using WebKit::WebRect;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTouchEvent;
 using WebKit::WebURL;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 using WebKit::WebVector;
 using extensions::APIPermission;
-using webkit_glue::ImageResourceFetcher;
+using webkit_glue::MultiResolutionImageResourceFetcher;
 
 // Delay in milliseconds that we'll wait before capturing the page contents
 // and thumbnail.
 static const int kDelayForCaptureMs = 500;
 
 // Typically, we capture the page data once the page is loaded.
 // Sometimes, the page never finishes to load, preventing the page capture
 // To workaround this problem, we always perform a capture after the following
 // delay.
 static const int kDelayForForcedCaptureMs = 6000;
@@ skipping 240 matching lines @@
 }
 
 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, data_image));
+          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, SkBitmap()));
+        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();
 }
 
@@ skipping 687 matching lines @@
   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<ImageResourceFetcher>(
-      new ImageResourceFetcher(
-          image_url, render_view()->GetWebView()->mainFrame(), id, image_size,
+  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)))));
+                     base::Unretained(this), image_size))));
   return true;
 }
 
 void ChromeRenderViewObserver::DidDownloadFavicon(
-    ImageResourceFetcher* fetcher, const SkBitmap& image) {
+    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(),
-                                          image.isNull(),
-                                          image));
+                                          images.empty(),
+                                          requested_size,
+                                          images));
 
   // Remove the image fetcher from our pending list. We're in the callback from
-  // ImageResourceFetcher, best to delay deletion.
+  // 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());
 }