| OLD | NEW |
|---|
| (Empty) |
| 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/search/suggestions/image_manager_impl.h" | |
| 6 | |
| 7 #include "base/memory/ref_counted_memory.h" | |
| 8 #include "content/public/browser/browser_thread.h" | |
| 9 #include "net/base/load_flags.h" | |
| 10 #include "net/url_request/url_request_context_getter.h" | |
| 11 #include "ui/gfx/codec/jpeg_codec.h" | |
| 12 | |
| 13 using leveldb_proto::ProtoDatabase; | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 // From JPEG-encoded bytes to SkBitmap. | |
| 18 SkBitmap* DecodeImage(const std::vector<unsigned char>& encoded_data) { | |
| 19 return gfx::JPEGCodec::Decode(&encoded_data[0], encoded_data.size()); | |
| 20 } | |
| 21 | |
| 22 } // namespace | |
| 23 | |
| 24 namespace suggestions { | |
| 25 | |
| 26 ImageManagerImpl::ImageManagerImpl() : weak_ptr_factory_(this) {} | |
| 27 | |
| 28 ImageManagerImpl::ImageManagerImpl( | |
| 29 net::URLRequestContextGetter* url_request_context, | |
| 30 scoped_ptr<ProtoDatabase<ImageData> > database, | |
| 31 const base::FilePath& database_dir) | |
| 32 : url_request_context_(url_request_context), | |
| 33 database_(database.Pass()), | |
| 34 database_ready_(false), | |
| 35 weak_ptr_factory_(this) { | |
| 36 database_->Init(database_dir, base::Bind(&ImageManagerImpl::OnDatabaseInit, | |
| 37 weak_ptr_factory_.GetWeakPtr())); | |
| 38 } | |
| 39 | |
| 40 ImageManagerImpl::~ImageManagerImpl() {} | |
| 41 | |
| 42 ImageManagerImpl::ImageRequest::ImageRequest() : fetcher(NULL) {} | |
| 43 | |
| 44 ImageManagerImpl::ImageRequest::ImageRequest(chrome::BitmapFetcher* f) | |
| 45 : fetcher(f) {} | |
| 46 | |
| 47 ImageManagerImpl::ImageRequest::~ImageRequest() { delete fetcher; } | |
| 48 | |
| 49 void ImageManagerImpl::Initialize(const SuggestionsProfile& suggestions) { | |
| 50 image_url_map_.clear(); | |
| 51 for (int i = 0; i < suggestions.suggestions_size(); ++i) { | |
| 52 const ChromeSuggestion& suggestion = suggestions.suggestions(i); | |
| 53 if (suggestion.has_thumbnail()) { | |
| 54 image_url_map_[GURL(suggestion.url())] = GURL(suggestion.thumbnail()); | |
| 55 } | |
| 56 } | |
| 57 } | |
| 58 | |
| 59 void ImageManagerImpl::GetImageForURL( | |
| 60 const GURL& url, | |
| 61 base::Callback<void(const GURL&, const SkBitmap*)> callback) { | |
| 62 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 63 // If |url| is not found in |image_url_map_|, then invoke |callback| with | |
| 64 // NULL since there is no associated image for this |url|. | |
| 65 GURL image_url; | |
| 66 if (!GetImageURL(url, &image_url)) { | |
| 67 callback.Run(url, NULL); | |
| 68 return; | |
| 69 } | |
| 70 | |
| 71 // |database_| can be NULL if something went wrong in initialization. | |
| 72 if (database_.get() && !database_ready_) { | |
| 73 // Once database is initialized, it will serve pending requests from either | |
| 74 // cache or network. | |
| 75 QueueCacheRequest(url, image_url, callback); | |
| 76 return; | |
| 77 } | |
| 78 | |
| 79 ServeFromCacheOrNetwork(url, image_url, callback); | |
| 80 } | |
| 81 | |
| 82 bool ImageManagerImpl::GetImageURL(const GURL& url, GURL* image_url) { | |
| 83 std::map<GURL, GURL>::iterator it = image_url_map_.find(url); | |
| 84 if (it == image_url_map_.end()) return false; // Not found. | |
| 85 *image_url = it->second; | |
| 86 return true; | |
| 87 } | |
| 88 | |
| 89 void ImageManagerImpl::QueueCacheRequest( | |
| 90 const GURL& url, const GURL& image_url, | |
| 91 base::Callback<void(const GURL&, const SkBitmap*)> callback) { | |
| 92 // To be served when the database has loaded. | |
| 93 ImageRequestMap::iterator it = pending_cache_requests_.find(url); | |
| 94 if (it == pending_cache_requests_.end()) { | |
| 95 ImageRequest request(NULL); | |
| 96 request.url = url; | |
| 97 request.image_url = image_url; | |
| 98 request.callbacks.push_back(callback); | |
| 99 pending_cache_requests_[url].swap(&request); | |
| 100 } else { | |
| 101 // Request already queued for this url. | |
| 102 it->second.callbacks.push_back(callback); | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 void ImageManagerImpl::ServeFromCacheOrNetwork( | |
| 107 const GURL& url, const GURL& image_url, | |
| 108 base::Callback<void(const GURL&, const SkBitmap*)> callback) { | |
| 109 // If there is a image available in memory, return it. | |
| 110 if (!ServeFromCache(url, callback)) { | |
| 111 StartOrQueueNetworkRequest(url, image_url, callback); | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 bool ImageManagerImpl::ServeFromCache( | |
| 116 const GURL& url, | |
| 117 base::Callback<void(const GURL&, const SkBitmap*)> callback) { | |
| 118 SkBitmap* bitmap = GetBitmapFromCache(url); | |
| 119 if (bitmap) { | |
| 120 callback.Run(url, bitmap); | |
| 121 return true; | |
| 122 } | |
| 123 return false; | |
| 124 } | |
| 125 | |
| 126 SkBitmap* ImageManagerImpl::GetBitmapFromCache(const GURL& url) { | |
| 127 ImageMap::iterator image_iter = image_map_.find(url.spec()); | |
| 128 if (image_iter != image_map_.end()) { | |
| 129 return &image_iter->second; | |
| 130 } | |
| 131 return NULL; | |
| 132 } | |
| 133 | |
| 134 void ImageManagerImpl::StartOrQueueNetworkRequest( | |
| 135 const GURL& url, const GURL& image_url, | |
| 136 base::Callback<void(const GURL&, const SkBitmap*)> callback) { | |
| 137 // Before starting to fetch the image. Look for a request in progress for | |
| 138 // |image_url|, and queue if appropriate. | |
| 139 ImageRequestMap::iterator it = pending_net_requests_.find(image_url); | |
| 140 if (it == pending_net_requests_.end()) { | |
| 141 // |image_url| is not being fetched, so create a request and initiate | |
| 142 // the fetch. | |
| 143 ImageRequest request(new chrome::BitmapFetcher(image_url, this)); | |
| 144 request.url = url; | |
| 145 request.callbacks.push_back(callback); | |
| 146 request.fetcher->Start( | |
| 147 url_request_context_, std::string(), | |
| 148 net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE, | |
| 149 net::LOAD_NORMAL); | |
| 150 pending_net_requests_[image_url].swap(&request); | |
| 151 } else { | |
| 152 // Request in progress. Register as an interested callback. | |
| 153 it->second.callbacks.push_back(callback); | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 void ImageManagerImpl::OnFetchComplete(const GURL image_url, | |
| 158 const SkBitmap* bitmap) { | |
| 159 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 160 | |
| 161 ImageRequestMap::iterator image_iter = pending_net_requests_.find(image_url); | |
| 162 DCHECK(image_iter != pending_net_requests_.end()); | |
| 163 | |
| 164 ImageRequest* request = &image_iter->second; | |
| 165 | |
| 166 // Here |bitmap| could be NULL or a pointer to a bitmap which is owned by the | |
| 167 // BitmapFetcher and which ceases to exist after this function. Pass the | |
| 168 // un-owned pointer to the registered callbacks. | |
| 169 for (CallbackVector::iterator callback_iter = request->callbacks.begin(); | |
| 170 callback_iter != request->callbacks.end(); ++callback_iter) { | |
| 171 callback_iter->Run(request->url, bitmap); | |
| 172 } | |
| 173 | |
| 174 // Save the bitmap to the in-memory model as well as the database, because it | |
| 175 // is now the freshest representation of the image. | |
| 176 // TODO(mathp): Handle null (no image found), possible deletion in DB. | |
| 177 if (bitmap) SaveImage(request->url, *bitmap); | |
| 178 | |
| 179 // Erase the completed ImageRequest. | |
| 180 pending_net_requests_.erase(image_iter); | |
| 181 } | |
| 182 | |
| 183 void ImageManagerImpl::SaveImage(const GURL& url, const SkBitmap& bitmap) { | |
| 184 // Update the image map. | |
| 185 image_map_.insert(std::make_pair(url.spec(), bitmap)); | |
| 186 | |
| 187 if (!database_ready_) return; | |
| 188 | |
| 189 // Attempt to save a JPEG representation to the database. If not successful, | |
| 190 // the fetched bitmap will still be inserted in the cache, above. | |
| 191 std::vector<unsigned char> encoded_data; | |
| 192 if (EncodeImage(bitmap, &encoded_data)) { | |
| 193 // Save the resulting bitmap to the database. | |
| 194 ImageData data; | |
| 195 data.set_url(url.spec()); | |
| 196 data.set_data(std::string(encoded_data.begin(), encoded_data.end())); | |
| 197 scoped_ptr<ProtoDatabase<ImageData>::KeyEntryVector> entries_to_save( | |
| 198 new ProtoDatabase<ImageData>::KeyEntryVector()); | |
| 199 scoped_ptr<std::vector<std::string> > keys_to_remove( | |
| 200 new std::vector<std::string>()); | |
| 201 entries_to_save->push_back(std::make_pair(data.url(), data)); | |
| 202 database_->UpdateEntries(entries_to_save.Pass(), keys_to_remove.Pass(), | |
| 203 base::Bind(&ImageManagerImpl::OnDatabaseSave, | |
| 204 weak_ptr_factory_.GetWeakPtr())); | |
| 205 } | |
| 206 } | |
| 207 | |
| 208 void ImageManagerImpl::OnDatabaseInit(bool success) { | |
| 209 if (!success) { | |
| 210 DVLOG(1) << "Image database init failed."; | |
| 211 database_.reset(); | |
| 212 ServePendingCacheRequests(); | |
| 213 return; | |
| 214 } | |
| 215 database_->LoadEntries(base::Bind(&ImageManagerImpl::OnDatabaseLoad, | |
| 216 weak_ptr_factory_.GetWeakPtr())); | |
| 217 } | |
| 218 | |
| 219 void ImageManagerImpl::OnDatabaseLoad(bool success, | |
| 220 scoped_ptr<ImageDataVector> entries) { | |
| 221 if (!success) { | |
| 222 DVLOG(1) << "Image database load failed."; | |
| 223 database_.reset(); | |
| 224 ServePendingCacheRequests(); | |
| 225 return; | |
| 226 } | |
| 227 database_ready_ = true; | |
| 228 | |
| 229 LoadEntriesInCache(entries.Pass()); | |
| 230 ServePendingCacheRequests(); | |
| 231 } | |
| 232 | |
| 233 void ImageManagerImpl::OnDatabaseSave(bool success) { | |
| 234 if (!success) { | |
| 235 DVLOG(1) << "Image database save failed."; | |
| 236 database_.reset(); | |
| 237 database_ready_ = false; | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 void ImageManagerImpl::LoadEntriesInCache(scoped_ptr<ImageDataVector> entries) { | |
| 242 for (ImageDataVector::iterator it = entries->begin(); it != entries->end(); | |
| 243 ++it) { | |
| 244 std::vector<unsigned char> encoded_data(it->data().begin(), | |
| 245 it->data().end()); | |
| 246 | |
| 247 scoped_ptr<SkBitmap> bitmap(DecodeImage(encoded_data)); | |
| 248 if (bitmap.get()) { | |
| 249 image_map_.insert(std::make_pair(it->url(), *bitmap)); | |
| 250 } | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 void ImageManagerImpl::ServePendingCacheRequests() { | |
| 255 for (ImageRequestMap::iterator it = pending_cache_requests_.begin(); | |
| 256 it != pending_cache_requests_.end(); ++it) { | |
| 257 const ImageRequest& request = it->second; | |
| 258 for (CallbackVector::const_iterator callback_it = request.callbacks.begin(); | |
| 259 callback_it != request.callbacks.end(); ++callback_it) { | |
| 260 ServeFromCacheOrNetwork(request.url, request.image_url, *callback_it); | |
| 261 } | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 // static | |
| 266 bool ImageManagerImpl::EncodeImage(const SkBitmap& bitmap, | |
| 267 std::vector<unsigned char>* dest) { | |
| 268 SkAutoLockPixels bitmap_lock(bitmap); | |
| 269 if (!bitmap.readyToDraw() || bitmap.isNull()) { | |
| 270 return false; | |
| 271 } | |
| 272 return gfx::JPEGCodec::Encode( | |
| 273 reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)), | |
| 274 gfx::JPEGCodec::FORMAT_SkBitmap, bitmap.width(), bitmap.height(), | |
| 275 bitmap.width() * bitmap.bytesPerPixel(), 100, dest); | |
| 276 } | |
| 277 | |
| 278 } // namespace suggestions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 543753002:
[Suggestions] Move ImageManager to the component (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master