Rip out browser-side RID caching for most visited items.

chrome/browser/ui/webui/favicon_source.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/browser/ui/webui/favicon_source.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
@@ skipping 143 matching lines @@
 }
 
 bool FaviconSource::ShouldReplaceExistingSource() const {
   // Leave the existing DataSource in place, otherwise we'll drop any pending
   // requests on the floor.
   return false;
 }
 
 bool FaviconSource::ShouldServiceRequest(const net::URLRequest* request) const {
   if (request->url().SchemeIs(chrome::kChromeSearchScheme)) {
-    return InstantService::IsInstantPath(request->url()) &&
-        InstantIOContext::ShouldServiceRequest(request);
+    // Strip leading slash.
+    std::string path = request->url().path().substr(1);

[Jered, 2013/05/31 17:34:33]

Why do the !path.empty() check here? I think we can omit this, since we're not
actually checking that the path is valid and it seems odd to just check this one
way in which it could be bad.

[kmadhusu, 2013/06/04 02:36:01]

It was just a safety check. Removed.

+    return !path.empty() && InstantIOContext::ShouldServiceRequest(request);
   }
   return URLDataSource::ShouldServiceRequest(request);
 }
 
 bool FaviconSource::HandleMissingResource(const IconRequest& request) {
   // No additional checks to locate the favicon resource in the base
   // implementation.
   return false;
 }
 
 bool FaviconSource::ParsePath(const std::string& raw_path,

[Jered, 2013/05/31 17:34:33]

Here and elsewhere, change "raw_path" to "path".

[kmadhusu, 2013/06/04 02:36:01]

Done.

                               bool* is_icon_url,
                               GURL* url,
                               int* size_in_dip,
                               ui::ScaleFactor* scale_factor) const {
   DCHECK_EQ(16, gfx::kFaviconSize);
 
   *is_icon_url = false;
   *url = GURL();
   *size_in_dip = 16;
   *scale_factor = ui::SCALE_FACTOR_100P;
 
   if (raw_path.empty())
     return false;
 
-  // Translate to regular path if |raw_path| is of the form
-  // chrome-search://favicon/<most_visited_item_id>, where
-  // "most_visited_item_id" is a uint64.
-  std::string path = InstantService::MaybeTranslateInstantPathOnUI(profile_,
-                                                                   raw_path);
   size_t parsed_index = 0;
-  if (HasSubstringAt(path, parsed_index, kLargestParameter)) {
+  if (HasSubstringAt(raw_path, parsed_index, kLargestParameter)) {
     parsed_index += strlen(kLargestParameter);
     *size_in_dip = 0;
-  } else if (HasSubstringAt(path, parsed_index, kSizeParameter)) {
+  } else if (HasSubstringAt(raw_path, parsed_index, kSizeParameter)) {
     parsed_index += strlen(kSizeParameter);
 
-    size_t slash = path.find("/", parsed_index);
+    size_t slash = raw_path.find("/", parsed_index);
     if (slash == std::string::npos)
       return false;
 
-    size_t scale_delimiter = path.find("@", parsed_index);
+    size_t scale_delimiter = raw_path.find("@", parsed_index);
     std::string size_str;
     std::string scale_str;
     if (scale_delimiter == std::string::npos) {
       // Support the legacy size format of 'size/aa/' where 'aa' is the desired
       // size in DIP for the sake of not regressing the extensions which use it.
-      size_str = path.substr(parsed_index, slash - parsed_index);
+      size_str = raw_path.substr(parsed_index, slash - parsed_index);
     } else {
-      size_str = path.substr(parsed_index, scale_delimiter - parsed_index);
-      scale_str = path.substr(scale_delimiter + 1,
-                              slash - scale_delimiter - 1);
+      size_str = raw_path.substr(parsed_index, scale_delimiter - parsed_index);
+      scale_str = raw_path.substr(scale_delimiter + 1,
+                                  slash - scale_delimiter - 1);
     }
 
     if (!base::StringToInt(size_str, size_in_dip))
       return false;
 
     if (*size_in_dip != 64 && *size_in_dip != 32) {
       // Only 64x64, 32x32 and 16x16 icons are supported.
       *size_in_dip = 16;
     }
 
     if (!scale_str.empty())
       webui::ParseScaleFactor(scale_str, scale_factor);
 
     // Return the default favicon (as opposed to a resized favicon) for
     // favicon sizes which are not cached by the favicon service.
     // Currently the favicon service caches:
     // - favicons of sizes "16 * scale factor" px of type FAVICON
     //   where scale factor is one of FaviconUtil::GetFaviconScaleFactors().
     // - the largest TOUCH_ICON / TOUCH_PRECOMPOSED_ICON
     if (*size_in_dip != 16 && icon_types_ == chrome::FAVICON)
       return false;
 
     parsed_index = slash + 1;
   }
 
-  if (HasSubstringAt(path, parsed_index, kIconURLParameter)) {
+  if (HasSubstringAt(raw_path, parsed_index, kIconURLParameter)) {
     parsed_index += strlen(kIconURLParameter);
     *is_icon_url = true;
-    *url = GURL(path.substr(parsed_index));
+    *url = GURL(raw_path.substr(parsed_index));
   } else {
     // URL requests prefixed with "origin/" are converted to a form with an
     // empty path and a valid scheme. (e.g., example.com -->
     // http://example.com/ or http://example.com/a --> http://example.com/)
-    if (HasSubstringAt(path, parsed_index, kOriginParameter)) {
+    if (HasSubstringAt(raw_path, parsed_index, kOriginParameter)) {
       parsed_index += strlen(kOriginParameter);
-      std::string possibly_invalid_url = path.substr(parsed_index);
+      std::string possibly_invalid_url = raw_path.substr(parsed_index);
 
       // If the URL does not specify a scheme (e.g., example.com instead of
       // http://example.com), add "http://" as a default.
       if (!GURL(possibly_invalid_url).has_scheme())
         possibly_invalid_url = "http://" + possibly_invalid_url;
 
       // Strip the path beyond the top-level domain.
       *url = GURL(possibly_invalid_url).GetOrigin();
     } else {
-      *url = GURL(path.substr(parsed_index));
+      *url = GURL(raw_path.substr(parsed_index));
     }
   }
   return true;
 }
 
 void FaviconSource::OnFaviconDataAvailable(
     const IconRequest& request,
     const chrome::FaviconBitmapResult& bitmap_result) {
   if (bitmap_result.is_valid()) {
     // Forward the data along to the networking system.
@@ skipping 30 matching lines @@
 
   if (!default_favicon) {
     ui::ScaleFactor scale_factor = icon_request.scale_factor;
     default_favicon = ResourceBundle::GetSharedInstance()
         .LoadDataResourceBytesForScale(resource_id, scale_factor);
     default_favicons_[favicon_index] = default_favicon;
   }
 
   icon_request.callback.Run(default_favicon);
 }