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   SkBitmap empty_bitmap;
  49
  50   // OnImageChanged with an empty bitmap signifies a completed request.
  51   observer_->OnImageChanged(request_id_, empty_bitmap);
  52 }
  53
  54 void BitmapFetcherRequest::NotifyImageChanged(const SkBitmap& bitmap) {
  55   if (!bitmap.empty())
  56     observer_->OnImageChanged(request_id_, bitmap);
  57 }
  58
  59 BitmapFetcherService::CacheEntry::CacheEntry() {
  60 }
  61
  62 BitmapFetcherService::CacheEntry::~CacheEntry() {
  63 }
  64
  65 BitmapFetcherService::BitmapFetcherService(content::BrowserContext* context)
  66     : cache_(kMaxCacheEntries), current_request_id_(1), context_(context) {
  67 }
  68
  69 BitmapFetcherService::~BitmapFetcherService() {
  70 }
  71
  72 void BitmapFetcherService::CancelRequest(int request_id) {
  73   ScopedVector<BitmapFetcherRequest>::iterator iter;
  74   for (iter = requests_.begin(); iter != requests_.end(); ++iter) {
  75     if ((*iter)->request_id() == request_id) {
  76       requests_.erase(iter);
  77       // Deliberately leave the associated fetcher running to populate cache.
  78       return;
  79     }
  80   }
  81 }
  82
  83 BitmapFetcherService::RequestId BitmapFetcherService::RequestImage(
  84     const GURL& url,
  85     Observer* observer) {
  86   // Create a new request, assigning next available request ID.
  87   ++current_request_id_;
  88   if (current_request_id_ == REQUEST_ID_INVALID)
  89     ++current_request_id_;
  90   int request_id = current_request_id_;
  91   scoped_ptr<BitmapFetcherRequest> request(
  92       new BitmapFetcherRequest(request_id, observer));
  93
  94   // Check for existing images first.
  95   base::OwningMRUCache<GURL, CacheEntry*>::iterator iter = cache_.Get(url);
  96   if (iter != cache_.end()) {
  97     BitmapFetcherService::CacheEntry* entry = iter->second;
  98     request->NotifyImageChanged(*(entry->bitmap.get()));
  99
 100     // There is no request ID associated with this - data is already delivered.
 101     return REQUEST_ID_INVALID;
 102   }
 103
 104   // Limit number of simultaneous in-flight requests.
 105   if (requests_.size() > kMaxRequests)
 106     return REQUEST_ID_INVALID;
 107
 108   // Make sure there's a fetcher for this URL and attach to request.
 109   const chrome::BitmapFetcher* fetcher = EnsureFetcherForUrl(url);
 110   request->set_fetcher(fetcher);
 111
 112   requests_.push_back(request.release());
 113   return requests_.back()->request_id();
 114 }
 115
 116 void BitmapFetcherService::Prefetch(const GURL& url) {
 117   EnsureFetcherForUrl(url);
 118 }
 119
 120 chrome::BitmapFetcher* BitmapFetcherService::CreateFetcher(const GURL& url) {
 121   chrome::BitmapFetcher* new_fetcher = new chrome::BitmapFetcher(url, this);
 122
 123   new_fetcher->Start(
 124       context_->GetRequestContext(),
 125       std::string(),
 126       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
 127       net::LOAD_NORMAL);
 128   return new_fetcher;
 129 }
 130
 131 const chrome::BitmapFetcher* BitmapFetcherService::EnsureFetcherForUrl(
 132     const GURL& url) {
 133   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
 134   if (fetcher)
 135     return fetcher;
 136
 137   chrome::BitmapFetcher* new_fetcher = CreateFetcher(url);
 138   active_fetchers_.push_back(new_fetcher);
 139   return new_fetcher;
 140 }
 141
 142 const chrome::BitmapFetcher* BitmapFetcherService::FindFetcherForUrl(
 143     const GURL& url) {
 144   for (BitmapFetchers::iterator iter = active_fetchers_.begin();
 145        iter != active_fetchers_.end();
 146        ++iter) {
 147     if (url == (*iter)->url())
 148       return *iter;
 149   }
 150   return NULL;
 151 }
 152
 153 void BitmapFetcherService::RemoveFetcher(const chrome::BitmapFetcher* fetcher) {
 154   for (BitmapFetchers::iterator iter = active_fetchers_.begin();
 155        iter != active_fetchers_.end();
 156        ++iter) {
 157     if (fetcher == (*iter)) {
 158       active_fetchers_.erase(iter);
 159       return;
 160     }
 161   }
 162   NOTREACHED();  // RemoveFetcher should always result in removal.
 163 }
 164
 165 void BitmapFetcherService::OnFetchComplete(const GURL url,
 166                                            const SkBitmap* bitmap) {
 167   DCHECK(bitmap);  // can never be NULL, guaranteed by BitmapFetcher.
 168
 169   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
 170   DCHECK(fetcher);
 171
 172   // Notify all attached requests of completion.
 173   ScopedVector<BitmapFetcherRequest>::iterator iter = requests_.begin();
 174   while (iter != requests_.end()) {
 175     if ((*iter)->get_fetcher() == fetcher) {
 176       (*iter)->NotifyImageChanged(*bitmap);
 177       iter = requests_.erase(iter);
 178     } else {
 179       ++iter;
 180     }
 181   }
 182
 183   if (!bitmap->isNull()) {
 184     CacheEntry* entry = new CacheEntry;
 185     entry->bitmap.reset(new SkBitmap(*bitmap));
 186     cache_.Put(fetcher->url(), entry);
 187   }
 188
 189   RemoveFetcher(fetcher);
 190 }