Replace content's faviconURL with components/favicon's

chrome/browser/favicon/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 "chrome/browser/favicon/favicon_handler.h"
 
 #include "build/build_config.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted_memory.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/favicon/favicon_util.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_util.h"
 
-using content::FaviconURL;
+using favicon::FaviconURL;
 
 namespace {
 
 // Size (along each axis) of a touch icon. This currently corresponds to
 // the apple touch icon for iPad.
 const int kTouchIconSize = 144;
 
-// Returns favicon_base::IconType the given icon_type corresponds to.
-favicon_base::IconType ToChromeIconType(FaviconURL::IconType icon_type) {
-  switch (icon_type) {
-    case FaviconURL::FAVICON:
-      return favicon_base::FAVICON;
-    case FaviconURL::TOUCH_ICON:
-      return favicon_base::TOUCH_ICON;
-    case FaviconURL::TOUCH_PRECOMPOSED_ICON:
-      return favicon_base::TOUCH_PRECOMPOSED_ICON;
-    case FaviconURL::INVALID_ICON:
-      return favicon_base::INVALID_ICON;
-  }
-  NOTREACHED();
-  return favicon_base::INVALID_ICON;
-}
-
 // Get the maximal icon size in pixels for a icon of type |icon_type| for the
 // current platform.
 int GetMaximalIconSize(favicon_base::IconType icon_type) {
   switch (icon_type) {
     case favicon_base::FAVICON:
 #if defined(OS_ANDROID)
       return 192;
 #else
       return gfx::ImageSkia::GetMaxSupportedScale() * gfx::kFaviconSize;
 #endif
     case favicon_base::TOUCH_ICON:
     case favicon_base::TOUCH_PRECOMPOSED_ICON:
       return kTouchIconSize;
     case favicon_base::INVALID_ICON:
       return 0;
   }
   NOTREACHED();
   return 0;
 }
 
 bool DoUrlAndIconMatch(const FaviconURL& favicon_url,
                        const GURL& url,
                        favicon_base::IconType icon_type) {
-  return favicon_url.icon_url == url &&
-      ToChromeIconType(favicon_url.icon_type) == icon_type;
+  return favicon_url.icon_url == url && favicon_url.icon_type == icon_type;
 }
 
 // Returns true if all of the icon URLs and icon types in |bitmap_results| are
 // identical and if they match the icon URL and icon type in |favicon_url|.
 // Returns false if |bitmap_results| is empty.
 bool DoUrlsAndIconsMatch(
     const FaviconURL& favicon_url,
     const std::vector<favicon_base::FaviconBitmapResult>& bitmap_results) {
   if (bitmap_results.empty())
     return false;
 
-  const favicon_base::IconType icon_type =
-      ToChromeIconType(favicon_url.icon_type);
+  const favicon_base::IconType icon_type = favicon_url.icon_type;
 
   for (size_t i = 0; i < bitmap_results.size(); ++i) {
     if (favicon_url.icon_url != bitmap_results[i].icon_url ||
         icon_type != bitmap_results[i].icon_type) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 290 matching lines @@
 }
 
 void FaviconHandler::ProcessCurrentUrl() {
   DCHECK(!image_urls_.empty());
 
   // current_candidate() may return NULL if download_largest_icon_ is true and
   // all the sizes are larger than the max.
   if (PageChangedSinceFaviconWasRequested() || !current_candidate())
     return;
 
-  if (current_candidate()->icon_type == FaviconURL::FAVICON) {
+  if (current_candidate()->icon_type == favicon_base::FAVICON) {
     if (!favicon_expired_or_incomplete_ &&
         driver_->GetActiveFaviconValidity() &&
         DoUrlAndIconMatch(*current_candidate(),
                           driver_->GetActiveFaviconURL(),
                           favicon_base::FAVICON))
       return;
   } else if (!favicon_expired_or_incomplete_ && got_favicon_from_history_ &&
              HasValidResult(history_results_) &&
              DoUrlsAndIconsMatch(*current_candidate(), history_results_)) {
     return;
   }
 
   if (got_favicon_from_history_)
-    DownloadFaviconOrAskFaviconService(
-        driver_->GetActiveURL(),
-        current_candidate()->icon_url,
-        ToChromeIconType(current_candidate()->icon_type));
+    DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
+                                       current_candidate()->icon_url,
+                                       current_candidate()->icon_type);
 }
 
 void FaviconHandler::OnDidDownloadFavicon(
     int id,
     const GURL& image_url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   DownloadRequests::iterator i = download_requests_.find(id);
   if (i == download_requests_.end()) {
     // Currently WebContents notifies us of ANY downloads so that it is
@@ skipping 161 matching lines @@
       // TODO(pkotwicz): Do something better.
       favicon_expired_or_incomplete_ = true;
     }
   }
   if (has_results && !favicon_expired_or_incomplete_) {
     if (current_candidate() &&
         !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)) {
       // Mapping in the database is wrong. DownloadFavIconOrAskHistory will
       // update the mapping for this url and download the favicon if we don't
       // already have it.
-      DownloadFaviconOrAskFaviconService(
-          driver_->GetActiveURL(),
-          current_candidate()->icon_url,
-          ToChromeIconType(current_candidate()->icon_type));
+      DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
+                                         current_candidate()->icon_url,
+                                         current_candidate()->icon_type);
     }
   } else if (current_candidate()) {
     // 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,
-        ToChromeIconType(current_candidate()->icon_type));
+    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.
 }
 
 void FaviconHandler::DownloadFaviconOrAskFaviconService(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type) {
   if (favicon_expired_or_incomplete_) {
@@ skipping 44 matching lines @@
                        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,
-                     ToChromeIconType(current_candidate()->icon_type));
+                     current_candidate()->icon_type);
   }
   history_results_ = favicon_bitmap_results;
 }
 
 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.
   const int download_id = DownloadFavicon(image_url,
                                           GetMaximalIconSize(icon_type));
   if (download_id) {
     // Download ids should be unique.
     DCHECK(download_requests_.find(download_id) == download_requests_.end());
     download_requests_[download_id] =
         DownloadRequest(url, image_url, icon_type);
   }
 
   return download_id;
 }
 
 void FaviconHandler::SortAndPruneImageUrls() {
   for (std::vector<FaviconURL>::iterator i = image_urls_.begin();
        i != image_urls_.end();) {
     if (i->icon_sizes.empty()) {
       ++i;
       continue;
     }
-    int max_size = GetMaximalIconSize(ToChromeIconType(i->icon_type));
+    int max_size = GetMaximalIconSize(i->icon_type);
     int index = GetLargestSizeIndex(i->icon_sizes, max_size * max_size);
     if (index == -1) {
       i = image_urls_.erase(i);
     } else {
       gfx::Size largest = i->icon_sizes[index];
       i->icon_sizes.clear();
       i->icon_sizes.push_back(largest);
       ++i;
     }
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }