[NTP Tiles] Fetch missing MostLikely tiles from a Google server

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/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"
@@ skipping 66 matching lines @@
 class IconCacherTest : public ::testing::Test {
  protected:
   IconCacherTest()
       : site_(base::string16(),  // title, unused
               GURL("http://url.google/"),
               GURL("http://url.google/icon.png"),
               GURL("http://url.google/favicon.ico"),
               GURL()),  // thumbnail, unused
         image_fetcher_(new ::testing::StrictMock<MockImageFetcher>),
         image_decoder_(new ::testing::StrictMock<MockImageDecoder>),
+        task_runner_(new base::TestSimpleTaskRunner()),
         favicon_service_(/*favicon_client=*/nullptr, &history_service_),
-        task_runner_(new base::TestSimpleTaskRunner()) {
+        large_icon_service_(
+            &favicon_service_,
+            task_runner_,
+            base::MakeUnique<::testing::StrictMock<MockImageFetcher>>()) {
     CHECK(history_dir_.CreateUniqueTempDir());
     CHECK(history_service_.Init(
         history::HistoryDatabaseParams(history_dir_.GetPath(), 0, 0)));
   }
 
   void SetUp() override {
     if (ui::ResourceBundle::HasSharedInstance()) {
       ui::ResourceBundle::CleanupSharedInstance();
     }
     ON_CALL(mock_resource_delegate_, GetPathForResourcePack(_, _))
@@ skipping 58 matching lines @@
   }
 
   void WaitForTasksToFinish() { task_runner_->RunUntilIdle(); }
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   PopularSites::Site site_;
   std::unique_ptr<MockImageFetcher> image_fetcher_;
   std::unique_ptr<MockImageDecoder> image_decoder_;
   base::ScopedTempDir history_dir_;
   history::HistoryService history_service_;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   favicon::FaviconServiceImpl favicon_service_;
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  favicon::LargeIconService large_icon_service_;
   NiceMock<MockResourceDelegate> mock_resource_delegate_;
 };
 
 ACTION(FailFetch) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(arg2, arg0, gfx::Image(), image_fetcher::RequestMetadata()));
 }
 
 ACTION_P2(DecodeSuccessfully, width, height) {
@@ skipping 17 matching lines @@
   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_, std::move(image_fetcher_));
-  cacher.StartFetch(site_, done.Get(), done.Get());
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        std::move(image_fetcher_));
+  cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   WaitForTasksToFinish();
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
 }
 
 TEST_F(IconCacherTest, LargeNotCachedAndFetchSucceeded) {
   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_, std::move(image_fetcher_));
-  cacher.StartFetch(site_, done.Get(), done.Get());
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        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));
 }
 
 TEST_F(IconCacherTest, 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_, std::move(image_fetcher_));
-  cacher.StartFetch(site_, done.Get(), done.Get());
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        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(IconCacherTest, LargeNotCachedAndFetchFailed) {
   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_, std::move(image_fetcher_));
-  cacher.StartFetch(site_, done.Get(), done.Get());
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        std::move(image_fetcher_));
+  cacher.StartFetchPopularSites(site_, done.Get(), done.Get());
   WaitForTasksToFinish();
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
   EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
 }
 
 TEST_F(IconCacherTest, HandlesEmptyCallbacksNicely) {
   EXPECT_CALL(*image_fetcher_, SetDataUseServiceName(_));
   EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(_));
   ON_CALL(*image_fetcher_, StartOrQueueNetworkRequest(_, _, _))
       .WillByDefault(PassFetch(128, 128));
-  IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_));
-  cacher.StartFetch(site_, base::Closure(), base::Closure());
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        std::move(image_fetcher_));
+  cacher.StartFetchPopularSites(site_, base::Closure(), base::Closure());
   WaitForTasksToFinish();
 }
 
 TEST_F(IconCacherTest, ProvidesDefaultIconAndSucceedsWithFetching) {
   // 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())
@@ skipping 14 matching lines @@
                 StartOrQueueNetworkRequest(_, site_.large_icon_url, _))
         .WillOnce(PassFetch(128, 128));
 
     // Both callback are called async after the request but preliminary has to
     // preceed icon_available.
     EXPECT_CALL(preliminary_icon_available, Run())
         .WillOnce(Quit(&default_loop));
     EXPECT_CALL(icon_available, Run()).WillOnce(Quit(&fetch_loop));
   }
 
-  IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_));
+  IconCacherImpl cacher(&favicon_service_, &large_icon_service_,
+                        std::move(image_fetcher_));
   site_.default_icon_resource = 12345;
-  cacher.StartFetch(site_, icon_available.Get(),
-                    preliminary_icon_available.Get());
+  cacher.StartFetchPopularSites(site_, icon_available.Get(),
+                                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.
 }
 
 }  // namespace
 }  // namespace ntp_tiles