[LargeIconService] Make check_seen param optional for fetching

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/feature_list.h"
@@ skipping 22 matching lines @@
 namespace favicon {
 namespace {
 
 // This feature is only used for accessing field trial parameters, not for
 // switching on/off the code.
 const base::Feature kLargeIconServiceFetchingFeature{
     "LargeIconServiceFetching", base::FEATURE_ENABLED_BY_DEFAULT};
 
 const char kGoogleServerV2RequestFormat[] =
     "https://t0.gstatic.com/faviconV2?"
-    "client=chrome&drop_404_icon=true&check_seen=true&"
+    "client=chrome&drop_404_icon=true&%s"
     "size=%d&min_size=%d&max_size=%d&fallback_opts=TYPE,SIZE,URL&url=%s";
 const char kGoogleServerV2RequestFormatParam[] = "request_format";
 
+const char kCheckSeenParam[] = "check_seen=true&";

[pkotwicz, 2017/05/24 05:02:25]

Random question: Does "check_seen=false" work?

[jkrcal, 2017/05/24 08:54:48]

Yes. Any non-"true" value of check_seen is equivalent to skipping the parameter.

+
 const int kGoogleServerV2EnforcedMinSizeInPixel = 32;
 const char kGoogleServerV2EnforcedMinSizeInPixelParam[] =
     "enforced_min_size_in_pixel";
 
 const double kGoogleServerV2DesiredToMaxSizeFactor = 2.0;
 const char kGoogleServerV2DesiredToMaxSizeFactorParam[] =
     "desired_to_max_size_factor";
 
 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 GetRequestUrlForGoogleServerV2(const GURL& page_url,
                                     int min_source_size_in_pixel,
-                                    int desired_size_in_pixel) {
+                                    int desired_size_in_pixel,
+                                    bool may_page_url_be_private) {
   std::string url_format = base::GetFieldTrialParamValueByFeature(
       kLargeIconServiceFetchingFeature, kGoogleServerV2RequestFormatParam);
   double desired_to_max_size_factor = base::GetFieldTrialParamByFeatureAsDouble(
       kLargeIconServiceFetchingFeature,
       kGoogleServerV2DesiredToMaxSizeFactorParam,
       kGoogleServerV2DesiredToMaxSizeFactor);
 
   min_source_size_in_pixel = std::max(
       min_source_size_in_pixel, base::GetFieldTrialParamByFeatureAsInt(
                                     kLargeIconServiceFetchingFeature,
                                     kGoogleServerV2EnforcedMinSizeInPixelParam,
                                     kGoogleServerV2EnforcedMinSizeInPixel));
   desired_size_in_pixel =
       std::max(desired_size_in_pixel, min_source_size_in_pixel);
   int max_size_in_pixel =
       static_cast<int>(desired_size_in_pixel * desired_to_max_size_factor);
 
   return GURL(base::StringPrintf(
       url_format.empty() ? kGoogleServerV2RequestFormat : url_format.c_str(),
-      desired_size_in_pixel, min_source_size_in_pixel, max_size_in_pixel,
-      page_url.spec().c_str()));
+      may_page_url_be_private ? kCheckSeenParam : "", desired_size_in_pixel,
+      min_source_size_in_pixel, max_size_in_pixel, 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() &&
          db_result.pixel_size.width() >= min_source_size;
 }
 
 // Wraps the PNG data in |db_result| in a gfx::Image. If |desired_size| is not
@@ skipping 237 matching lines @@
   return GetLargeIconOrFallbackStyleImpl(
       page_url, min_source_size_in_pixel, desired_size_in_pixel,
       favicon_base::LargeIconCallback(), image_callback, tracker);
 }
 
 void LargeIconService::
     GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
         const GURL& page_url,
         int min_source_size_in_pixel,
         int desired_size_in_pixel,
+        bool may_page_url_be_private,
         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 server_request_url = GetRequestUrlForGoogleServerV2(
-      trimmed_page_url, min_source_size_in_pixel, desired_size_in_pixel);
+      trimmed_page_url, min_source_size_in_pixel, desired_size_in_pixel,
+      may_page_url_be_private);
 
   // Do not download if the URL is invalid after trimming, or there is a
   // previous cache miss recorded for |server_request_url|.
   if (!server_request_url.is_valid() || !trimmed_page_url.is_valid() ||
       !image_fetcher_ ||
       favicon_service_->WasUnableToDownloadFavicon(server_request_url)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, false));
     return;
   }
@@ skipping 48 matching lines @@
   // 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