Restrict salient image size before storing

components/enhanced_bookmarks/bookmark_image_service.cc

 // 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/enhanced_bookmarks/bookmark_image_service.h"
 
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 172 matching lines @@
     RetrieveImageFromStore(page_url,
                            base::Bind(&BookmarkImageService::FetchCallback,
                                       base::Unretained(this),
                                       page_url,
                                       callback));
   }
 }
 
 void BookmarkImageService::ProcessNewImage(const GURL& page_url,
                                            bool update_bookmarks,
-                                           const gfx::Image& image,
-                                           const GURL& image_url) {
+                                           const GURL& image_url,
+                                           const gfx::Image& image) {
   DCHECK(CalledOnValidThread());
   PostTaskToStoreImage(image, image_url, page_url);
   if (update_bookmarks && image_url.is_valid()) {
     const BookmarkNode* bookmark =
         enhanced_bookmark_model_->bookmark_model()
             ->GetMostRecentlyAddedUserNodeForURL(page_url);
     if (bookmark) {
       const gfx::Size& size = image.Size();
       bool result = enhanced_bookmark_model_->SetOriginalImage(
           bookmark, image_url, size.width(), size.height());
       DCHECK(result);
     }
   }
 }
 
 bool BookmarkImageService::IsPageUrlInProgress(const GURL& page_url) {
   DCHECK(CalledOnValidThread());
   return in_progress_page_urls_.find(page_url) != in_progress_page_urls_.end();
 }
 
-ImageRecord BookmarkImageService::StoreImage(const gfx::Image& image,
-                                             const GURL& image_url,
-                                             const GURL& page_url) {
-  ImageRecord image_info(image, image_url, SK_ColorBLACK);
-  if (!image.IsEmpty()) {
-    image_info.dominant_color = DominantColorForImage(image);
+ImageRecord BookmarkImageService::ResizeAndStoreImage(const gfx::Image& image,
+                                                      const GURL& image_url,
+                                                      const GURL& page_url) {
+  gfx::Image resized_image = ResizeImage(image);
+  ImageRecord image_info(resized_image, image_url, SK_ColorBLACK);
+  if (!resized_image.IsEmpty()) {
+    image_info.dominant_color = DominantColorForImage(resized_image);
     // TODO(lpromero): this should be saved all the time, even when there is an
     // empty image. http://crbug.com/451450
     pool_->PostNamedSequencedWorkerTask(
         kSequenceToken, FROM_HERE,
         base::Bind(&ImageStore::Insert, base::Unretained(store_.get()),
                    page_url, image_info));
   }
   return image_info;
 }
 
 void BookmarkImageService::PostTaskToStoreImage(const gfx::Image& image,
                                                 const GURL& image_url,
                                                 const GURL& page_url) {
   DCHECK(CalledOnValidThread());
 
   base::Callback<ImageRecord(void)> task =
-      base::Bind(&BookmarkImageService::StoreImage, base::Unretained(this),
-                 image, image_url, page_url);
+      base::Bind(&BookmarkImageService::ResizeAndStoreImage,
+                 base::Unretained(this), image, image_url, page_url);
   base::Callback<void(const ImageRecord&)> reply =
       base::Bind(&BookmarkImageService::OnStoreImagePosted,
                  base::Unretained(this), page_url);
 
   base::PostTaskAndReplyWithResult(pool_.get(), FROM_HERE, task, reply);
 }
 
 void BookmarkImageService::OnStoreImagePosted(const GURL& page_url,
                                               const ImageRecord& image) {
   DCHECK(CalledOnValidThread());
@@ skipping 110 matching lines @@
     const BookmarkNode* node) {
 }
 
 void BookmarkImageService::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   ClearAll();
 }
 
 }  // namespace enhanced_bookmarks