Ensure PopularSite icon availability in ntp_tiles.

components/ntp_tiles/icon_cacher_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.h"
+
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "components/favicon/core/favicon_client.h"
+#include "components/favicon/core/favicon_service.h"
+#include "components/favicon/core/favicon_util.h"
+#include "components/history/core/browser/history_database_params.h"
+#include "components/history/core/browser/history_service.h"
+#include "components/image_fetcher/image_fetcher.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+using ::testing::_;
+using ::testing::InSequence;
+using ::testing::MockFunction;
+using ::testing::Return;
+
+namespace ntp_tiles {
+namespace {
+
+class MockImageFetcher : public image_fetcher::ImageFetcher {
+ public:
+  MOCK_METHOD1(SetImageFetcherDelegate,
+               void(image_fetcher::ImageFetcherDelegate* delegate));
+  MOCK_METHOD1(SetDataUseServiceName,
+               void(image_fetcher::ImageFetcher::DataUseServiceName name));
+  MOCK_METHOD3(StartOrQueueNetworkRequest,
+               void(const std::string& id,
+                    const GURL& image_url,
+                    base::Callback<void(const std::string& id,
+                                        const gfx::Image& image)> callback));
+};
+
+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>),
+        favicon_service_(/*favicon_client=*/nullptr, &history_service_) {
+    CHECK(history_dir_.CreateUniqueTempDir());
+    CHECK(history_service_.Init(
+        history::HistoryDatabaseParams(history_dir_.GetPath(), 0, 0)));
+  }
+
+  void PreloadIcon(const GURL& url,
+                   const GURL& icon_url,
+                   favicon_base::IconType icon_type,
+                   int width,
+                   int height) {
+    favicon_service_.SetFavicons(url, icon_url, icon_type,
+                                 gfx::test::CreateImage(width, height));
+  }
+
+  bool IconIsCachedFor(const GURL& url, favicon_base::IconType icon_type) {
+    base::CancelableTaskTracker tracker;
+    bool is_cached;
+    base::RunLoop loop;
+    favicon::GetFaviconImageForPageURL(
+        &favicon_service_, url, icon_type,
+        base::Bind(
+            [](bool* is_cached, base::RunLoop* loop,
+               const favicon_base::FaviconImageResult& result) {
+              *is_cached = !result.image.IsEmpty();
+              loop->Quit();
+            },
+            &is_cached, &loop),
+        &tracker);
+    loop.Run();
+    return is_cached;
+  }
+
+  base::MessageLoop message_loop_;
+  PopularSites::Site site_;
+  std::unique_ptr<MockImageFetcher> image_fetcher_;
+  base::ScopedTempDir history_dir_;
+  history::HistoryService history_service_;
+  favicon::FaviconService favicon_service_;
+};
+
+template <typename Fn>
+base::Callback<Fn> BindMockFunction(MockFunction<Fn>* function) {
+  return base::Bind(&MockFunction<Fn>::Call, base::Unretained(function));
+}
+
+ACTION(FailFetch) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(arg2, arg0, gfx::Image()));
+}
+
+ACTION_P2(PassFetch, width, height) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(arg2, arg0, gfx::test::CreateImage(width, height)));
+}
+
+ACTION_P(Quit, run_loop) {
+  run_loop->Quit();
+}
+
+TEST_F(IconCacherTest, LargeCached) {
+  MockFunction<void(bool)> done;
+  base::RunLoop loop;
+  {
+    InSequence s;
+    EXPECT_CALL(*image_fetcher_,
+                SetDataUseServiceName(
+                    data_use_measurement::DataUseUserData::NTP_TILES));
+    EXPECT_CALL(done, Call(false)).WillOnce(Quit(&loop));

[Bernhard Bauer, 2016/10/13 13:20:09]

Hm, this seems more complicated than, say, using captureless lambdas like above.
Or just making a custom callback class:

  template<T>
  class ResultCallback<T> {
   public:
    base::Callback<void(T)> GetCallback() {
      return base::Bind(&ResultCallback<T>::SetResult, base::Unretained(this));
    }

    T WaitForResult() {
      run_loop_.Run();
      return result_;
    }

   private:
    void SetResult(T result) {
      result_ = result;
      run_loop_.Quit();
    }

    base::RunLoop run_loop_;
    T result_;
  };

[sfiera, 2016/10/14 06:27:32]

To me, the captureless lambda seems like the most convoluted option.
ResultCallback<T> is OK, but to me the mock approach fits better with the use of
the MockImageFetcher.

[Bernhard Bauer, 2016/10/17 14:38:38]

Yeah, TBH I'm not a big fan of the MockImageFetcher either :) Too much magic
going on IMO, in particular with ACTIONs...

But if you prefer this, LGTM.

+  }
+  PreloadIcon(site_.url, site_.large_icon_url, favicon_base::TOUCH_ICON, 128,
+              128);
+
+  IconCacher cacher(&favicon_service_, std::move(image_fetcher_));
+  cacher.StartFetch(site_, BindMockFunction(&done));
+  loop.Run();
+  EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
+  EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+}
+
+TEST_F(IconCacherTest, LargeNotCachedAndFetchSucceeded) {
+  MockFunction<void(bool)> done;
+  base::RunLoop loop;
+  {
+    InSequence s;
+    EXPECT_CALL(*image_fetcher_,
+                SetDataUseServiceName(
+                    data_use_measurement::DataUseUserData::NTP_TILES));
+    EXPECT_CALL(*image_fetcher_,
+                StartOrQueueNetworkRequest(_, site_.large_icon_url, _))
+        .WillOnce(PassFetch(128, 128));
+    EXPECT_CALL(done, Call(true)).WillOnce(Quit(&loop));
+  }
+
+  IconCacher cacher(&favicon_service_, std::move(image_fetcher_));
+  cacher.StartFetch(site_, BindMockFunction(&done));
+  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();
+
+  MockFunction<void(bool)> done;
+  base::RunLoop loop;
+  {
+    InSequence s;
+    EXPECT_CALL(*image_fetcher_,
+                SetDataUseServiceName(
+                    data_use_measurement::DataUseUserData::NTP_TILES));
+    EXPECT_CALL(*image_fetcher_,
+                StartOrQueueNetworkRequest(_, site_.favicon_url, _))
+        .WillOnce(PassFetch(128, 128));
+    EXPECT_CALL(done, Call(true)).WillOnce(Quit(&loop));
+  }
+
+  IconCacher cacher(&favicon_service_, std::move(image_fetcher_));
+  cacher.StartFetch(site_, BindMockFunction(&done));
+  loop.Run();
+  EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
+  EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+}
+
+TEST_F(IconCacherTest, LargeNotCachedAndFetchFailed) {
+  MockFunction<void(bool)> done;
+  base::RunLoop loop;
+  {
+    InSequence s;
+    EXPECT_CALL(*image_fetcher_,
+                SetDataUseServiceName(
+                    data_use_measurement::DataUseUserData::NTP_TILES));
+    EXPECT_CALL(*image_fetcher_,
+                StartOrQueueNetworkRequest(_, site_.large_icon_url, _))
+        .WillOnce(FailFetch());
+    EXPECT_CALL(done, Call(false)).WillOnce(Quit(&loop));
+  }
+
+  IconCacher cacher(&favicon_service_, std::move(image_fetcher_));
+  cacher.StartFetch(site_, BindMockFunction(&done));
+  loop.Run();
+  EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON));
+  EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON));
+}
+
+}  // namespace
+}  // namespace ntp_tiles