Moves SelectFaviconFrames from history to favicon_base component.

components/favicon_base/select_favicon_frames.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/history/select_favicon_frames.h"
+#include "components/favicon_base/select_favicon_frames.h"
 
+#include <limits>
 #include <set>
 
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 size_t BiggestCandidate(const std::vector<gfx::Size>& candidate_sizes) {
   size_t max_index = 0;
   int max_area = candidate_sizes[0].GetArea();
   for (size_t i = 1; i < candidate_sizes.size(); ++i) {
     int area = candidate_sizes[i].GetArea();
     if (area > max_area) {
       max_area = area;
       max_index = i;
     }
   }
   return max_index;
 }
 
 SkBitmap SampleNearestNeighbor(const SkBitmap& contents, int desired_size) {
   SkBitmap bitmap;
-  bitmap.setConfig(
-      SkBitmap::kARGB_8888_Config, desired_size, desired_size);
+  bitmap.setConfig(SkBitmap::kARGB_8888_Config, desired_size, desired_size);
   bitmap.allocPixels();
   if (!contents.isOpaque())
     bitmap.eraseARGB(0, 0, 0, 0);
 
   {
     SkCanvas canvas(bitmap);
     SkRect dest(SkRect::MakeWH(desired_size, desired_size));
     canvas.drawBitmapRect(contents, NULL, dest);
   }
 
   return bitmap;
 }
 
-enum ResizeMethod {
-NONE,
-SAMPLE_NEAREST_NEIGHBOUR,
-LANCZOS
-};
+enum ResizeMethod { NONE, SAMPLE_NEAREST_NEIGHBOUR, LANCZOS };
 
 size_t GetCandidateIndexWithBestScore(
     const std::vector<gfx::Size>& candidate_sizes_in_pixel,
     ui::ScaleFactor scale_factor,
     int desired_size_in_dip,
     float* score,
     ResizeMethod* resize_method) {
   DCHECK_NE(desired_size_in_dip, 0);
 
   float scale = ui::GetImageScale(scale_factor);
@@ skipping 12 matching lines @@
 
   // Huge favicon bitmaps often have a completely different visual style from
   // smaller favicon bitmaps. Avoid these favicon bitmaps when a favicon of
   // gfx::kFaviconSize DIP is requested.
   const int kHugeEdgeSizeInPixel = desired_size_in_pixel * 8;
 
   // Order of preference:
   // 1) Bitmaps with width and height smaller than |kHugeEdgeSizeInPixel|.
   // 2) Bitmaps which need to be scaled down instead of up.
   // 3) Bitmaps which do not need to be scaled as much.
-  int candidate_index = -1;
+  size_t candidate_index = std::numeric_limits<size_t>::max();
   float candidate_score = 0;
   for (size_t i = 0; i < candidate_sizes_in_pixel.size(); ++i) {
     float average_edge_in_pixel = (candidate_sizes_in_pixel[i].width() +
-        candidate_sizes_in_pixel[i].height()) / 2.0f;
+                                   candidate_sizes_in_pixel[i].height()) /
+                                  2.0f;
 
     float score = 0;
     if (candidate_sizes_in_pixel[i].width() >= kHugeEdgeSizeInPixel ||
         candidate_sizes_in_pixel[i].height() >= kHugeEdgeSizeInPixel) {
-      score = std::min(1.0f, desired_size_in_pixel / average_edge_in_pixel) *
-          0.01f;
+      score =
+          std::min(1.0f, desired_size_in_pixel / average_edge_in_pixel) * 0.01f;
     } else if (candidate_sizes_in_pixel[i].width() >= desired_size_in_pixel &&
                candidate_sizes_in_pixel[i].height() >= desired_size_in_pixel) {
       score = desired_size_in_pixel / average_edge_in_pixel * 0.01f + 0.15f;
     } else {
       score = std::min(1.0f, average_edge_in_pixel / desired_size_in_pixel) *
-          0.01f + 0.1f;
+                  0.01f +
+              0.1f;
     }
 
-    if (candidate_index == -1 || score > candidate_score) {
+    if (candidate_index == std::numeric_limits<size_t>::max() ||
+        score > candidate_score) {
       candidate_index = i;
       candidate_score = score;
     }
   }
   *score = candidate_score;
 
   // Integer multiples are built using nearest neighbor sampling. Otherwise,
   // Lanczos scaling is used.
   const gfx::Size& candidate_size_in_pixel =
       candidate_sizes_in_pixel[candidate_index];
@@ skipping 45 matching lines @@
       *match_score = 1.0f;
     return;
   }
 
   float total_score = 0;
   for (size_t i = 0; i < scale_factors.size(); ++i) {
     float score;
     SelectionResult result;
     result.scale_factor = scale_factors[i];
     result.index = GetCandidateIndexWithBestScore(candidate_sizes,
-        result.scale_factor, desired_size, &score, &result.resize_method);
+                                                  result.scale_factor,
+                                                  desired_size,
+                                                  &score,
+                                                  &result.resize_method);
     results->push_back(result);
     total_score += score;
   }
 
   if (match_score)
     *match_score = total_score / scale_factors.size();
 }
 
 // Resize |source_bitmap| using |resize_method|.
 SkBitmap GetResizedBitmap(const SkBitmap& source_bitmap,
                           int desired_size_in_dip,
                           ui::ScaleFactor scale_factor,
                           ResizeMethod resize_method) {
   float scale = ui::GetImageScale(scale_factor);
-  int desired_size_in_pixel = static_cast<int>(
-      desired_size_in_dip * scale + 0.5f);
+  int desired_size_in_pixel =
+      static_cast<int>(desired_size_in_dip * scale + 0.5f);
 
   switch (resize_method) {
     case NONE:
       return source_bitmap;
     case SAMPLE_NEAREST_NEIGHBOUR:
       return SampleNearestNeighbor(source_bitmap, desired_size_in_pixel);
     case LANCZOS:
       return skia::ImageOperations::Resize(
-          source_bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
-          desired_size_in_pixel, desired_size_in_pixel);
+          source_bitmap,
+          skia::ImageOperations::RESIZE_LANCZOS3,
+          desired_size_in_pixel,
+          desired_size_in_pixel);
   }
   return source_bitmap;
 }
 
 }  // namespace
 
 const float kSelectFaviconFramesInvalidScore = -1.0f;
 
 gfx::ImageSkia SelectFaviconFrames(
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_sizes,
     const std::vector<ui::ScaleFactor>& scale_factors,
     int desired_size,
     float* match_score) {
   std::vector<SelectionResult> results;
-  GetCandidateIndicesWithBestScores(original_sizes, scale_factors,
-      desired_size, match_score, &results);
+  GetCandidateIndicesWithBestScores(
+      original_sizes, scale_factors, desired_size, match_score, &results);
 
   gfx::ImageSkia multi_image;
   for (size_t i = 0; i < results.size(); ++i) {
     const SelectionResult& result = results[i];
     SkBitmap resized_bitmap = GetResizedBitmap(bitmaps[result.index],
-        desired_size, result.scale_factor, result.resize_method);
-    multi_image.AddRepresentation(
-        gfx::ImageSkiaRep(resized_bitmap,
-                          ui::GetImageScale(result.scale_factor)));
+                                               desired_size,
+                                               result.scale_factor,
+                                               result.resize_method);
+    multi_image.AddRepresentation(gfx::ImageSkiaRep(
+        resized_bitmap, ui::GetImageScale(result.scale_factor)));
   }
   return multi_image;
 }
 
 void SelectFaviconFrameIndices(
     const std::vector<gfx::Size>& frame_pixel_sizes,
     const std::vector<ui::ScaleFactor>& scale_factors,
     int desired_size,
     std::vector<size_t>* best_indices,
     float* match_score) {
   std::vector<SelectionResult> results;
-  GetCandidateIndicesWithBestScores(frame_pixel_sizes, scale_factors,
-      desired_size, match_score, &results);
+  GetCandidateIndicesWithBestScores(
+      frame_pixel_sizes, scale_factors, desired_size, match_score, &results);
 
   std::set<size_t> already_added;
   for (size_t i = 0; i < results.size(); ++i) {
     size_t index = results[i].index;
     // GetCandidateIndicesWithBestScores() will return duplicate indices if the
     // bitmap data with |frame_pixel_sizes[index]| should be used for multiple
     // scale factors. Remove duplicates here such that |best_indices| contains
     // no duplicates.
     if (already_added.find(index) == already_added.end()) {
       already_added.insert(index);
       best_indices->push_back(index);
     }
   }
 }