[LargeIconService] Store downloaded icons under original URL

components/favicon/core/large_icon_service.cc

 // Copyright 2015 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 "components/favicon/core/large_icon_service.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
 #include "components/favicon_base/favicon_util.h"
+#include "components/image_fetcher/core/request_metadata.h"
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/url_canon.h"
 
 namespace favicon {
 namespace {
 
 const char kGoogleServerV2RequestFormat[] =
     "https://t0.gstatic.com/faviconV2?"
     "client=chrome&drop_404_icon=true&size=%d&min_size=%d&max_size=%d&"
     "fallback_opts=TYPE,SIZE,URL&url=%s";
 const int kGoogleServerV2MaxSizeInPixel = 128;
 const int kGoogleServerV2DesiredSizeInPixel = 64;
 
 GURL TrimPageUrlForGoogleServer(const GURL& page_url) {
   if (!page_url.SchemeIsHTTPOrHTTPS() || page_url.HostIsIPAddress())
     return GURL();
 
   url::Replacements<char> replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
   replacements.ClearQuery();
   replacements.ClearRef();
   return page_url.ReplaceComponents(replacements);
 }
 
-GURL GetIconUrlForGoogleServerV2(const GURL& page_url,
-                                 int min_source_size_in_pixel) {
+GURL GetRequestUrlForGoogleServerV2(const GURL& page_url,
+                                    int min_source_size_in_pixel) {
   return GURL(base::StringPrintf(
       kGoogleServerV2RequestFormat, kGoogleServerV2DesiredSizeInPixel,
       min_source_size_in_pixel, kGoogleServerV2MaxSizeInPixel,
       page_url.spec().c_str()));
 }
 
 bool IsDbResultAdequate(const favicon_base::FaviconRawBitmapResult& db_result,
                         int min_source_size) {
   return db_result.is_valid() &&
          db_result.pixel_size.width() == db_result.pixel_size.height() &&
@@ skipping 150 matching lines @@
     return;
   }
   image_callback_.Run(
       favicon_base::LargeIconImageResult(fallback_icon_style_.release()));
 }
 
 void OnFetchIconFromGoogleServerComplete(
     FaviconService* favicon_service,
     const GURL& page_url,
     const base::Callback<void(bool success)>& callback,
-    const std::string& icon_url,
+    const std::string& server_request_url,
     const gfx::Image& image,
     const image_fetcher::RequestMetadata& metadata) {
   if (image.IsEmpty()) {
-    DLOG(WARNING) << "large icon server fetch empty " << icon_url;
-    favicon_service->UnableToDownloadFavicon(GURL(icon_url));
+    DLOG(WARNING) << "large icon server fetch empty " << server_request_url;
+    favicon_service->UnableToDownloadFavicon(GURL(server_request_url));
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, false));
     return;
   }
 
-  // TODO(crbug.com/699542): Extract the original icon url from the response
-  // headers if available and use it instead of |icon_url|. Possibly the type
-  // too, because using TOUCH_ICON is a hacky way that allows us to not
-  // interfere with sync.
+  // If given, use the original favicon URL from Content-Location http header.
+  // Otherwise, use the request URL as fallback.
+  std::string original_icon_url = metadata.content_location_header;
+  if (original_icon_url.empty()) {
+    original_icon_url = server_request_url;
+  }
 
   // Write fetched icons to FaviconService's cache, but only if no icon was
   // available (clients are encouraged to do this in advance, but meanwhile
   // something else could've been written). By marking the icons initially
   // expired (out-of-date), they will be refetched when we visit the original
   // page any time in the future.
-  favicon_service->SetLastResortFavicons(page_url, GURL(icon_url),
+  favicon_service->SetLastResortFavicons(page_url, GURL(original_icon_url),
                                          favicon_base::IconType::TOUCH_ICON,
                                          image, callback);
 }
 
 }  // namespace
 
 LargeIconService::LargeIconService(
     FaviconService* favicon_service,
     const scoped_refptr<base::TaskRunner>& background_task_runner,
     std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher)
@@ skipping 33 matching lines @@
 }
 
 void LargeIconService::
     GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
         const GURL& page_url,
         int min_source_size_in_pixel,
         const base::Callback<void(bool success)>& callback) {
   DCHECK_LE(0, min_source_size_in_pixel);
 
   const GURL trimmed_page_url = TrimPageUrlForGoogleServer(page_url);
-  const GURL icon_url =
-      GetIconUrlForGoogleServerV2(trimmed_page_url, min_source_size_in_pixel);
+  const GURL server_request_url = GetRequestUrlForGoogleServerV2(
+      trimmed_page_url, min_source_size_in_pixel);
 
   // Do not download if the URL is invalid after trimming, or there is a
-  // previous cache miss recorded for |icon_url|.
+  // previous cache miss recorded for |server_request_url|.
   if (!trimmed_page_url.is_valid() || !image_fetcher_ ||
-      favicon_service_->WasUnableToDownloadFavicon(icon_url)) {
+      favicon_service_->WasUnableToDownloadFavicon(server_request_url)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, false));
     return;
   }
 
   image_fetcher_->SetDataUseServiceName(
       data_use_measurement::DataUseUserData::LARGE_ICON_SERVICE);
   image_fetcher_->StartOrQueueNetworkRequest(
-      icon_url.spec(), icon_url,
+      server_request_url.spec(), server_request_url,
       base::Bind(&OnFetchIconFromGoogleServerComplete, favicon_service_,
                  page_url, callback));
 }
 
 base::CancelableTaskTracker::TaskId
 LargeIconService::GetLargeIconOrFallbackStyleImpl(
     const GURL& page_url,
     int min_source_size_in_pixel,
     int desired_size_in_pixel,
     const favicon_base::LargeIconCallback& raw_bitmap_callback,
     const favicon_base::LargeIconImageCallback& image_callback,
     base::CancelableTaskTracker* tracker) {
   DCHECK_LE(1, min_source_size_in_pixel);
   DCHECK_LE(0, desired_size_in_pixel);
 
   scoped_refptr<LargeIconWorker> worker = new LargeIconWorker(
       min_source_size_in_pixel, desired_size_in_pixel, raw_bitmap_callback,
       image_callback, background_task_runner_, tracker);
 
   // TODO(beaudoin): For now this is just a wrapper around
   //   GetLargestRawFaviconForPageURL. Add the logic required to select the best
   //   possible large icon. Also add logic to fetch-on-demand when the URL of
   //   a large icon is known but its bitmap is not available.
   return favicon_service_->GetLargestRawFaviconForPageURL(
       page_url, large_icon_types_, min_source_size_in_pixel,
       base::Bind(&LargeIconWorker::OnIconLookupComplete, worker), tracker);
 }
 
 }  // namespace favicon