Add DownloadStatus metric to FaviconHandler

components/favicon/core/favicon_handler_unittest.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 "components/favicon/core/favicon_handler.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/histogram_tester.h"
 #include "components/favicon/core/favicon_driver.h"
 #include "components/favicon/core/test/mock_favicon_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 
 namespace favicon {
 namespace {
 
 using favicon_base::FAVICON;
 using favicon_base::FaviconRawBitmapResult;
 using favicon_base::TOUCH_ICON;
 using favicon_base::TOUCH_PRECOMPOSED_ICON;
 using testing::Assign;
 using testing::ElementsAre;
 using testing::InSequence;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Return;
 using testing::_;
 
+using DownloadOutcome = FaviconHandler::DownloadOutcome;
 using IntVector = std::vector<int>;
 using URLVector = std::vector<GURL>;
 using BitmapVector = std::vector<SkBitmap>;
 using SizeVector = std::vector<gfx::Size>;
 
 MATCHER_P2(ImageSizeIs, width, height, "") {
   *result_listener << "where size is " << arg.Width() << "x" << arg.Height();
   return arg.Size() == gfx::Size(width, height);
 }
 
@@ skipping 17 matching lines @@
 std::vector<unsigned char> FillBitmapWithEdgeSize(int size) {
   SkBitmap bitmap = CreateBitmapWithEdgeSize(size);
   std::vector<unsigned char> output;
   gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &output);
   return output;
 }
 
 std::vector<FaviconRawBitmapResult> CreateRawBitmapResult(
     const GURL& icon_url,
     favicon_base::IconType icon_type = FAVICON,
-    bool expired = false) {
+    bool expired = false,
+    int edge_size = gfx::kFaviconSize) {
   scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes());
-  data->data() = FillBitmapWithEdgeSize(gfx::kFaviconSize);
+  data->data() = FillBitmapWithEdgeSize(edge_size);
   FaviconRawBitmapResult bitmap_result;
   bitmap_result.expired = expired;
   bitmap_result.bitmap_data = data;
   // Use a pixel size other than (0,0) as (0,0) has a special meaning.
-  bitmap_result.pixel_size = gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize);
+  bitmap_result.pixel_size = gfx::Size(edge_size, edge_size);
   bitmap_result.icon_type = icon_type;
   bitmap_result.icon_url = icon_url;
   return {bitmap_result};
 }
 
-// Fake that implements the calls to FaviconHalder::Delegate's DownloadImage(),
+// Fake that implements the calls to FaviconHandler::Delegate's DownloadImage(),
 // delegated to this class through MockDelegate.
 class FakeImageDownloader {
  public:
   struct Response {
     int http_status_code = 404;
     BitmapVector bitmaps;
     SizeVector original_bitmap_sizes;
   };
 
   FakeImageDownloader() : next_download_id_(1) {}
@@ skipping 270 matching lines @@
   }
 
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<ui::test::ScopedSetSupportedScaleFactors>
       scoped_set_supported_scale_factors_;
   testing::NiceMock<MockFaviconServiceWithFake> favicon_service_;
   testing::NiceMock<MockDelegate> delegate_;
 };
 
 TEST_F(FaviconHandlerTest, GetFaviconFromHistory) {
+  base::HistogramTester histogram_tester;
   const GURL kIconURL("http://www.google.com/favicon");
 
   favicon_service_.fake()->Store(kPageURL, kIconURL,
                                  CreateRawBitmapResult(kIconURL));
 
   EXPECT_CALL(delegate_, OnFaviconUpdated(
                              kPageURL, FaviconDriverObserver::NON_TOUCH_16_DIP,
                              kIconURL, /*icon_url_changed=*/true, _));
 
   RunHandlerWithSimpleFaviconCandidates({kIconURL});
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      IsEmpty());
 }
 
 // Test that UpdateFaviconsAndFetch() is called with the appropriate parameters
 // when there is data in the database for neither the page URL nor the icon URL.
 TEST_F(FaviconHandlerTest, UpdateFaviconMappingsAndFetch) {
   EXPECT_CALL(favicon_service_, UpdateFaviconMappingsAndFetch(
                                     kPageURL, URLVector{kIconURL16x16}, FAVICON,
                                     /*desired_size_in_dip=*/16, _, _));
 
   RunHandlerWithSimpleFaviconCandidates({kIconURL16x16});
@@ skipping 122 matching lines @@
 
   RunHandlerWithSimpleFaviconCandidates({kNewIconURL});
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kNewIconURL));
 }
 
 // If there is data for the page URL in history which is invalid, test that:
 // - The invalid data is not sent to the UI.
 // - The icon is redownloaded.
 TEST_F(FaviconHandlerTest, FaviconInHistoryInvalid) {
   // Set non empty but invalid data.
-  FaviconRawBitmapResult bitmap_result;
-  bitmap_result.expired = false;
+  std::vector<FaviconRawBitmapResult> bitmap_result =
+      CreateRawBitmapResult(kIconURL16x16);
   // Empty bitmap data is invalid.
-  bitmap_result.bitmap_data = new base::RefCountedBytes();
-  bitmap_result.pixel_size = gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize);
-  bitmap_result.icon_type = FAVICON;
-  bitmap_result.icon_url = kIconURL16x16;
+  bitmap_result[0].bitmap_data = new base::RefCountedBytes();
 
-  favicon_service_.fake()->Store(kPageURL, kIconURL16x16, {bitmap_result});
+  favicon_service_.fake()->Store(kPageURL, kIconURL16x16, bitmap_result);
 
   // TODO(crbug.com/700811): It would be nice if we could check the image
   // being published to rule out invalid data.
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL16x16, _, _));
 
   RunHandlerWithSimpleFaviconCandidates({kIconURL16x16});
 
   EXPECT_THAT(favicon_service_.fake()->db_requests(), ElementsAre(kPageURL));
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL16x16));
 }
@@ skipping 467 matching lines @@
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, _, kIconURL12x12, _, ImageSizeIs(12, 12)));
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_LARGEST,
       {FaviconURL(kIconURL10x10, FAVICON, SizeVector{gfx::Size(16, 16)}),
        FaviconURL(kIconURL12x12, FAVICON, SizeVector{gfx::Size(15, 15)}),
        FaviconURL(kIconURL16x16, FAVICON, kEmptySizes)});
 }
 
+TEST_F(FaviconHandlerTest, TestRecordMultipleDownloadAttempts) {
+  base::HistogramTester histogram_tester;
+
+  // Try to download the three failing icons and end up logging three attempts.
+  RunHandlerWithCandidates(
+      FaviconDriverObserver::NON_TOUCH_LARGEST,
+      {FaviconURL(GURL("http://www.google.com/a"), FAVICON, kEmptySizes),
+       FaviconURL(GURL("http://www.google.com/b"), FAVICON, kEmptySizes),
+       FaviconURL(GURL("http://www.google.com/c"), FAVICON, kEmptySizes)});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      ElementsAre(base::Bucket(/*sample=*/3, /*expected_count=*/1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.TouchIcons"),
+      IsEmpty());
+}
+
+TEST_F(FaviconHandlerTest, TestRecordSingleFaviconDownloadAttempt) {
+  base::HistogramTester histogram_tester;
+
+  RunHandlerWithSimpleFaviconCandidates({kIconURL16x16});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.TouchIcons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
+      ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::SUCCEEDED),
+                               /*expected_count=*/1)));
+}
+
+TEST_F(FaviconHandlerTest, TestRecordSingleLargeIconDownloadAttempt) {
+  base::HistogramTester histogram_tester;
+
+  RunHandlerWithCandidates(FaviconDriverObserver::NON_TOUCH_LARGEST,
+                           {FaviconURL(kIconURL64x64, FAVICON, kEmptySizes)});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.TouchIcons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
+      ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::SUCCEEDED),
+                               /*expected_count=*/1)));
+}
+
+TEST_F(FaviconHandlerTest, TestRecordSingleTouchIconDownloadAttempt) {
+  base::HistogramTester histogram_tester;
+  RunHandlerWithCandidates(
+      FaviconDriverObserver::TOUCH_LARGEST,
+      {FaviconURL(kIconURL64x64, TOUCH_ICON, kEmptySizes)});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.TouchIcons"),
+      ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
+      ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::SUCCEEDED),
+                               /*expected_count=*/1)));
+}
+
+TEST_F(FaviconHandlerTest, TestRecordDownloadAttemptsFinishedByCache) {
+  const GURL kIconURL1024x1024("http://www.google.com/a-404-ing-icon");
+  base::HistogramTester histogram_tester;
+  favicon_service_.fake()->Store(
+      GURL("http://so.de"), kIconURL64x64,
+      CreateRawBitmapResult(kIconURL64x64, FAVICON, /*expired=*/false, 64));
+
+  RunHandlerWithCandidates(
+      FaviconDriverObserver::NON_TOUCH_LARGEST,
+      {FaviconURL(kIconURL1024x1024, FAVICON, {gfx::Size(1024, 1024)}),
+       FaviconURL(kIconURL12x12, FAVICON, {gfx::Size(12, 12)}),
+       FaviconURL(kIconURL64x64, FAVICON, {gfx::Size(64, 64)})});
+
+  // Should try only the first (receive 404) and get second icon from cache.
+  EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL1024x1024));
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.LargeIcons"),
+      ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      IsEmpty());
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.TouchIcons"),
+      IsEmpty());
+}
+
+TEST_F(FaviconHandlerTest, TestRecordSingleDownloadAttemptForRefreshingIcons) {
+  base::HistogramTester histogram_tester;
+  favicon_service_.fake()->Store(
+      kPageURL, kIconURL16x16,
+      CreateRawBitmapResult(kIconURL16x16, FAVICON, /*expired=*/true));
+
+  RunHandlerWithSimpleFaviconCandidates({kIconURL16x16});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
+      ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
+}
+
+TEST_F(FaviconHandlerTest, TestRecordFailingDownloadAttempt) {
+  base::HistogramTester histogram_tester;
+  const GURL k404IconURL("http://www.google.com/404.png");
+
+  delegate_.fake_downloader().AddError(k404IconURL, 404);
+
+  EXPECT_CALL(favicon_service_, UnableToDownloadFavicon(k404IconURL));
+
+  RunHandlerWithSimpleFaviconCandidates({k404IconURL});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
+      ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::FAILED),
+                               /*expected_count=*/1)));
+}
+
+TEST_F(FaviconHandlerTest, TestRecordSkippedDownloadForKnownFailingUrl) {
+  base::HistogramTester histogram_tester;
+  const GURL k404IconURL("http://www.google.com/404.png");
+
+  ON_CALL(favicon_service_, WasUnableToDownloadFavicon(k404IconURL))
+      .WillByDefault(Return(true));
+
+  RunHandlerWithSimpleFaviconCandidates({k404IconURL});
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
+      ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::SKIPPED),
+                               /*expected_count=*/1)));
+}
+
 }  // namespace
 }  // namespace favicon