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

components/ntp_tiles/icon_cacher_impl_unittest.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 <set>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/mock_callback.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/favicon/core/favicon_client.h"
 #include "components/favicon/core/favicon_service_impl.h"
 #include "components/favicon/core/favicon_util.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/image_fetcher/core/image_decoder.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "components/image_fetcher/core/request_metadata.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/gfx/image/image_unittest_util.h"
 
+using base::Bucket;
 using ::testing::_;
+using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::Invoke;
 using ::testing::InSequence;
+using ::testing::IsEmpty;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::ReturnArg;
 
 namespace ntp_tiles {
 namespace {
 
 class MockImageFetcher : public image_fetcher::ImageFetcher {
  public:
   MOCK_METHOD1(SetImageFetcherDelegate,
@@ skipping 176 matching lines @@
         ui::SCALE_FACTOR_NONE);
   }
 
   PopularSites::Site site_;
   std::unique_ptr<MockImageFetcher> image_fetcher_;
   std::unique_ptr<MockImageDecoder> image_decoder_;
   NiceMock<MockResourceDelegate> mock_resource_delegate_;
 };
 
 TEST_F(IconCacherTestPopularSites, LargeCached) {
+  base::HistogramTester histogram_tester;
   base::MockCallback<base::Closure> done;
   EXPECT_CALL(done, Run()).Times(0);
   base::RunLoop loop;
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::NTP_TILES));
     EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128)));
   }
   PreloadIcon(site_.url, site_.large_icon_url, favicon_base::TOUCH_ICON, 128,
               128);
   IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_));
   cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   WaitForMainThreadTasksToFinish();
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.popular"),
+      IsEmpty());
 }
 
 TEST_F(IconCacherTestPopularSites, LargeNotCachedAndFetchSucceeded) {
+  base::HistogramTester histogram_tester;
   base::MockCallback<base::Closure> done;
   base::RunLoop loop;
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::NTP_TILES));
     EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128)));
     EXPECT_CALL(*image_fetcher_,
                 StartOrQueueNetworkRequest(_, site_.large_icon_url, _))
         .WillOnce(PassFetch(128, 128));
     EXPECT_CALL(done, Run()).WillOnce(Quit(&loop));
   }
 
   IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_));
   cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   loop.Run();
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.popular"),
+      ElementsAre(Bucket(/*bucket=*/0, /*count=*/1)));  // bucket 0 = SUCCESS.
 }
 
 TEST_F(IconCacherTestPopularSites, SmallNotCachedAndFetchSucceeded) {
   site_.large_icon_url = GURL();
 
   base::MockCallback<base::Closure> done;
   base::RunLoop loop;
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::NTP_TILES));
     EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128)));
     EXPECT_CALL(*image_fetcher_,
                 StartOrQueueNetworkRequest(_, site_.favicon_url, _))
         .WillOnce(PassFetch(128, 128));
     EXPECT_CALL(done, Run()).WillOnce(Quit(&loop));
   }
 
   IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_));
   cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   loop.Run();
   EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
 }
 
 TEST_F(IconCacherTestPopularSites, LargeNotCachedAndFetchFailed) {
+  base::HistogramTester histogram_tester;
   base::MockCallback<base::Closure> done;
   EXPECT_CALL(done, Run()).Times(0);
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::NTP_TILES));
     EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128)));
     EXPECT_CALL(*image_fetcher_,
                 StartOrQueueNetworkRequest(_, site_.large_icon_url, _))
         .WillOnce(FailFetch());
   }
 
   IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_));
   cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   WaitForMainThreadTasksToFinish();
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.popular"),
+      ElementsAre(Bucket(/*bucket=*/1, /*count=*/1)));  // bucket 1 = FAILURE.
 }
 
 TEST_F(IconCacherTestPopularSites, HandlesEmptyCallbacksNicely) {
+  base::HistogramTester histogram_tester;
   EXPECT_CALL(*image_fetcher_, SetDataUseServiceName(_));
   EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(_));
   EXPECT_CALL(*image_fetcher_, StartOrQueueNetworkRequest(_, _, _))
       .WillOnce(PassFetch(128, 128));
   IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_));
   cacher.StartFetchPopularSites(site_, base::Closure(), base::Closure());
   WaitForHistoryThreadTasksToFinish();  // Writing the icon into the DB.
   WaitForMainThreadTasksToFinish();     // Finishing tasks after the DB write.
   // Even though the callbacks are not called, the icon gets written out.
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+  // The histogram gets reported despite empty callbacks.
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.popular"),
+      ElementsAre(Bucket(/*bucket=*/0, /*count=*/1)));  // bucket 0 = SUCCESS.
 }
 
 TEST_F(IconCacherTestPopularSites, ProvidesDefaultIconAndSucceedsWithFetching) {
+  base::HistogramTester histogram_tester;
   // The returned data string is not used by the mocked decoder.
   ON_CALL(mock_resource_delegate_, GetRawDataResource(12345, _, _))
       .WillByDefault(Return(""));
   // It's not important when the image_fetcher's decoder is used to decode the
   // image but it must happen at some point.
   EXPECT_CALL(*image_fetcher_, GetImageDecoder())
       .WillOnce(Return(image_decoder_.get()));
   EXPECT_CALL(*image_decoder_, DecodeImage(_, gfx::Size(128, 128), _))
       .WillOnce(DecodeSuccessfully(64, 64));
   base::MockCallback<base::Closure> preliminary_icon_available;
@@ skipping 23 matching lines @@
                                 preliminary_icon_available.Get());
 
   default_loop.Run();  // Wait for the default image.
   EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(),
               Eq(gfx::Size(64, 64)));  // Compares dimensions, not objects.
 
   // Let the fetcher continue and wait for the second call of the callback.
   fetch_loop.Run();  // Wait for the updated image.
   EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(),
               Eq(gfx::Size(128, 128)));  // Compares dimensions, not objects.
+  // The histogram gets reported only once (for the downloaded icon, not for the
+  // default one).
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.popular"),
+      ElementsAre(Bucket(/*bucket=*/0, /*count=*/1)));  // bucket 0 = SUCCESS.
 }
 
 TEST_F(IconCacherTestPopularSites, LargeNotCachedAndFetchPerformedOnlyOnce) {
   base::MockCallback<base::Closure> done;
   base::RunLoop loop;
   {
     InSequence s;
     // Image fetcher is used only once.
     EXPECT_CALL(*image_fetcher_,
                 SetDataUseServiceName(
@@ skipping 34 matching lines @@
   }
 
   scoped_refptr<base::TestSimpleTaskRunner>
       large_icon_service_background_task_runner_;
   std::unique_ptr<MockImageFetcher> fetcher_for_large_icon_service_;
   std::unique_ptr<MockImageFetcher> fetcher_for_icon_cacher_;
 };
 
 TEST_F(IconCacherTestMostLikely, Cached) {
   GURL page_url("http://www.site.com");
+  base::HistogramTester histogram_tester;
+
   GURL icon_url("http://www.site.com/favicon.png");
   PreloadIcon(page_url, icon_url, favicon_base::TOUCH_ICON, 128, 128);
 
   favicon::LargeIconService large_icon_service(
       &favicon_service_, large_icon_service_background_task_runner_,
       std::move(fetcher_for_large_icon_service_));
   IconCacherImpl cacher(&favicon_service_, &large_icon_service,
                         std::move(fetcher_for_icon_cacher_));
 
   base::MockCallback<base::Closure> done;
   EXPECT_CALL(done, Run()).Times(0);
   cacher.StartFetchMostLikely(page_url, done.Get());
   WaitForMainThreadTasksToFinish();
 
   EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.server"),
+      IsEmpty());
 }
 
 TEST_F(IconCacherTestMostLikely, NotCachedAndFetchSucceeded) {
   GURL page_url("http://www.site.com");
+  base::HistogramTester histogram_tester;
 
   base::MockCallback<base::Closure> done;
   base::RunLoop loop;
   {
     InSequence s;
     EXPECT_CALL(*fetcher_for_large_icon_service_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::LARGE_ICON_SERVICE));
     EXPECT_CALL(*fetcher_for_large_icon_service_,
                 StartOrQueueNetworkRequest(_, _, _))
         .WillOnce(PassFetch(128, 128));
     EXPECT_CALL(done, Run()).WillOnce(Quit(&loop));
   }
 
   favicon::LargeIconService large_icon_service(
       &favicon_service_, large_icon_service_background_task_runner_,
       std::move(fetcher_for_large_icon_service_));
   IconCacherImpl cacher(&favicon_service_, &large_icon_service,
                         std::move(fetcher_for_icon_cacher_));
 
   cacher.StartFetchMostLikely(page_url, done.Get());
   // Both these task runners need to be flushed in order to get |done| called by
   // running the main loop.
   WaitForHistoryThreadTasksToFinish();
   large_icon_service_background_task_runner_->RunUntilIdle();
 
   loop.Run();
   EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.server"),
+      ElementsAre(Bucket(/*bucket=*/0, /*count=*/1)));  // bucket 0 = SUCCESS.
 }
 
 TEST_F(IconCacherTestMostLikely, NotCachedAndFetchFailed) {
   GURL page_url("http://www.site.com");
+  base::HistogramTester histogram_tester;
 
   base::MockCallback<base::Closure> done;
   {
     InSequence s;
     EXPECT_CALL(*fetcher_for_large_icon_service_,
                 SetDataUseServiceName(
                     data_use_measurement::DataUseUserData::LARGE_ICON_SERVICE));
     EXPECT_CALL(*fetcher_for_large_icon_service_,
                 StartOrQueueNetworkRequest(_, _, _))
         .WillOnce(FailFetch());
     EXPECT_CALL(done, Run()).Times(0);
   }
 
   favicon::LargeIconService large_icon_service(
       &favicon_service_, large_icon_service_background_task_runner_,
       std::move(fetcher_for_large_icon_service_));
   IconCacherImpl cacher(&favicon_service_, &large_icon_service,
                         std::move(fetcher_for_icon_cacher_));
 
   cacher.StartFetchMostLikely(page_url, done.Get());
   // Both these task runners need to be flushed before flushing the main thread
   // queue in order to finish the work.
   WaitForHistoryThreadTasksToFinish();
   large_icon_service_background_task_runner_->RunUntilIdle();
   WaitForMainThreadTasksToFinish();
 
   EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON));
   EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("NewTabPage.TileFaviconFetched.server"),
+      ElementsAre(Bucket(/*bucket=*/1, /*count=*/1)));  // bucket 1 = FAILURE.
 }
 
 TEST_F(IconCacherTestMostLikely, HandlesEmptyCallbacksNicely) {
   GURL page_url("http://www.site.com");
 
   EXPECT_CALL(*fetcher_for_large_icon_service_, SetDataUseServiceName(_));
   EXPECT_CALL(*fetcher_for_large_icon_service_,
               StartOrQueueNetworkRequest(_, _, _))
       .WillOnce(PassFetch(128, 128));
 
@@ skipping 46 matching lines @@
   WaitForHistoryThreadTasksToFinish();
   large_icon_service_background_task_runner_->RunUntilIdle();
 
   loop.Run();
   EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON));
 }
 
 }  // namespace
 }  // namespace ntp_tiles