[Icon cacher] Add metrics for downloading favicons for NTP Tiles

components/ntp_tiles/icon_cacher_impl.cc

 // Copyright 2016 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/ntp_tiles/icon_cacher_impl.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/favicon/core/favicon_util.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
 #include "components/favicon_base/favicon_util.h"
 #include "components/image_fetcher/core/image_decoder.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 namespace ntp_tiles {
 
 namespace {
 
 constexpr int kDesiredFrameSize = 128;
 
 // TODO(jkrcal): Make the size in dip and the scale factor be passed as
 // arguments from the UI so that we desire for the right size on a given device.
 // See crbug.com/696563.
 constexpr int kTileIconMinSizePx = 48;
 constexpr int kTileIconDesiredSizePx = 96;
 
+// Enumeration listing all possible outcomes for fetch attempts of favicons for
+// NTP tiles. Used for UMA histograms, so do not change existing
+// values. Insert new values at the end, and update the histogram definition.
+enum class TileFaviconFetchResult { SUCCESS = 0, FAILURE = 1, COUNT = 2 };
+
+void RecordPopularSitesFaviconFetchResult(TileFaviconFetchResult result) {
+  UMA_HISTOGRAM_ENUMERATION("NewTabPage.TileFaviconFetched.popular", result,

[rkaplow, 2017/05/19 20:19:11]

instead of using an enum, can you use a boolean histogram?

You can also use a boolean as the enum type in the xml

[jkrcal, 2017/05/22 07:59:42]

Done.

+                            TileFaviconFetchResult::COUNT);
+}
+
+void RecordMostLikelyFaviconFetchResult(TileFaviconFetchResult result) {
+  UMA_HISTOGRAM_ENUMERATION("NewTabPage.TileFaviconFetched.server", result,
+                            TileFaviconFetchResult::COUNT);
+}
+
 favicon_base::IconType IconType(const PopularSites::Site& site) {
   return site.large_icon_url.is_valid() ? favicon_base::TOUCH_ICON
                                         : favicon_base::FAVICON;
 }
 
 const GURL& IconURL(const PopularSites::Site& site) {
   return site.large_icon_url.is_valid() ? site.large_icon_url
                                         : site.favicon_url;
 }
 
@@ skipping 63 matching lines @@
 }
 
 void IconCacherImpl::OnPopularSitesFaviconDownloaded(
     PopularSites::Site site,
     std::unique_ptr<CancelableImageCallback> preliminary_callback,
     const std::string& id,
     const gfx::Image& fetched_image,
     const image_fetcher::RequestMetadata& metadata) {
   if (fetched_image.IsEmpty()) {
     FinishRequestAndNotifyIconAvailable(site.url, /*newly_available=*/false);
+    RecordPopularSitesFaviconFetchResult(TileFaviconFetchResult::FAILURE);
     return;
   }
 
   // Avoid invoking callback about preliminary icon to be triggered. The best
   // possible icon has already been downloaded.
   if (preliminary_callback) {
     preliminary_callback->Cancel();
   }
   SaveIconForSite(site, fetched_image);
   FinishRequestAndNotifyIconAvailable(site.url, /*newly_available=*/true);
+  RecordPopularSitesFaviconFetchResult(TileFaviconFetchResult::SUCCESS);
 }
 
 void IconCacherImpl::SaveAndNotifyDefaultIconForSite(
     const PopularSites::Site& site,
     const base::Closure& preliminary_icon_available,
     const gfx::Image& image) {
   SaveIconForSite(site, image);
   if (preliminary_icon_available) {
     preliminary_icon_available.Run();
   }
@@ skipping 51 matching lines @@
   if (!HasResultDefaultBackgroundColor(result)) {
     // We should only fetch for default "gray" tiles so that we never overrite
     // any favicon of any size.
     FinishRequestAndNotifyIconAvailable(page_url, /*newly_available=*/false);
     return;
   }
 
   large_icon_service_
       ->GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
           page_url, kTileIconMinSizePx, kTileIconDesiredSizePx,
-          base::Bind(&IconCacherImpl::FinishRequestAndNotifyIconAvailable,
+          base::Bind(&IconCacherImpl::OnMostLikelyFaviconDownloaded,
                      weak_ptr_factory_.GetWeakPtr(), page_url));
 }
 
+void IconCacherImpl::OnMostLikelyFaviconDownloaded(const GURL& request_url,
+                                                   bool success) {
+  RecordMostLikelyFaviconFetchResult(success ? TileFaviconFetchResult::SUCCESS
+                                             : TileFaviconFetchResult::FAILURE);
+  FinishRequestAndNotifyIconAvailable(request_url, success);
+}
+
 bool IconCacherImpl::StartRequest(const GURL& request_url,
                                   const base::Closure& icon_available) {
   bool in_flight = in_flight_requests_.count(request_url) > 0;
   in_flight_requests_[request_url].push_back(icon_available);
   return !in_flight;
 }
 
 void IconCacherImpl::FinishRequestAndNotifyIconAvailable(
     const GURL& request_url,
     bool newly_available) {
   std::vector<base::Closure> callbacks =
       std::move(in_flight_requests_[request_url]);
   in_flight_requests_.erase(request_url);
   if (!newly_available) {
     return;
   }
   for (const base::Closure& callback : callbacks) {
     if (callback) {
       callback.Run();
     }
   }
 }
 
 }  // namespace ntp_tiles