Reload favicon from HTTP cache on Ctrl+Refresh

content/renderer/image_loading_helper.cc

 // Copyright (c) 2013 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 "content/renderer/image_loading_helper.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/child/image_decoder.h"
 #include "content/common/image_messages.h"
@@ skipping 86 matching lines @@
 
 namespace content {
 
 ImageLoadingHelper::ImageLoadingHelper(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame) {
 }
 
 ImageLoadingHelper::~ImageLoadingHelper() {
 }
 
-void ImageLoadingHelper::OnDownloadImage(int id,
-                                         const GURL& image_url,
-                                         bool is_favicon,
-                                         uint32_t max_image_size) {
+void ImageLoadingHelper::OnDownloadImage(
+    int id,
+    const GURL& image_url,
+    bool is_favicon,
+    uint32_t max_image_size,
+    bool bypass_cache) {
   std::vector<SkBitmap> result_images;
   std::vector<gfx::Size> result_original_image_sizes;
   if (image_url.SchemeIs(url::kDataScheme)) {
     SkBitmap data_image = ImageFromDataUrl(image_url);
     if (!data_image.empty()) {
       result_images.push_back(ResizeImage(data_image, max_image_size));
       result_original_image_sizes.push_back(
           gfx::Size(data_image.width(), data_image.height()));
     }
   } else {
-    if (DownloadImage(id, image_url, is_favicon, max_image_size)) {
+    if (DownloadImage(id, image_url, is_favicon, max_image_size,
+                      bypass_cache)) {
       // Will complete asynchronously via ImageLoadingHelper::DidDownloadImage
       return;
     }
   }
 
   Send(new ImageHostMsg_DidDownloadImage(routing_id(),
                                          id,
                                          0,
                                          image_url,
                                          result_images,
                                          result_original_image_sizes));
 }
 
-bool ImageLoadingHelper::DownloadImage(int id,
-                                       const GURL& image_url,
-                                       bool is_favicon,
-                                       uint32_t max_image_size) {
+bool ImageLoadingHelper::DownloadImage(
+    int id,
+    const GURL& image_url,
+    bool is_favicon,
+    uint32_t max_image_size,
+    bool bypass_cache) {
   // Create an image resource fetcher and assign it with a call back object.
   image_fetchers_.push_back(new MultiResolutionImageResourceFetcher(
-      image_url,
-      render_frame()->GetWebFrame(),
-      id,
+      image_url, render_frame()->GetWebFrame(), id,
       is_favicon ? WebURLRequest::RequestContextFavicon
                  : WebURLRequest::RequestContextImage,
-      base::Bind(&ImageLoadingHelper::DidDownloadImage,
-                 base::Unretained(this),
+      bypass_cache ? WebURLRequest::ReloadBypassingCache
+                   : WebURLRequest::UseProtocolCachePolicy,
+      base::Bind(&ImageLoadingHelper::DidDownloadImage, base::Unretained(this),
                  max_image_size)));
   return true;
 }
 
 void ImageLoadingHelper::DidDownloadImage(
     uint32_t max_image_size,
     MultiResolutionImageResourceFetcher* fetcher,
     const std::vector<SkBitmap>& images) {
   std::vector<SkBitmap> result_images;
   std::vector<gfx::Size> result_original_image_sizes;
@@ skipping 36 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ImageLoadingHelper, message)
     IPC_MESSAGE_HANDLER(ImageMsg_DownloadImage, OnDownloadImage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 }  // namespace content