| 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 "components/enhanced_bookmarks/bookmark_image_service.h" | |
| 6 | |
| 7 #include "base/single_thread_task_runner.h" | |
| 8 #include "base/task_runner_util.h" | |
| 9 #include "base/thread_task_runner_handle.h" | |
| 10 #include "base/threading/sequenced_worker_pool.h" | |
| 11 #include "components/bookmarks/browser/bookmark_model.h" | |
| 12 #include "components/bookmarks/browser/bookmark_model_observer.h" | |
| 13 #include "components/enhanced_bookmarks/enhanced_bookmark_model.h" | |
| 14 #include "components/enhanced_bookmarks/enhanced_bookmark_utils.h" | |
| 15 #include "components/enhanced_bookmarks/image_store_util.h" | |
| 16 #include "components/enhanced_bookmarks/persistent_image_store.h" | |
| 17 | |
| 18 using bookmarks::BookmarkModel; | |
| 19 using bookmarks::BookmarkNode; | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 const char kSequenceToken[] = "BookmarkImagesSequenceToken"; | |
| 24 | |
| 25 void ConstructPersistentImageStore(PersistentImageStore* store, | |
| 26 const base::FilePath& path) { | |
| 27 DCHECK(store); | |
| 28 new (store) PersistentImageStore(path); | |
| 29 } | |
| 30 | |
| 31 void DeleteImageStore(ImageStore* store) { | |
| 32 DCHECK(store); | |
| 33 delete store; | |
| 34 } | |
| 35 | |
| 36 void RetrieveImageFromStoreRelay( | |
| 37 ImageStore* store, | |
| 38 const GURL& page_url, | |
| 39 enhanced_bookmarks::BookmarkImageService::ImageCallback callback, | |
| 40 scoped_refptr<base::SingleThreadTaskRunner> origin_loop) { | |
| 41 origin_loop->PostTask(FROM_HERE, base::Bind(callback, store->Get(page_url))); | |
| 42 } | |
| 43 | |
| 44 } // namespace | |
| 45 | |
| 46 namespace enhanced_bookmarks { | |
| 47 BookmarkImageService::BookmarkImageService( | |
| 48 scoped_ptr<ImageStore> store, | |
| 49 EnhancedBookmarkModel* enhanced_bookmark_model, | |
| 50 scoped_refptr<base::SequencedWorkerPool> pool) | |
| 51 : enhanced_bookmark_model_(enhanced_bookmark_model), | |
| 52 store_(store.Pass()), | |
| 53 pool_(pool) { | |
| 54 DCHECK(CalledOnValidThread()); | |
| 55 enhanced_bookmark_model_->bookmark_model()->AddObserver(this); | |
| 56 } | |
| 57 | |
| 58 BookmarkImageService::BookmarkImageService( | |
| 59 const base::FilePath& path, | |
| 60 EnhancedBookmarkModel* enhanced_bookmark_model, | |
| 61 scoped_refptr<base::SequencedWorkerPool> pool) | |
| 62 : enhanced_bookmark_model_(enhanced_bookmark_model), pool_(pool) { | |
| 63 DCHECK(CalledOnValidThread()); | |
| 64 // PersistentImageStore has to be constructed in the thread it will be used, | |
| 65 // so we are posting the construction to the thread. However, we first | |
| 66 // allocate memory and keep here. The reason is that, before | |
| 67 // PersistentImageStore construction is done, it's possible that | |
| 68 // another member function, that posts store_ to the thread, is called. | |
| 69 // Although the construction might not be finished yet, we still want to post | |
| 70 // the task since it's guaranteed to be constructed by the time it is used, by | |
| 71 // the sequential thread task pool. | |
| 72 // | |
| 73 // Other alternatives: | |
| 74 // - Using a lock or WaitableEvent for PersistentImageStore construction. | |
| 75 // But waiting on UI thread is discouraged. | |
| 76 // - Posting the current BookmarkImageService instance instead of store_. | |
| 77 // But this will require using a weak pointer and can potentially block | |
| 78 // destroying BookmarkImageService. | |
| 79 PersistentImageStore* store = | |
| 80 (PersistentImageStore*)::operator new(sizeof(PersistentImageStore)); | |
| 81 store_.reset(store); | |
| 82 pool_->PostNamedSequencedWorkerTask( | |
| 83 kSequenceToken, | |
| 84 FROM_HERE, | |
| 85 base::Bind(&ConstructPersistentImageStore, store, path)); | |
| 86 } | |
| 87 | |
| 88 BookmarkImageService::~BookmarkImageService() { | |
| 89 DCHECK(CalledOnValidThread()); | |
| 90 pool_->PostNamedSequencedWorkerTask( | |
| 91 kSequenceToken, | |
| 92 FROM_HERE, | |
| 93 base::Bind(&DeleteImageStore, store_.release())); | |
| 94 } | |
| 95 | |
| 96 void BookmarkImageService::Shutdown() { | |
| 97 DCHECK(CalledOnValidThread()); | |
| 98 enhanced_bookmark_model_->bookmark_model()->RemoveObserver(this); | |
| 99 enhanced_bookmark_model_ = NULL; | |
| 100 } | |
| 101 | |
| 102 void BookmarkImageService::SalientImageForUrl(const GURL& page_url, | |
| 103 ImageCallback callback) { | |
| 104 DCHECK(CalledOnValidThread()); | |
| 105 SalientImageForUrl(page_url, true, callback); | |
| 106 } | |
| 107 | |
| 108 void BookmarkImageService::RetrieveImageFromStore(const GURL& page_url, | |
| 109 ImageCallback callback) { | |
| 110 DCHECK(CalledOnValidThread()); | |
| 111 pool_->PostSequencedWorkerTaskWithShutdownBehavior( | |
| 112 pool_->GetNamedSequenceToken(kSequenceToken), | |
| 113 FROM_HERE, | |
| 114 base::Bind(&RetrieveImageFromStoreRelay, | |
| 115 base::Unretained(store_.get()), | |
| 116 page_url, | |
| 117 callback, | |
| 118 base::ThreadTaskRunnerHandle::Get()), | |
| 119 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); | |
| 120 } | |
| 121 | |
| 122 void BookmarkImageService::RetrieveSalientImageForPageUrl( | |
| 123 const GURL& page_url) { | |
| 124 DCHECK(CalledOnValidThread()); | |
| 125 if (IsPageUrlInProgress(page_url)) | |
| 126 return; // A request for this URL is already in progress. | |
| 127 | |
| 128 in_progress_page_urls_.insert(page_url); | |
| 129 | |
| 130 const BookmarkNode* bookmark = | |
| 131 enhanced_bookmark_model_->bookmark_model() | |
| 132 ->GetMostRecentlyAddedUserNodeForURL(page_url); | |
| 133 GURL image_url; | |
| 134 if (bookmark) { | |
| 135 int width; | |
| 136 int height; | |
| 137 enhanced_bookmark_model_->GetThumbnailImage( | |
| 138 bookmark, &image_url, &width, &height); | |
| 139 } | |
| 140 | |
| 141 RetrieveSalientImage( | |
| 142 page_url, | |
| 143 image_url, | |
| 144 "", | |
| 145 net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE, | |
| 146 false); | |
| 147 } | |
| 148 | |
| 149 void BookmarkImageService::FetchCallback(const GURL& page_url, | |
| 150 ImageCallback original_callback, | |
| 151 scoped_refptr<ImageRecord> record) { | |
| 152 DCHECK(CalledOnValidThread()); | |
| 153 if (!record->image->IsEmpty() || !record->url.is_empty()) { | |
| 154 // Either the record was in the store or there is no image in the store, but | |
| 155 // an URL for a record is present, indicating that a previous attempt to | |
| 156 // download the image failed. Just return the record. | |
| 157 original_callback.Run(record); | |
| 158 } else { | |
| 159 // There is no record in the store, and no previous attempts to retrieve | |
| 160 // one. Start a request to retrieve a salient image if there is an image | |
| 161 // url set on a bookmark, and then enqueue the request for the record to | |
| 162 // be triggered when the retrieval is finished. | |
| 163 RetrieveSalientImageForPageUrl(page_url); | |
| 164 SalientImageForUrl(page_url, false, original_callback); | |
| 165 } | |
| 166 } | |
| 167 | |
| 168 void BookmarkImageService::SalientImageForUrl(const GURL& page_url, | |
| 169 bool fetch_from_web, | |
| 170 ImageCallback callback) { | |
| 171 DCHECK(CalledOnValidThread()); | |
| 172 | |
| 173 // If the request is done while the image is currently being retrieved, just | |
| 174 // store the appropriate callbacks to call once the image is retrieved. | |
| 175 if (IsPageUrlInProgress(page_url)) { | |
| 176 callbacks_[page_url].push_back(callback); | |
| 177 return; | |
| 178 } | |
| 179 | |
| 180 if (!fetch_from_web) { | |
| 181 RetrieveImageFromStore(page_url, callback); | |
| 182 } else { | |
| 183 RetrieveImageFromStore(page_url, | |
| 184 base::Bind(&BookmarkImageService::FetchCallback, | |
| 185 base::Unretained(this), | |
| 186 page_url, | |
| 187 callback)); | |
| 188 } | |
| 189 } | |
| 190 | |
| 191 void BookmarkImageService::ProcessNewImage(const GURL& page_url, | |
| 192 bool update_bookmarks, | |
| 193 const GURL& image_url, | |
| 194 scoped_ptr<gfx::Image> image) { | |
| 195 DCHECK(CalledOnValidThread()); | |
| 196 | |
| 197 gfx::Size size = image->Size(); | |
| 198 PostTaskToStoreImage(image.Pass(), image_url, page_url); | |
| 199 | |
| 200 if (update_bookmarks && image_url.is_valid()) { | |
| 201 const BookmarkNode* bookmark = | |
| 202 enhanced_bookmark_model_->bookmark_model() | |
| 203 ->GetMostRecentlyAddedUserNodeForURL(page_url); | |
| 204 if (bookmark) { | |
| 205 | |
| 206 bool result = enhanced_bookmark_model_->SetOriginalImage( | |
| 207 bookmark, image_url, size.width(), size.height()); | |
| 208 DCHECK(result); | |
| 209 } | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 bool BookmarkImageService::IsPageUrlInProgress(const GURL& page_url) { | |
| 214 DCHECK(CalledOnValidThread()); | |
| 215 return in_progress_page_urls_.find(page_url) != in_progress_page_urls_.end(); | |
| 216 } | |
| 217 | |
| 218 scoped_refptr<ImageRecord> BookmarkImageService::ResizeAndStoreImage( | |
| 219 scoped_refptr<ImageRecord> image_info, | |
| 220 const GURL& page_url) { | |
| 221 | |
| 222 if (!image_info->image->IsEmpty()) { | |
| 223 image_info->image = ResizeImage(*image_info->image); | |
| 224 image_info->dominant_color = DominantColorForImage(*image_info->image); | |
| 225 // TODO(lpromero): this should be saved all the time, even when there is an | |
| 226 // empty image. http://crbug.com/451450 | |
| 227 pool_->PostNamedSequencedWorkerTask( | |
| 228 kSequenceToken, FROM_HERE, | |
| 229 base::Bind(&ImageStore::Insert, base::Unretained(store_.get()), | |
| 230 page_url, image_info)); | |
| 231 } | |
| 232 | |
| 233 return image_info; | |
| 234 } | |
| 235 | |
| 236 void BookmarkImageService::PostTaskToStoreImage( | |
| 237 scoped_ptr<gfx::Image> image, | |
| 238 const GURL& image_url, | |
| 239 const GURL& page_url) { | |
| 240 DCHECK(CalledOnValidThread()); | |
| 241 | |
| 242 scoped_refptr<ImageRecord> image_info( | |
| 243 new ImageRecord(image.Pass(), image_url)); | |
| 244 | |
| 245 // TODO ensure image thread safety. | |
| 246 base::Callback<scoped_refptr<ImageRecord>(void)> task = | |
| 247 base::Bind(&BookmarkImageService::ResizeAndStoreImage, | |
| 248 base::Unretained(this), image_info, page_url); | |
| 249 base::Callback<void(scoped_refptr<ImageRecord>)> reply = | |
| 250 base::Bind(&BookmarkImageService::OnStoreImagePosted, | |
| 251 base::Unretained(this), page_url); | |
| 252 | |
| 253 base::PostTaskAndReplyWithResult(pool_.get(), FROM_HERE, task, reply); | |
| 254 } | |
| 255 | |
| 256 void BookmarkImageService::OnStoreImagePosted( | |
| 257 const GURL& page_url, | |
| 258 scoped_refptr<ImageRecord> image) { | |
| 259 DCHECK(CalledOnValidThread()); | |
| 260 in_progress_page_urls_.erase(page_url); | |
| 261 ProcessRequests(page_url, image); | |
| 262 } | |
| 263 | |
| 264 void BookmarkImageService::RemoveImageForUrl(const GURL& page_url) { | |
| 265 DCHECK(CalledOnValidThread()); | |
| 266 pool_->PostNamedSequencedWorkerTask( | |
| 267 kSequenceToken, | |
| 268 FROM_HERE, | |
| 269 base::Bind(&ImageStore::Erase, base::Unretained(store_.get()), page_url)); | |
| 270 in_progress_page_urls_.erase(page_url); | |
| 271 ProcessRequests(page_url, scoped_refptr<ImageRecord>(new ImageRecord())); | |
| 272 } | |
| 273 | |
| 274 void BookmarkImageService::ChangeImageURL(const GURL& from, const GURL& to) { | |
| 275 DCHECK(CalledOnValidThread()); | |
| 276 pool_->PostNamedSequencedWorkerTask(kSequenceToken, | |
| 277 FROM_HERE, | |
| 278 base::Bind(&ImageStore::ChangeImageURL, | |
| 279 base::Unretained(store_.get()), | |
| 280 from, | |
| 281 to)); | |
| 282 in_progress_page_urls_.erase(from); | |
| 283 ProcessRequests(from, scoped_refptr<ImageRecord>(new ImageRecord())); | |
| 284 } | |
| 285 | |
| 286 void BookmarkImageService::ClearAll() { | |
| 287 DCHECK(CalledOnValidThread()); | |
| 288 // Clears and executes callbacks. | |
| 289 pool_->PostNamedSequencedWorkerTask( | |
| 290 kSequenceToken, | |
| 291 FROM_HERE, | |
| 292 base::Bind(&ImageStore::ClearAll, base::Unretained(store_.get()))); | |
| 293 | |
| 294 for (std::map<const GURL, std::vector<ImageCallback>>::const_iterator it = | |
| 295 callbacks_.begin(); | |
| 296 it != callbacks_.end(); ++it) { | |
| 297 ProcessRequests(it->first, scoped_refptr<ImageRecord>(new ImageRecord())); | |
| 298 } | |
| 299 | |
| 300 in_progress_page_urls_.erase(in_progress_page_urls_.begin(), | |
| 301 in_progress_page_urls_.end()); | |
| 302 } | |
| 303 | |
| 304 void BookmarkImageService::ProcessRequests(const GURL& page_url, | |
| 305 scoped_refptr<ImageRecord> record) { | |
| 306 DCHECK(CalledOnValidThread()); | |
| 307 | |
| 308 std::vector<ImageCallback> callbacks = callbacks_[page_url]; | |
| 309 for (std::vector<ImageCallback>::const_iterator it = callbacks.begin(); | |
| 310 it != callbacks.end(); ++it) { | |
| 311 it->Run(record); | |
| 312 } | |
| 313 | |
| 314 callbacks_.erase(page_url); | |
| 315 } | |
| 316 | |
| 317 // BookmarkModelObserver methods. | |
| 318 | |
| 319 void BookmarkImageService::BookmarkNodeRemoved( | |
| 320 BookmarkModel* model, | |
| 321 const BookmarkNode* parent, | |
| 322 int old_index, | |
| 323 const BookmarkNode* node, | |
| 324 const std::set<GURL>& removed_urls) { | |
| 325 DCHECK(CalledOnValidThread()); | |
| 326 for (std::set<GURL>::const_iterator iter = removed_urls.begin(); | |
| 327 iter != removed_urls.end(); | |
| 328 ++iter) { | |
| 329 RemoveImageForUrl(*iter); | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 void BookmarkImageService::BookmarkModelLoaded(BookmarkModel* model, | |
| 334 bool ids_reassigned) { | |
| 335 } | |
| 336 | |
| 337 void BookmarkImageService::BookmarkNodeMoved(BookmarkModel* model, | |
| 338 const BookmarkNode* old_parent, | |
| 339 int old_index, | |
| 340 const BookmarkNode* new_parent, | |
| 341 int new_index) { | |
| 342 } | |
| 343 | |
| 344 void BookmarkImageService::BookmarkNodeAdded(BookmarkModel* model, | |
| 345 const BookmarkNode* parent, | |
| 346 int index) { | |
| 347 } | |
| 348 | |
| 349 void BookmarkImageService::OnWillChangeBookmarkNode(BookmarkModel* model, | |
| 350 const BookmarkNode* node) { | |
| 351 DCHECK(CalledOnValidThread()); | |
| 352 if (node->is_url()) | |
| 353 previous_url_ = node->url(); | |
| 354 } | |
| 355 | |
| 356 void BookmarkImageService::BookmarkNodeChanged(BookmarkModel* model, | |
| 357 const BookmarkNode* node) { | |
| 358 DCHECK(CalledOnValidThread()); | |
| 359 if (node->is_url() && previous_url_ != node->url()) | |
| 360 ChangeImageURL(previous_url_, node->url()); | |
| 361 } | |
| 362 | |
| 363 void BookmarkImageService::BookmarkNodeFaviconChanged( | |
| 364 BookmarkModel* model, | |
| 365 const BookmarkNode* node) { | |
| 366 } | |
| 367 | |
| 368 void BookmarkImageService::BookmarkNodeChildrenReordered( | |
| 369 BookmarkModel* model, | |
| 370 const BookmarkNode* node) { | |
| 371 } | |
| 372 | |
| 373 void BookmarkImageService::BookmarkAllUserNodesRemoved( | |
| 374 BookmarkModel* model, | |
| 375 const std::set<GURL>& removed_urls) { | |
| 376 ClearAll(); | |
| 377 } | |
| 378 | |
| 379 } // namespace enhanced_bookmarks | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1219713002:
Removed bookmark_image_service (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master