[Doodle] Move image fetching from LogoBridge to DoodleService

components/doodle/doodle_service_unittest.cc

 // Copyright 2017 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/doodle/doodle_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/mock_callback.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "components/image_fetcher/core/image_fetcher.h"
+#include "components/image_fetcher/core/request_metadata.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_unittest_util.h"
 
+using image_fetcher::ImageFetcher;
+using image_fetcher::RequestMetadata;
+using testing::_;
 using testing::Eq;
 using testing::StrictMock;
+using testing::Not;
 
 namespace doodle {
 
 namespace {
 
 class FakeDoodleFetcher : public DoodleFetcher {
  public:
   FakeDoodleFetcher() = default;
   ~FakeDoodleFetcher() override = default;
 
@@ skipping 18 matching lines @@
   std::vector<FinishedCallback> callbacks_;
 };
 
 class MockDoodleObserver : public DoodleService::Observer {
  public:
   MOCK_METHOD1(OnDoodleConfigUpdated,
                void(const base::Optional<DoodleConfig>&));
   MOCK_METHOD1(OnDoodleConfigRevalidated, void(bool));
 };
 
+class FakeImageFetcher : public ImageFetcher {
+ public:
+  FakeImageFetcher() = default;
+  ~FakeImageFetcher() override = default;
+
+  void SetImageFetcherDelegate(image_fetcher::ImageFetcherDelegate*) override {
+    NOTREACHED();
+  }
+
+  void SetDataUseServiceName(DataUseServiceName) override {
+    // Ignored.
+  }
+
+  void SetImageDownloadLimit(base::Optional<int64_t>) override {
+    // Ignored.
+  }
+
+  void SetDesiredImageFrameSize(const gfx::Size&) override {
+    // Ignored.
+  }
+
+  void StartOrQueueNetworkRequest(
+      const std::string& id,
+      const GURL& url,
+      const ImageFetcherCallback& callback) override {
+    // For simplicity, the fake doesn't support multiple concurrent requests.
+    DCHECK(!HasPendingRequest());
+
+    pending_id_ = id;
+    pending_url_ = url;
+    pending_callback_ = callback;
+  }
+
+  image_fetcher::ImageDecoder* GetImageDecoder() override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  bool HasPendingRequest() const { return !pending_callback_.is_null(); }
+
+  const GURL& pending_url() const { return pending_url_; }
+
+  void RespondToPendingRequest(const gfx::Image& image) {
+    DCHECK(HasPendingRequest());
+
+    RequestMetadata metadata;
+    metadata.http_response_code = 200;
+    pending_callback_.Run(pending_id_, image, metadata);
+
+    pending_id_.clear();
+    pending_url_ = GURL();
+    pending_callback_.Reset();
+  }
+
+ private:
+  std::string pending_id_;
+  GURL pending_url_;
+  ImageFetcherCallback pending_callback_;
+};
+
 DoodleConfig CreateConfig(DoodleType type) {
   return DoodleConfig(type, DoodleImage(GURL("https://doodle.com/image.jpg")));
 }
 
+MATCHER(IsEmptyImage, "") {
+  return arg.IsEmpty();
+}
+
 }  // namespace
 
 class DoodleServiceTest : public testing::Test {
  public:
   DoodleServiceTest()
       : task_runner_(new base::TestMockTimeTaskRunner()),
         task_runner_handle_(task_runner_),
         tick_clock_(task_runner_->GetMockTickClock()),
         fetcher_(nullptr),
         expiry_timer_(nullptr) {
     DoodleService::RegisterProfilePrefs(pref_service_.registry());
 
     task_runner_->FastForwardBy(base::TimeDelta::FromHours(12345));
 
     // Set the minimum refresh interval to 0 by default, so tests don't have to
     // worry about it. The tests that care set it explicitly.
     RecreateServiceWithZeroRefreshInterval();
   }
 
-  void DestroyService() { service_ = nullptr; }
+  void TearDown() override { DestroyService(); }
+
+  void DestroyService() {
+    if (image_fetcher_) {
+      // Make sure we didn't receive an unexpected image request.
+      ASSERT_FALSE(image_fetcher_->HasPendingRequest());
+    }
+
+    fetcher_ = nullptr;
+    expiry_timer_ = nullptr;
+    image_fetcher_ = nullptr;
+
+    service_ = nullptr;
+  }
 
   void RecreateServiceWithZeroRefreshInterval() {
     RecreateService(/*min_refresh_interval=*/base::TimeDelta());
   }
 
   void RecreateService(base::Optional<base::TimeDelta> refresh_interval) {
     auto expiry_timer = base::MakeUnique<base::OneShotTimer>(tick_clock_.get());
     expiry_timer->SetTaskRunner(task_runner_);
     expiry_timer_ = expiry_timer.get();
 
     auto fetcher = base::MakeUnique<FakeDoodleFetcher>();
     fetcher_ = fetcher.get();
 
+    auto image_fetcher = base::MakeUnique<FakeImageFetcher>();
+    image_fetcher_ = image_fetcher.get();
+
     service_ = base::MakeUnique<DoodleService>(
         &pref_service_, std::move(fetcher), std::move(expiry_timer),
         task_runner_->GetMockClock(), task_runner_->GetMockTickClock(),
-        refresh_interval);
+        refresh_interval, std::move(image_fetcher));
   }
 
   DoodleService* service() { return service_.get(); }
   FakeDoodleFetcher* fetcher() { return fetcher_; }
+  FakeImageFetcher* image_fetcher() { return image_fetcher_; }
 
   base::TestMockTimeTaskRunner* task_runner() { return task_runner_.get(); }
 
  private:
   TestingPrefServiceSimple pref_service_;
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<base::TickClock> tick_clock_;
 
   std::unique_ptr<DoodleService> service_;
 
   // Weak, owned by the service.
   FakeDoodleFetcher* fetcher_;
   base::OneShotTimer* expiry_timer_;
+  FakeImageFetcher* image_fetcher_;
 };
 
 TEST_F(DoodleServiceTest, FetchesConfigOnRefresh) {
   ASSERT_THAT(service()->config(), Eq(base::nullopt));
 
   // Request a refresh of the doodle config.
   service()->Refresh();
   // The request should have arrived at the fetcher.
   EXPECT_THAT(fetcher()->num_pending_callbacks(), Eq(1u));
 
@@ skipping 457 matching lines @@
 
   // Fast-forward time so that the config expires.
   task_runner()->FastForwardBy(base::TimeDelta::FromHours(1));
   ASSERT_THAT(service()->config(), Eq(base::nullopt));
 
   // This should not have resulted in any metrics being emitted.
   histograms.ExpectTotalCount("Doodle.ConfigDownloadOutcome", 0);
   histograms.ExpectTotalCount("Doodle.ConfigDownloadTime", 0);
 }
 
+TEST_F(DoodleServiceTest, GetImageWithEmptyConfigReturnsImmediately) {
+  ASSERT_THAT(service()->config(), Eq(base::nullopt));
+
+  base::MockCallback<DoodleService::ImageCallback> callback;
+  EXPECT_CALL(callback, Run(IsEmptyImage()));
+
+  service()->GetImage(callback.Get());
+}
+
+TEST_F(DoodleServiceTest, GetImageFetchesLargeImage) {
+  service()->Refresh();
+  DoodleConfig config = CreateConfig(DoodleType::SIMPLE);
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE,
+                               base::TimeDelta::FromHours(1), config);
+  ASSERT_THAT(service()->config(), Eq(config));
+
+  base::MockCallback<DoodleService::ImageCallback> callback;
+  service()->GetImage(callback.Get());
+
+  EXPECT_EQ(config.large_image.url, image_fetcher()->pending_url());
+
+  EXPECT_CALL(callback, Run(Not(IsEmptyImage())));
+  gfx::Image image = gfx::test::CreateImage(1, 1);
+  ASSERT_TRUE(image_fetcher()->HasPendingRequest());
+  image_fetcher()->RespondToPendingRequest(image);
+}
+
+TEST_F(DoodleServiceTest, GetImageFetchesCTAImage) {
+  service()->Refresh();
+  DoodleConfig config = CreateConfig(DoodleType::SIMPLE);
+  // Set a CTA image, which should take precedence over the regular image.
+  config.large_image.is_animated_gif = true;
+  config.large_cta_image = DoodleImage(GURL("https://doodle.com/cta.jpg"));
+  config.large_cta_image->is_cta = true;
+  fetcher()->ServeAllCallbacks(DoodleState::AVAILABLE,
+                               base::TimeDelta::FromHours(1), config);
+  ASSERT_THAT(service()->config(), Eq(config));
+
+  base::MockCallback<DoodleService::ImageCallback> callback;
+  service()->GetImage(callback.Get());
+
+  // If the doodle has a CTA image, that should loaded instead of the regular
+  // large image.
+  EXPECT_EQ(config.large_cta_image->url, image_fetcher()->pending_url());
+
+  EXPECT_CALL(callback, Run(Not(IsEmptyImage())));
+  gfx::Image image = gfx::test::CreateImage(1, 1);
+  ASSERT_TRUE(image_fetcher()->HasPendingRequest());
+  image_fetcher()->RespondToPendingRequest(image);
+}
+
 }  // namespace doodle