Adds support for saving favicon size into history database.

chrome/browser/history/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 "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 {
 
+// Return gfx::Size vector with the pixel sizes of |bitmaps|.
 void SizesFromBitmaps(const std::vector<SkBitmap>& bitmaps,
                       std::vector<gfx::Size>* sizes) {
   for (size_t i = 0; i < bitmaps.size(); ++i)
     sizes->push_back(gfx::Size(bitmaps[i].width(), bitmaps[i].height()));
 }
 
+// Return gfx::Size vector with the pixel sizes of |bitmap_id_sizes|.
+void SizesFromFaviconBitmapIDSizes(
+    const std::vector<history::FaviconBitmapIDSize>& bitmap_id_sizes,
+    std::vector<gfx::Size>* sizes) {
+  for (size_t i = 0; i < bitmap_id_sizes.size(); ++i)
+    sizes->push_back(bitmap_id_sizes[i].pixel_size);
+}
+
 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;
     }
   }
@@ skipping 101 matching lines @@
     }
   }
   *score = 0.1f;
   //    c) Else, from the biggest smaller variant.
   if (candidate_index == -1) {
     *score = 0;
     candidate_index = BiggestCandidate(candidate_sizes);
   }
 
   const gfx::Size& candidate_size = candidate_sizes[candidate_index];
-  bool is_integer_multiple = desired_size % candidate_size.width() == 0 &&
-                             desired_size % candidate_size.height() == 0;
-  *resize_method = is_integer_multiple ? SAMPLE_NEAREST_NEIGHBOUR : LANCZOS;
+  if (candidate_size.IsEmpty()) {
+    *resize_method = NONE;
+  } else if (desired_size % candidate_size.width() == 0 &&
+             desired_size % candidate_size.height() == 0) {
+    *resize_method = SAMPLE_NEAREST_NEIGHBOUR;
+  } else {
+    *resize_method = LANCZOS;
+  }
   return candidate_index;
 }
 
 // Represents the index of the best candidate for a |scale_factor| from the
 // |candidate_sizes| passed into GetCandidateIndicesWithBestScores().
 struct SelectionResult {
   // index in |candidate_sizes| of the best candidate.
   size_t index;
 
   // The ScaleFactor for which |index| is the best candidate.
   ui::ScaleFactor scale_factor;
 
   // How the bitmap data that the bitmap with |candidate_sizes[index]| should
   // be resized for displaying in the UI.
   ResizeMethod resize_method;
 };
 
 void GetCandidateIndicesWithBestScores(
     const std::vector<gfx::Size>& candidate_sizes,
     const std::vector<ui::ScaleFactor>& scale_factors,
     int desired_size,
     float* match_score,
     std::vector<SelectionResult>* results) {
-  if (candidate_sizes.empty())
+  if (candidate_sizes.empty()) {
+    *match_score = 0.0f;
     return;
+  }
 
   if (desired_size == 0) {
     // Just return the biggest image available.
     SelectionResult result;
     result.index = BiggestCandidate(candidate_sizes);
     result.scale_factor = ui::SCALE_FACTOR_100P;
     result.resize_method = NONE;
     results->push_back(result);
     if (match_score)
       *match_score = 0.8f;
@@ skipping 37 matching lines @@
     case LANCZOS:
       return skia::ImageOperations::Resize(
           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<ui::ScaleFactor>& scale_factors,
     int desired_size,
     float* match_score) {
   std::vector<gfx::Size> candidate_sizes;
   SizesFromBitmaps(bitmaps, &candidate_sizes);
 
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(candidate_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, result.scale_factor));
   }
   return multi_image;
 }
+
+void SelectFaviconBitmapIDs(
+    const std::vector<history::FaviconBitmapIDSize>& bitmap_id_sizes,
+    const std::vector<ui::ScaleFactor>& scale_factors,
+    int desired_size,
+    std::vector<history::FaviconBitmapID>* filtered_favicon_bitmap_ids,
+    float* match_score) {
+  std::vector<gfx::Size> candidate_sizes;
+  SizesFromFaviconBitmapIDSizes(bitmap_id_sizes, &candidate_sizes);
+
+  std::vector<SelectionResult> results;
+  GetCandidateIndicesWithBestScores(candidate_sizes, scale_factors,
+      desired_size, match_score, &results);
+
+  std::set<history::FaviconBitmapID> already_added;
+  for (size_t i = 0; i < results.size(); ++i) {
+    const SelectionResult& result = results[i];
+    history::FaviconBitmapID bitmap_id =
+        bitmap_id_sizes[result.index].bitmap_id;
+
+    // GetCandidateIndicesWithBestScores() will return duplicate indices if the
+    // bitmap data for a |bitmap_id| should be used for multiple scale factors.
+    // Remove duplicates here such that |filtered_favicon_bitmap_ids| contains
+    // no duplicates.
+    if (already_added.find(bitmap_id) == already_added.end()) {
+      already_added.insert(bitmap_id);
+      filtered_favicon_bitmap_ids->push_back(bitmap_id);
+    }
+  }
+}