chrome/browser/bitmap_fetcher/bitmap_fetcher_service_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher_service.h"
   6
   7 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
   8 #include "chrome/test/base/testing_profile.h"
   9 #include "content/public/test/test_browser_thread_bundle.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace {
  13
  14 class TestNotificationInterface {
  15  public:
  16   virtual ~TestNotificationInterface() {}
  17   virtual void OnImageChanged() = 0;
  18   virtual void OnRequestFinished() = 0;
  19 };
  20
  21 class TestObserver : public BitmapFetcherService::Observer {
  22  public:
  23   explicit TestObserver(TestNotificationInterface* target) : target_(target) {}
  24   ~TestObserver() override { target_->OnRequestFinished(); }
  25
  26   void OnImageChanged(BitmapFetcherService::RequestId request_id,
  27                       const SkBitmap& answers_image) override {
  28     target_->OnImageChanged();
  29   }
  30
  31  private:
  32   TestNotificationInterface* target_;
  33
  34   DISALLOW_COPY_AND_ASSIGN(TestObserver);
  35 };
  36
  37 class TestService : public BitmapFetcherService {
  38  public:
  39   explicit TestService(content::BrowserContext* context)
  40       : BitmapFetcherService(context) {}
  41   ~TestService() override {}
  42
  43   // Create a fetcher, but don't start downloading. That allows side-stepping
  44   // the decode step, which requires a utility process.
  45   chrome::BitmapFetcher* CreateFetcher(const GURL& url) override {
  46     return new chrome::BitmapFetcher(url, this);
  47   }
  48 };
  49
  50 }  // namespace
  51
  52 class BitmapFetcherServiceTest : public testing::Test,
  53                                  public TestNotificationInterface {
  54  public:
  55   BitmapFetcherServiceTest()
  56       : url1_(GURL("http://example.org/sample-image-1.png")),
  57         url2_(GURL("http://example.org/sample-image-2.png")) {
  58   }
  59
  60   void SetUp() override {
  61     service_.reset(new TestService(&profile_));
  62     requests_finished_ = 0;
  63     images_changed_ = 0;
  64   }
  65
  66   const ScopedVector<BitmapFetcherRequest>& requests() const {
  67     return service_->requests_;
  68   }
  69   const ScopedVector<chrome::BitmapFetcher>& active_fetchers() const {
  70     return service_->active_fetchers_;
  71   }
  72   size_t cache_size() const { return service_->cache_.size(); }
  73
  74   void OnImageChanged() override { images_changed_++; }
  75
  76   void OnRequestFinished() override { requests_finished_++; }
  77
  78   // Simulate finishing a URL fetch and decode for the given fetcher.
  79   void CompleteFetch(const GURL& url) {
  80     const chrome::BitmapFetcher* fetcher = service_->FindFetcherForUrl(url);
  81     ASSERT_TRUE(fetcher);
  82
  83     // Create a non-empty bitmap.
  84     SkBitmap image;
  85     image.allocN32Pixels(2, 2);
  86     image.eraseColor(SK_ColorGREEN);
  87
  88     const_cast<chrome::BitmapFetcher*>(fetcher)->OnImageDecoded(image);
  89   }
  90
  91   void FailFetch(const GURL& url) {
  92     const chrome::BitmapFetcher* fetcher = service_->FindFetcherForUrl(url);
  93     ASSERT_TRUE(fetcher);
  94     const_cast<chrome::BitmapFetcher*>(fetcher)->OnImageDecoded(SkBitmap());
  95   }
  96
  97  protected:
  98   scoped_ptr<BitmapFetcherService> service_;
  99
 100   int images_changed_;
 101   int requests_finished_;
 102
 103   const GURL url1_;
 104   const GURL url2_;
 105
 106  private:
 107   content::TestBrowserThreadBundle thread_bundle_;
 108   TestingProfile profile_;
 109 };
 110
 111 TEST_F(BitmapFetcherServiceTest, RequestInvalidUrl) {
 112   const BitmapFetcherService::RequestId invalid_request_id =
 113       BitmapFetcherService::REQUEST_ID_INVALID;
 114   GURL invalid_url;
 115   ASSERT_FALSE(invalid_url.is_valid());
 116
 117   BitmapFetcherService::RequestId request_id =
 118       service_->RequestImage(invalid_url, new TestObserver(this));
 119   EXPECT_EQ(invalid_request_id, request_id);
 120 }
 121
 122 TEST_F(BitmapFetcherServiceTest, CancelInvalidRequest) {
 123   service_->CancelRequest(BitmapFetcherService::REQUEST_ID_INVALID);
 124   service_->CancelRequest(23);
 125 }
 126
 127 TEST_F(BitmapFetcherServiceTest, OnlyFirstRequestCreatesFetcher) {
 128   EXPECT_EQ(0U, active_fetchers().size());
 129
 130   service_->RequestImage(url1_, new TestObserver(this));
 131   EXPECT_EQ(1U, active_fetchers().size());
 132
 133   service_->RequestImage(url1_, new TestObserver(this));
 134   EXPECT_EQ(1U, active_fetchers().size());
 135 }
 136
 137 TEST_F(BitmapFetcherServiceTest, CompletedFetchNotifiesAllObservers) {
 138   service_->RequestImage(url1_, new TestObserver(this));
 139   service_->RequestImage(url1_, new TestObserver(this));
 140   service_->RequestImage(url1_, new TestObserver(this));
 141   service_->RequestImage(url1_, new TestObserver(this));
 142   EXPECT_EQ(1U, active_fetchers().size());
 143   EXPECT_EQ(4U, requests().size());
 144
 145   CompleteFetch(url1_);
 146   EXPECT_EQ(4, images_changed_);
 147   EXPECT_EQ(4, requests_finished_);
 148 }
 149
 150 TEST_F(BitmapFetcherServiceTest, CancelRequest) {
 151   service_->RequestImage(url1_, new TestObserver(this));
 152   service_->RequestImage(url1_, new TestObserver(this));
 153   BitmapFetcherService::RequestId requestId =
 154       service_->RequestImage(url2_, new TestObserver(this));
 155   service_->RequestImage(url1_, new TestObserver(this));
 156   service_->RequestImage(url1_, new TestObserver(this));
 157   EXPECT_EQ(5U, requests().size());
 158
 159   service_->CancelRequest(requestId);
 160   EXPECT_EQ(4U, requests().size());
 161
 162   CompleteFetch(url2_);
 163   EXPECT_EQ(0, images_changed_);
 164
 165   CompleteFetch(url1_);
 166   EXPECT_EQ(4, images_changed_);
 167 }
 168
 169 TEST_F(BitmapFetcherServiceTest, FailedRequestsDontEnterCache) {
 170   service_->RequestImage(url1_, new TestObserver(this));
 171   service_->RequestImage(url2_, new TestObserver(this));
 172   EXPECT_EQ(0U, cache_size());
 173
 174   CompleteFetch(url1_);
 175   EXPECT_EQ(1U, cache_size());
 176
 177   FailFetch(url2_);
 178   EXPECT_EQ(1U, cache_size());
 179 }