src/chrome/browser/bitmap_fetcher/bitmap_fetcher_service.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 "base/memory/weak_ptr.h"
   8 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "net/base/load_flags.h"
  11 #include "third_party/skia/include/core/SkBitmap.h"
  12
  13 namespace {
  14
  15 const size_t kMaxRequests = 25;  // Maximum number of inflight requests allowed.
  16 const int kMaxCacheEntries = 5;  // Maximum number of cache entries.
  17
  18 }  // namespace.
  19
  20 class BitmapFetcherRequest {
  21  public:
  22   BitmapFetcherRequest(BitmapFetcherService::RequestId request_id,
  23                        BitmapFetcherService::Observer* observer);
  24   ~BitmapFetcherRequest();
  25
  26   void NotifyImageChanged(const SkBitmap& bitmap);
  27   BitmapFetcherService::RequestId request_id() const { return request_id_; }
  28
  29   // Weak ptr |fetcher| is used to identify associated fetchers.
  30   void set_fetcher(const chrome::BitmapFetcher* fetcher) { fetcher_ = fetcher; }
  31   const chrome::BitmapFetcher* get_fetcher() const { return fetcher_; }
  32
  33  private:
  34   const BitmapFetcherService::RequestId request_id_;
  35   scoped_ptr<BitmapFetcherService::Observer> observer_;
  36   const chrome::BitmapFetcher* fetcher_;
  37
  38   DISALLOW_COPY_AND_ASSIGN(BitmapFetcherRequest);
  39 };
  40
  41 BitmapFetcherRequest::BitmapFetcherRequest(
  42     BitmapFetcherService::RequestId request_id,
  43     BitmapFetcherService::Observer* observer)
  44     : request_id_(request_id), observer_(observer) {
  45 }
  46
  47 BitmapFetcherRequest::~BitmapFetcherRequest() {
  48 }
  49
  50 void BitmapFetcherRequest::NotifyImageChanged(const SkBitmap& bitmap) {
  51   if (!bitmap.empty())
  52     observer_->OnImageChanged(request_id_, bitmap);
  53 }
  54
  55 BitmapFetcherService::CacheEntry::CacheEntry() {
  56 }
  57
  58 BitmapFetcherService::CacheEntry::~CacheEntry() {
  59 }
  60
  61 BitmapFetcherService::BitmapFetcherService(content::BrowserContext* context)
  62     : cache_(kMaxCacheEntries), current_request_id_(1), context_(context) {
  63 }
  64
  65 BitmapFetcherService::~BitmapFetcherService() {
  66 }
  67
  68 void BitmapFetcherService::CancelRequest(int request_id) {
  69   ScopedVector<BitmapFetcherRequest>::iterator iter;
  70   for (iter = requests_.begin(); iter != requests_.end(); ++iter) {
  71     if ((*iter)->request_id() == request_id) {
  72       requests_.erase(iter);
  73       // Deliberately leave the associated fetcher running to populate cache.
  74       return;
  75     }
  76   }
  77 }
  78
  79 BitmapFetcherService::RequestId BitmapFetcherService::RequestImage(
  80     const GURL& url,
  81     Observer* observer) {
  82   // Create a new request, assigning next available request ID.
  83   ++current_request_id_;
  84   if (current_request_id_ == REQUEST_ID_INVALID)
  85     ++current_request_id_;
  86   int request_id = current_request_id_;
  87   scoped_ptr<BitmapFetcherRequest> request(
  88       new BitmapFetcherRequest(request_id, observer));
  89
  90   // Check for existing images first.
  91   base::OwningMRUCache<GURL, CacheEntry*>::iterator iter = cache_.Get(url);
  92   if (iter != cache_.end()) {
  93     BitmapFetcherService::CacheEntry* entry = iter->second;
  94     request->NotifyImageChanged(*(entry->bitmap.get()));
  95
  96     // There is no request ID associated with this - data is already delivered.
  97     return REQUEST_ID_INVALID;
  98   }
  99
 100   // Limit number of simultaneous in-flight requests.
 101   if (requests_.size() > kMaxRequests)
 102     return REQUEST_ID_INVALID;
 103
 104   // Make sure there's a fetcher for this URL and attach to request.
 105   const chrome::BitmapFetcher* fetcher = EnsureFetcherForUrl(url);
 106   request->set_fetcher(fetcher);
 107
 108   requests_.push_back(request.release());
 109   return requests_.back()->request_id();
 110 }
 111
 112 void BitmapFetcherService::Prefetch(const GURL& url) {
 113   if (url.is_valid())
 114     EnsureFetcherForUrl(url);
 115 }
 116
 117 chrome::BitmapFetcher* BitmapFetcherService::CreateFetcher(const GURL& url) {
 118   chrome::BitmapFetcher* new_fetcher = new chrome::BitmapFetcher(url, this);
 119
 120   new_fetcher->Start(
 121       context_->GetRequestContext(),
 122       std::string(),
 123       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
 124       net::LOAD_NORMAL);
 125   return new_fetcher;
 126 }
 127
 128 const chrome::BitmapFetcher* BitmapFetcherService::EnsureFetcherForUrl(
 129     const GURL& url) {
 130   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
 131   if (fetcher)
 132     return fetcher;
 133
 134   chrome::BitmapFetcher* new_fetcher = CreateFetcher(url);
 135   active_fetchers_.push_back(new_fetcher);
 136   return new_fetcher;
 137 }
 138
 139 const chrome::BitmapFetcher* BitmapFetcherService::FindFetcherForUrl(
 140     const GURL& url) {
 141   for (BitmapFetchers::iterator iter = active_fetchers_.begin();
 142        iter != active_fetchers_.end();
 143        ++iter) {
 144     if (url == (*iter)->url())
 145       return *iter;
 146   }
 147   return NULL;
 148 }
 149
 150 void BitmapFetcherService::RemoveFetcher(const chrome::BitmapFetcher* fetcher) {
 151   for (BitmapFetchers::iterator iter = active_fetchers_.begin();
 152        iter != active_fetchers_.end();
 153        ++iter) {
 154     if (fetcher == (*iter)) {
 155       active_fetchers_.erase(iter);
 156       return;
 157     }
 158   }
 159   NOTREACHED();  // RemoveFetcher should always result in removal.
 160 }
 161
 162 void BitmapFetcherService::OnFetchComplete(const GURL url,
 163                                            const SkBitmap* bitmap) {
 164   DCHECK(bitmap);  // can never be NULL, guaranteed by BitmapFetcher.
 165
 166   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
 167   DCHECK(fetcher);
 168
 169   // Notify all attached requests of completion.
 170   ScopedVector<BitmapFetcherRequest>::iterator iter = requests_.begin();
 171   while (iter != requests_.end()) {
 172     if ((*iter)->get_fetcher() == fetcher) {
 173       (*iter)->NotifyImageChanged(*bitmap);
 174       iter = requests_.erase(iter);
 175     } else {
 176       ++iter;
 177     }
 178   }
 179
 180   if (!bitmap->isNull()) {
 181     CacheEntry* entry = new CacheEntry;
 182     entry->bitmap.reset(new SkBitmap(*bitmap));
 183     cache_.Put(fetcher->url(), entry);
 184   }
 185
 186   RemoveFetcher(fetcher);
 187 }