| // Copyright 2014 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/suggestions/image_manager.h" |
| |
| #include <memory> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/location.h" |
| #include "base/task_runner_util.h" |
| #include "base/task_scheduler/post_task.h" |
| #include "components/image_fetcher/core/image_fetcher.h" |
| #include "components/suggestions/image_encoder.h" |
| #include "net/traffic_annotation/network_traffic_annotation.h" |
| #include "ui/gfx/image/image.h" |
| |
| using leveldb_proto::ProtoDatabase; |
| |
| namespace { |
| |
| // Statistics are logged to UMA with this string as part of histogram name. They |
| // can all be found under LevelDB.*.ImageManager. Changing this needs to |
| // synchronize with histograms.xml, AND will also become incompatible with older |
| // browsers still reporting the previous values. |
| const char kDatabaseUMAClientName[] = "ImageManager"; |
| |
| std::unique_ptr<SkBitmap> DecodeImage( |
| scoped_refptr<base::RefCountedMemory> encoded_data) { |
| return suggestions::DecodeJPEGToSkBitmap(encoded_data->front(), |
| encoded_data->size()); |
| } |
| |
| // Wraps an ImageManager callback so that it can be used with the ImageFetcher. |
| void WrapCallback( |
| const suggestions::ImageManager::ImageCallback& wrapped_callback, |
| const std::string& url, |
| const gfx::Image& image, |
| const image_fetcher::RequestMetadata& metadata) { |
| wrapped_callback.Run(GURL(url), image); |
| } |
| |
| constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation = |
| net::DefineNetworkTrafficAnnotation("suggestions_image_manager", R"( |
| semantics { |
| sender: "Suggestions Service Thumbnail Fetch" |
| description: |
| "Retrieves thumbnails for site suggestions based on the user's " |
| "synced browsing history, for use e.g. on the New Tab page." |
| trigger: |
| "Triggered when a thumbnail for a suggestion is required, and no " |
| "local thumbnail is available." |
| data: "The URL for which to retrieve a thumbnail." |
| destination: GOOGLE_OWNED_SERVICE |
| } |
| policy { |
| cookies_allowed: NO |
| setting: |
| "Users can disable this feature by signing out of Chrome, or " |
| "disabling Sync or History Sync in Chrome settings under 'Advanced " |
| "sync settings...'. The feature is enabled by default." |
| chrome_policy { |
| SyncDisabled { |
| policy_options {mode: MANDATORY} |
| SyncDisabled: true |
| } |
| } |
| chrome_policy { |
| SigninAllowed { |
| policy_options {mode: MANDATORY} |
| SigninAllowed: false |
| } |
| } |
| })"); |
| |
| } // namespace |
| |
| namespace suggestions { |
| |
| ImageManager::ImageManager() : weak_ptr_factory_(this) {} |
| |
| ImageManager::ImageManager( |
| std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher, |
| std::unique_ptr<ProtoDatabase<ImageData>> database, |
| const base::FilePath& database_dir) |
| : image_fetcher_(std::move(image_fetcher)), |
| database_(std::move(database)), |
| background_task_runner_(base::CreateSequencedTaskRunnerWithTraits( |
| {base::TaskPriority::USER_VISIBLE})), |
| database_ready_(false), |
| weak_ptr_factory_(this) { |
| image_fetcher_->SetImageFetcherDelegate(this); |
| database_->Init(kDatabaseUMAClientName, database_dir, |
| leveldb_proto::CreateSimpleOptions(), |
| base::Bind(&ImageManager::OnDatabaseInit, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| ImageManager::~ImageManager() {} |
| |
| ImageManager::ImageCacheRequest::ImageCacheRequest() {} |
| |
| ImageManager::ImageCacheRequest::ImageCacheRequest( |
| const ImageCacheRequest& other) = default; |
| |
| ImageManager::ImageCacheRequest::~ImageCacheRequest() {} |
| |
| void ImageManager::Initialize(const SuggestionsProfile& suggestions) { |
| image_url_map_.clear(); |
| for (int i = 0; i < suggestions.suggestions_size(); ++i) { |
| const ChromeSuggestion& suggestion = suggestions.suggestions(i); |
| if (suggestion.has_thumbnail()) { |
| image_url_map_[GURL(suggestion.url())] = GURL(suggestion.thumbnail()); |
| } |
| } |
| } |
| |
| void ImageManager::AddImageURL(const GURL& url, const GURL& image_url) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| image_url_map_[url] = image_url; |
| } |
| |
| void ImageManager::GetImageForURL(const GURL& url, ImageCallback callback) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| // If |url| is not found in |image_url_map_|, then invoke |callback| with |
| // NULL since there is no associated image for this |url|. |
| GURL image_url; |
| if (!GetImageURL(url, &image_url)) { |
| callback.Run(url, gfx::Image()); |
| return; |
| } |
| |
| // |database_| can be NULL if something went wrong in initialization. |
| if (database_.get() && !database_ready_) { |
| // Once database is initialized, it will serve pending requests from either |
| // cache or network. |
| QueueCacheRequest(url, image_url, callback); |
| return; |
| } |
| |
| ServeFromCacheOrNetwork(url, image_url, callback); |
| } |
| |
| void ImageManager::OnImageFetched(const std::string& url, |
| const gfx::Image& image) { |
| // |image| can be empty if image fetch was unsuccessful. |
| if (!image.IsEmpty()) |
| SaveImage(url, *image.ToSkBitmap()); |
| } |
| |
| bool ImageManager::GetImageURL(const GURL& url, GURL* image_url) { |
| DCHECK(image_url); |
| std::map<GURL, GURL>::iterator it = image_url_map_.find(url); |
| if (it == image_url_map_.end()) return false; // Not found. |
| *image_url = it->second; |
| return true; |
| } |
| |
| void ImageManager::QueueCacheRequest( |
| const GURL& url, const GURL& image_url, ImageCallback callback) { |
| // To be served when the database has loaded. |
| ImageCacheRequestMap::iterator it = pending_cache_requests_.find(url); |
| if (it == pending_cache_requests_.end()) { |
| ImageCacheRequest request; |
| request.url = url; |
| request.image_url = image_url; |
| request.callbacks.push_back(callback); |
| pending_cache_requests_[url] = request; |
| } else { |
| // Request already queued for this url. |
| it->second.callbacks.push_back(callback); |
| } |
| } |
| |
| void ImageManager::OnCacheImageDecoded( |
| const GURL& url, |
| const GURL& image_url, |
| const ImageCallback& callback, |
| std::unique_ptr<SkBitmap> bitmap) { |
| if (bitmap.get()) { |
| callback.Run(url, gfx::Image::CreateFrom1xBitmap(*bitmap)); |
| } else { |
| image_fetcher_->StartOrQueueNetworkRequest( |
| url.spec(), image_url, base::Bind(&WrapCallback, callback), |
| kTrafficAnnotation); |
| } |
| } |
| |
| scoped_refptr<base::RefCountedMemory> ImageManager::GetEncodedImageFromCache( |
| const GURL& url) { |
| ImageMap::iterator image_iter = image_map_.find(url.spec()); |
| if (image_iter != image_map_.end()) { |
| return image_iter->second; |
| } |
| return nullptr; |
| } |
| |
| void ImageManager::ServeFromCacheOrNetwork( |
| const GURL& url, |
| const GURL& image_url, |
| ImageCallback callback) { |
| scoped_refptr<base::RefCountedMemory> encoded_data = |
| GetEncodedImageFromCache(url); |
| if (encoded_data.get()) { |
| base::PostTaskAndReplyWithResult( |
| background_task_runner_.get(), FROM_HERE, |
| base::Bind(&DecodeImage, encoded_data), |
| base::Bind(&ImageManager::OnCacheImageDecoded, |
| weak_ptr_factory_.GetWeakPtr(), url, image_url, callback)); |
| } else { |
| image_fetcher_->StartOrQueueNetworkRequest( |
| url.spec(), image_url, base::Bind(&WrapCallback, callback), |
| kTrafficAnnotation); |
| } |
| } |
| |
| void ImageManager::SaveImage(const std::string& url, const SkBitmap& bitmap) { |
| scoped_refptr<base::RefCountedBytes> encoded_data( |
| new base::RefCountedBytes()); |
| // TODO(treib): Should encoding happen on the |background_task_runner_|? |
| // *De*coding happens there. |
| if (!EncodeSkBitmapToJPEG(bitmap, &encoded_data->data())) { |
| return; |
| } |
| |
| // Update the image map. |
| image_map_.insert({url, encoded_data}); |
| |
| if (!database_ready_) return; |
| |
| // Save the resulting bitmap to the database. |
| ImageData data; |
| data.set_url(url); |
| data.set_data(encoded_data->front(), encoded_data->size()); |
| std::unique_ptr<ProtoDatabase<ImageData>::KeyEntryVector> entries_to_save( |
| new ProtoDatabase<ImageData>::KeyEntryVector()); |
| std::unique_ptr<std::vector<std::string>> keys_to_remove( |
| new std::vector<std::string>()); |
| entries_to_save->push_back(std::make_pair(data.url(), data)); |
| database_->UpdateEntries(std::move(entries_to_save), |
| std::move(keys_to_remove), |
| base::Bind(&ImageManager::OnDatabaseSave, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void ImageManager::OnDatabaseInit(bool success) { |
| if (!success) { |
| DVLOG(1) << "Image database init failed."; |
| database_.reset(); |
| ServePendingCacheRequests(); |
| return; |
| } |
| database_->LoadEntries(base::Bind(&ImageManager::OnDatabaseLoad, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void ImageManager::OnDatabaseLoad(bool success, |
| std::unique_ptr<ImageDataVector> entries) { |
| if (!success) { |
| DVLOG(1) << "Image database load failed."; |
| database_.reset(); |
| ServePendingCacheRequests(); |
| return; |
| } |
| database_ready_ = true; |
| |
| LoadEntriesInCache(std::move(entries)); |
| ServePendingCacheRequests(); |
| } |
| |
| void ImageManager::OnDatabaseSave(bool success) { |
| if (!success) { |
| DVLOG(1) << "Image database save failed."; |
| database_.reset(); |
| database_ready_ = false; |
| } |
| } |
| |
| void ImageManager::LoadEntriesInCache( |
| std::unique_ptr<ImageDataVector> entries) { |
| for (ImageDataVector::iterator it = entries->begin(); it != entries->end(); |
| ++it) { |
| std::vector<unsigned char> encoded_data(it->data().begin(), |
| it->data().end()); |
| |
| image_map_.insert( |
| {it->url(), base::RefCountedBytes::TakeVector(&encoded_data)}); |
| } |
| } |
| |
| void ImageManager::ServePendingCacheRequests() { |
| for (ImageCacheRequestMap::iterator it = pending_cache_requests_.begin(); |
| it != pending_cache_requests_.end(); ++it) { |
| const ImageCacheRequest& request = it->second; |
| for (CallbackVector::const_iterator callback_it = request.callbacks.begin(); |
| callback_it != request.callbacks.end(); ++callback_it) { |
| ServeFromCacheOrNetwork(request.url, request.image_url, *callback_it); |
| } |
| } |
| } |
| |
| } // namespace suggestions |