Always select best favicon bitmap

components/favicon_base/select_favicon_frames.cc

 // Copyright 2014 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_base/select_favicon_frames.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 37 matching lines @@
 
   return bitmap;
 }
 
 size_t GetCandidateIndexWithBestScore(
     const std::vector<gfx::Size>& candidate_sizes,
     int desired_size,
     float* score) {
   DCHECK_NE(desired_size, 0);
 
-  // Try to find an exact match.
-  for (size_t i = 0; i < candidate_sizes.size(); ++i) {
-    if (candidate_sizes[i].width() == desired_size &&
-        candidate_sizes[i].height() == desired_size) {
-      *score = 1;
-      return i;
-    }
-  }
-
-  // Huge favicon bitmaps often have a completely different visual style from
-  // smaller favicon bitmaps. Avoid them.
-  const int kHugeEdgeSize = desired_size * 8;
-
-  // Order of preference:
-  // 1) Bitmaps with width and height smaller than |kHugeEdgeSize|.
-  // 2) Bitmaps which need to be scaled down instead of up.
-  // 3) Bitmaps which do not need to be scaled as much.
   size_t candidate_index = std::numeric_limits<size_t>::max();
   float candidate_score = 0;
-  for (size_t i = 0; i < candidate_sizes.size(); ++i) {
-    float average_edge =
-        (candidate_sizes[i].width() + candidate_sizes[i].height()) / 2.0f;
-
-    float score = 0;
-    if (candidate_sizes[i].width() >= kHugeEdgeSize ||
-        candidate_sizes[i].height() >= kHugeEdgeSize) {
-      score = std::min(1.0f, desired_size / average_edge) * 0.01f;
-    } else if (candidate_sizes[i].width() >= desired_size &&
-               candidate_sizes[i].height() >= desired_size) {
-      score = desired_size / average_edge * 0.01f + 0.15f;
-    } else {
-      score = std::min(1.0f, average_edge / desired_size) * 0.01f + 0.1f;
-    }
-
+  for (size_t i = 0; i < candidate_sizes.size() && candidate_score != 1.0f;
+       ++i) {
+    float score = GetFaviconCandidateScore(candidate_sizes[i], desired_size);
     if (candidate_index == std::numeric_limits<size_t>::max() ||
         score > candidate_score) {
       candidate_index = i;
       candidate_score = score;
     }
   }
   *score = candidate_score;
 
   return candidate_index;
 }
@@ skipping 148 matching lines @@
     image_source->AddImageSkiaRep(
         gfx::ImageSkiaRep(GetResizedBitmap(bitmaps[index],
                                            original_sizes[index],
                                            desired_sizes[i]),
                           favicon_scales[i]));
   }
   return gfx::ImageSkia(image_source,
                         gfx::Size(desired_size_in_dip, desired_size_in_dip));
 }
 
+gfx::ImageSkia CreateFaviconImageSkiaWithScaleFactors(
+    const std::vector<SkBitmap>& bitmaps,
+    const std::vector<gfx::Size>& original_sizes,
+    const std::vector<float>& desired_scale_factors,
+    int desired_size_in_dip) {
+  std::vector<int> desired_sizes;
+  std::vector<float> scale_factors = desired_scale_factors;
+
+  for (size_t i = 0; i < desired_scale_factors.size(); ++i) {
+    if (desired_scale_factors[i] == 0) {
+      desired_sizes.push_back(original_sizes[i].width());
+      scale_factors[i] = 1.0f * desired_sizes.back() / desired_size_in_dip;
+    } else {
+      desired_sizes.push_back(static_cast<int>(
+          ceil(desired_size_in_dip * desired_scale_factors[i])));
+    }
+  }
+
+  std::vector<SelectionResult> results;
+  // TODO(mastiz) / DONOTSUBMIT: Why is this actually needed? FaviconHandler
+  // should have selected the correct bitmaps.
+  GetCandidateIndicesWithBestScores(original_sizes, desired_sizes,
+                                    /*score=*/nullptr, &results);
+  if (results.size() == 0)
+    return gfx::ImageSkia();
+
+  FaviconImageSource* image_source = new FaviconImageSource;
+
+  for (size_t i = 0; i < results.size(); ++i) {
+    size_t index = results[i].index;
+    image_source->AddImageSkiaRep(gfx::ImageSkiaRep(
+        GetResizedBitmap(bitmaps[index], original_sizes[index],
+                         desired_sizes[i]),
+        scale_factors[i]));
+  }
+  return gfx::ImageSkia(image_source,
+                        gfx::Size(desired_size_in_dip, desired_size_in_dip));
+}
+
 void SelectFaviconFrameIndices(const std::vector<gfx::Size>& frame_pixel_sizes,
                                const std::vector<int>& desired_sizes,
                                std::vector<size_t>* best_indices,
                                float* match_score) {
   std::vector<SelectionResult> results;
   GetCandidateIndicesWithBestScores(
       frame_pixel_sizes, desired_sizes, 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);
     }
   }
 }
+
+float GetFaviconCandidateScore(const gfx::Size& candidate_size,
+                               int desired_size) {
+  // Huge favicon bitmaps often have a completely different visual style from
+  // smaller favicon bitmaps. Avoid them.
+  const int kHugeEdgeSize = desired_size * 8;
+
+  float average_edge =
+      (candidate_size.width() + candidate_size.height()) / 2.0f;
+  if (candidate_size.width() == desired_size &&
+      candidate_size.height() == desired_size) {
+    return 1.0f;
+  } else if (candidate_size.width() >= kHugeEdgeSize ||
+             candidate_size.height() >= kHugeEdgeSize) {
+    return std::min(1.0f, desired_size / average_edge) * 0.01f;
+  } else if (candidate_size.width() >= desired_size &&
+             candidate_size.height() >= desired_size) {
+    return desired_size / average_edge * 0.01f + 0.15f;
+  } else {
+    return std::min(1.0f, average_edge / desired_size) * 0.01f + 0.1f;
+  }
+}