Log the expected icon size when no suitable icon for a banner is found.

chrome/browser/manifest/manifest_icon_selector.cc

 // Copyright 2015 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/manifest/manifest_icon_selector.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/strings/utf_string_conversions.h"
 #include "components/mime_util/mime_util.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/gfx/screen.h"
 
 using content::Manifest;
 
 ManifestIconSelector::ManifestIconSelector(int ideal_icon_size_in_px,
                                            int minimum_icon_size_in_px)
     : ideal_icon_size_in_px_(ideal_icon_size_in_px),
-      minimum_icon_size_in_px_(minimum_icon_size_in_px) {
+      minimum_icon_size_in_px_(minimum_icon_size_in_px),
+      density_(
+          gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor()) {
 }
 
 bool ManifestIconSelector::IconSizesContainsPreferredSize(
     const std::vector<gfx::Size>& sizes) {
   for (size_t i = 0; i < sizes.size(); ++i) {
     if (sizes[i].height() != sizes[i].width())
       continue;
     if (sizes[i].width() == ideal_icon_size_in_px_)
       return true;
   }
@@ skipping 36 matching lines @@
         best_index = i;
         best_delta = delta;
       }
     }
   }
 
   return best_index;
 }
 
 int ManifestIconSelector::FindBestMatchingIcon(
-    const std::vector<content::Manifest::Icon>& icons,
-    float density) {
+    const std::vector<content::Manifest::Icon>& icons) {
   int best_index = -1;
 
   // The first pass is to find the ideal icon. That icon is of the right size
   // with the default density or the device's density.
   for (size_t i = 0; i < icons.size(); ++i) {
-    if (icons[i].density == density &&
+    if (icons[i].density == density_ &&
         IconSizesContainsPreferredSize(icons[i].sizes)) {
       return i;
     }
 
     // If there is an icon with the right size but not the right density, keep
     // it on the side and only use it if nothing better is found.
     if (icons[i].density == Manifest::Icon::kDefaultDensity &&
         IconSizesContainsPreferredSize(icons[i].sizes)) {
       best_index = i;
     }
   }
 
   if (best_index != -1)
     return best_index;
 
   // The second pass is to find an icon with 'any'. The current device scale
   // factor is preferred. Otherwise, the default scale factor is used.
   for (size_t i = 0; i < icons.size(); ++i) {
-    if (icons[i].density == density &&
+    if (icons[i].density == density_ &&
         IconSizesContainsAny(icons[i].sizes)) {
       return i;
     }
 
     // If there is an icon with 'any' but not the right density, keep it on the
     // side and only use it if nothing better is found.
     if (icons[i].density == Manifest::Icon::kDefaultDensity &&
         IconSizesContainsAny(icons[i].sizes)) {
       best_index = i;
     }
   }
 
   if (best_index != -1)
     return best_index;
 
   // The last pass will try to find the best suitable icon for the device's
   // scale factor. If none, another pass will be run using kDefaultDensity.
-  best_index = FindBestMatchingIconForDensity(icons, density);
+  best_index = FindBestMatchingIconForDensity(icons, density_);
   if (best_index != -1 &&
         IconSizesContainsBiggerThanMinimumSize(icons[best_index].sizes))
     return best_index;
 
   best_index = FindBestMatchingIconForDensity(icons,
       Manifest::Icon::kDefaultDensity);
   if (best_index != -1 &&
         IconSizesContainsBiggerThanMinimumSize(icons[best_index].sizes))
     return best_index;
 
@@ skipping 27 matching lines @@
   return result;
 }
 
 // static
 GURL ManifestIconSelector::FindBestMatchingIcon(
     const std::vector<Manifest::Icon>& unfiltered_icons,
     const int ideal_icon_size_in_dp,
     const int minimum_icon_size_in_dp) {
   DCHECK(minimum_icon_size_in_dp <= ideal_icon_size_in_dp);
 
-  const float device_scale_factor =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
   const int ideal_icon_size_in_px =
-      static_cast<int>(round(ideal_icon_size_in_dp * device_scale_factor));
+    ConvertIconSizeFromDpToPx(ideal_icon_size_in_dp);
   const int minimum_icon_size_in_px =
-      static_cast<int>(round(minimum_icon_size_in_dp * device_scale_factor));
+    ConvertIconSizeFromDpToPx(minimum_icon_size_in_dp);
 
   std::vector<Manifest::Icon> icons =
       ManifestIconSelector::FilterIconsByType(unfiltered_icons);
 
   ManifestIconSelector selector(ideal_icon_size_in_px,
                                 minimum_icon_size_in_px);
-  int index = selector.FindBestMatchingIcon(icons, device_scale_factor);
+  int index = selector.FindBestMatchingIcon(icons);
   if (index == -1)
     return GURL();
   return icons[index].src;
 }
+
+// static
+int ManifestIconSelector::ConvertIconSizeFromDpToPx(int icon_size_in_dp) {
+  return static_cast<int>(round(
+      icon_size_in_dp *
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor()));
+}