[Icons NTP] Enable Large Icon URL storage and image fetching (Touch Icons only), behind flag.

components/favicon/core/browser/favicon_handler.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 "components/favicon/core/browser/favicon_handler.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 184 matching lines @@
       image_url(image_url),
       image(image),
       score(score),
       icon_type(icon_type) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 FaviconHandler::FaviconHandler(FaviconService* service,
                                FaviconClient* client,
                                FaviconDriver* driver,
-                               Type icon_type,
+                               Type handler_type,
                                bool download_largest_icon)
     : got_favicon_from_history_(false),
       favicon_expired_or_incomplete_(false),
-      icon_types_(icon_type == FAVICON
-                      ? favicon_base::FAVICON
-                      : favicon_base::TOUCH_ICON |
-                            favicon_base::TOUCH_PRECOMPOSED_ICON),
+      handler_type_(handler_type),
+      icon_types_(FaviconHandler::GetIconTypesFromHandlerType(handler_type)),
       download_largest_icon_(download_largest_icon),
       service_(service),
       client_(client),
       driver_(driver) {
   DCHECK(driver_);
 }
 
 FaviconHandler::~FaviconHandler() {
 }
 
+// static
+int FaviconHandler::GetIconTypesFromHandlerType(
+    FaviconHandler::Type handler_type) {
+  switch (handler_type) {
+    case FAVICON:
+      return favicon_base::FAVICON;
+    case TOUCH:  // Falls through.
+    case LARGE:
+      return favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON;
+    default:
+      NOTREACHED();
+  }
+  return 0;
+}
+
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
   favicon_expired_or_incomplete_ = got_favicon_from_history_ = false;
   image_urls_.clear();
 
   // Request the favicon from the history service. In parallel to this the
   // renderer is going to notify us (well WebContents) when the favicon url is
@@ skipping 262 matching lines @@
   if (service_) {
     service_->GetFaviconForPageURL(page_url, icon_types, preferred_icon_size(),
                                    callback, tracker);
   }
 }
 
 void FaviconHandler::SetHistoryFavicons(const GURL& page_url,
                                         const GURL& icon_url,
                                         favicon_base::IconType icon_type,
                                         const gfx::Image& image) {
+  // TODO(huangs): Get the following to garbage collect if handler_type_ == ALL.
   if (service_) {
     service_->SetFavicons(page_url, icon_url, icon_type, image);
   }
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
   if (!driver_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
@@ skipping 23 matching lines @@
         favicon_bitmap_results) {
   if (PageChangedSinceFaviconWasRequested())
     return;
   got_favicon_from_history_ = true;
   history_results_ = favicon_bitmap_results;
   bool has_results = !favicon_bitmap_results.empty();
   favicon_expired_or_incomplete_ = has_results && HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
   bool has_valid_result = HasValidResult(favicon_bitmap_results);
 
-  if (has_results && icon_types_ == favicon_base::FAVICON &&
+  if (has_results && handler_type_ == FAVICON &&
       !download_largest_icon_ && !driver_->GetActiveFaviconValidity() &&
       (!current_candidate() ||
        DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
     if (has_valid_result) {
       // The db knows the favicon (although it may be out of date) and the entry
       // doesn't have an icon. Set the favicon now, and if the favicon turns out
       // to be expired (or the wrong url) we'll fetch later on. This way the
       // user doesn't see a flash of the default favicon.
       NotifyFaviconAvailable(favicon_bitmap_results, true);
     } else {
@@ skipping 17 matching lines @@
     // We know the official url for the favicon, but either don't have the
     // favicon or it's expired. Continue on to DownloadFaviconOrAskHistory to
     // either download or check history again.
     DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
                                        current_candidate()->icon_url,
                                        current_candidate()->icon_type);
   }
   // else we haven't got the icon url. When we get it we'll ask the
   // renderer to download the icon.
 
-  if (has_valid_result &&
-      (icon_types_ != favicon_base::FAVICON || download_largest_icon_))
+  if (has_valid_result && (handler_type_ != FAVICON || download_largest_icon_))
     NotifyFaviconAvailable(favicon_bitmap_results, false);
 }
 
 void FaviconHandler::DownloadFaviconOrAskFaviconService(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type) {
   if (favicon_expired_or_incomplete_) {
     // We have the mapping, but the favicon is out of date. Download it now.
     ScheduleDownload(page_url, icon_url, icon_type);
@@ skipping 23 matching lines @@
 void FaviconHandler::OnFaviconData(const std::vector<
     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
   if (PageChangedSinceFaviconWasRequested())
     return;
 
   bool has_results = !favicon_bitmap_results.empty();
   bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
   bool has_valid_result = HasValidResult(favicon_bitmap_results);
 
-  if (has_results && icon_types_ == favicon_base::FAVICON &&
-      !download_largest_icon_) {
+  if (has_results && handler_type_ == FAVICON && !download_largest_icon_) {
     if (has_valid_result) {
       // There is a favicon, set it now. If expired we'll download the current
       // one again, but at least the user will get some icon instead of the
       // default and most likely the current one is fine anyway.
       NotifyFaviconAvailable(favicon_bitmap_results, true);
     }
     if (has_expired_or_incomplete_result) {
       // The favicon is out of date. Request the current one.
       ScheduleDownload(driver_->GetActiveURL(),
                        driver_->GetActiveFaviconURL(),
                        favicon_base::FAVICON);
     }
   } else if (current_candidate() &&
       (!has_results || has_expired_or_incomplete_result ||
        !(DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)))) {
     // We don't know the favicon, it is out of date or its type is not same as
     // one got from page. Request the current one.
     ScheduleDownload(driver_->GetActiveURL(),
                      current_candidate()->icon_url,
                      current_candidate()->icon_type);
   }
   history_results_ = favicon_bitmap_results;
 
   if (has_valid_result &&
-      (icon_types_ != favicon_base::FAVICON || download_largest_icon_)) {
+      (handler_type_ != FAVICON || download_largest_icon_)) {
     NotifyFaviconAvailable(favicon_bitmap_results, false);
   }
 }
 
 int FaviconHandler::ScheduleDownload(const GURL& url,
                                      const GURL& image_url,
                                      favicon_base::IconType icon_type) {
   // A max bitmap size is specified to avoid receiving huge bitmaps in
   // OnDidDownloadFavicon(). See FaviconDriver::StartDownload()
   // for more details about the max bitmap size.
@@ skipping 16 matching lines @@
       continue;
 
     gfx::Size largest =
         image_url.icon_sizes[GetLargestSizeIndex(image_url.icon_sizes)];
     image_url.icon_sizes.clear();
     image_url.icon_sizes.push_back(largest);
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }