Ensure that favicons always have 1x representation regardless of whether the platform supports it

chrome/browser/favicon/favicon_service.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_service.h"
 
 #include "chrome/browser/favicon/favicon_util.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_service_factory.h"
@@ skipping 57 matching lines @@
   } else {
     ForwardEmptyResultAsync(request);
   }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::GetFavicon(
     const GURL& icon_url,
     history::IconType icon_type,
     int desired_size_in_dip,
-    const std::vector<ui::ScaleFactor>& desired_scale_factors,
     CancelableRequestConsumerBase* consumer,
     const FaviconResultsCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(callback);
   AddRequest(request, consumer);
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     history_service_->GetFavicons(request, icon_urls, icon_type,
-        desired_size_in_dip, desired_scale_factors);
+        desired_size_in_dip, FaviconUtil::GetFaviconScaleFactors());
   } else {
     ForwardEmptyResultAsync(request);
   }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
-    const std::vector<ui::ScaleFactor>& desired_scale_factors,
     CancelableRequestConsumerBase* consumer,
     const FaviconResultsCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(callback);
   AddRequest(request, consumer);
   if (history_service_) {
     history_service_->UpdateFaviconMappingsAndFetch(request, page_url,
-        icon_urls, icon_types, desired_size_in_dip, desired_scale_factors);
+        icon_urls, icon_types, desired_size_in_dip,
+        FaviconUtil::GetFaviconScaleFactors());
   } else {
     ForwardEmptyResultAsync(request);
   }
   return request->handle();
 }
 
 FaviconService::Handle FaviconService::GetFaviconImageForURL(
     const FaviconForURLParams& params,
     const FaviconImageCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(base::Bind(
       &FaviconService::GetFaviconImageCallback,
       base::Unretained(this),
       params.desired_size_in_dip,
       callback));
 
-  std::vector<ui::ScaleFactor> desired_scale_factors =
-      ui::GetSupportedScaleFactors();
-  return GetFaviconForURLImpl(params, desired_scale_factors, request);
+  return GetFaviconForURLImpl(params,
+                              FaviconUtil::GetFaviconScaleFactors(),
+                              request);
 }
 
 FaviconService::Handle FaviconService::GetRawFaviconForURL(
     const FaviconForURLParams& params,
     ui::ScaleFactor desired_scale_factor,
     const FaviconRawCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(base::Bind(
       &FaviconService::GetRawFaviconCallback,
       base::Unretained(this),
       params.desired_size_in_dip,
       desired_scale_factor,
       callback));
 
   std::vector<ui::ScaleFactor> desired_scale_factors;
   desired_scale_factors.push_back(desired_scale_factor);
   return GetFaviconForURLImpl(params, desired_scale_factors, request);
 }
 
 FaviconService::Handle FaviconService::GetFaviconForURL(
     const FaviconForURLParams& params,
-    const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconResultsCallback& callback) {
   GetFaviconRequest* request = new GetFaviconRequest(callback);
-  return GetFaviconForURLImpl(params, desired_scale_factors, request);
+  return GetFaviconForURLImpl(params,
+                              FaviconUtil::GetFaviconScaleFactors(),
+                              request);
 }
 
 FaviconService::Handle FaviconService::GetLargestRawFaviconForID(
       history::FaviconID favicon_id,
       CancelableRequestConsumerBase* consumer,
       const FaviconRawCallback& callback) {
    // Use 0 as |desired_size_in_dip| to get the largest bitmap for |favicon_id|
    // without any resizing.
    int desired_size_in_dip = 0;
    ui::ScaleFactor desired_scale_factor = ui::SCALE_FACTOR_100P;
@@ skipping 116 matching lines @@
 
 void FaviconService::GetFaviconImageCallback(
     int desired_size_in_dip,
     FaviconImageCallback callback,
     Handle handle,
     std::vector<history::FaviconBitmapResult> favicon_bitmap_results,
     history::IconURLSizesMap icon_url_sizes_map) {
   history::FaviconImageResult image_result;
   image_result.image = FaviconUtil::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
-      ui::GetSupportedScaleFactors(),
+      FaviconUtil::GetFaviconScaleFactors(),
       desired_size_in_dip);
   image_result.icon_url = image_result.image.IsEmpty() ?
       GURL() : favicon_bitmap_results[0].icon_url;
   callback.Run(handle, image_result);
 }
 
 void FaviconService::GetRawFaviconCallback(
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
     FaviconRawCallback callback,
@@ skipping 22 matching lines @@
       desired_size_in_dip * desired_scale + 0.5f);
   gfx::Size desired_size_in_pixel(desired_edge_width_in_pixel,
                                   desired_edge_width_in_pixel);
   if (bitmap_result.pixel_size == desired_size_in_pixel) {
     callback.Run(handle, bitmap_result);
     return;
   }
 
   // Convert raw bytes to SkBitmap, resize via SelectFaviconFrames(), then
   // convert back.
-  SkBitmap bitmap;
-  if (!gfx::PNGCodec::Decode(bitmap_result.bitmap_data->front(),
-                             bitmap_result.bitmap_data->size(),
-                             &bitmap)) {
-    callback.Run(handle, history::FaviconBitmapResult());
-    return;
-  }
-
-  std::vector<SkBitmap> bitmaps;
-  bitmaps.push_back(bitmap);
   std::vector<ui::ScaleFactor> desired_scale_factors;
   desired_scale_factors.push_back(desired_scale_factor);
-  gfx::ImageSkia resized_image = SelectFaviconFrames(bitmaps,
-      desired_scale_factors, desired_size_in_dip, NULL);
+  gfx::Image resized_image = FaviconUtil::SelectFaviconFramesFromPNGs(
+      favicon_bitmap_results, desired_scale_factors, desired_size_in_dip);
 
   std::vector<unsigned char> resized_bitmap_data;
-  if (!gfx::PNGCodec::EncodeBGRASkBitmap(*resized_image.bitmap(), false,
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false,
                                          &resized_bitmap_data)) {
     callback.Run(handle, history::FaviconBitmapResult());
     return;
   }
 
   bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector(
       &resized_bitmap_data);
   callback.Run(handle, bitmap_result);
 }
 
 void FaviconService::ForwardEmptyResultAsync(GetFaviconRequest* request) {
   request->ForwardResultAsync(request->handle(),
                               std::vector<history::FaviconBitmapResult>(),
                               history::IconURLSizesMap());
 }