Set version field when changes are made to enhanced bookmarks.

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/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
+#include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
 #include "components/enhanced_bookmarks/enhanced_bookmark_utils.h"
-#include "components/enhanced_bookmarks/metadata_accessor.h"
 #include "components/enhanced_bookmarks/persistent_image_store.h"
 
 namespace {
 
 const char kSequenceToken[] = "BookmarkImagesSequenceToken";
 
 void ConstructPersistentImageStore(PersistentImageStore* store,
                                    const base::FilePath& path) {
   DCHECK(store);
   new (store) PersistentImageStore(path);
@@ skipping 12 matching lines @@
   std::pair<gfx::Image, GURL> image_data = store->Get(page_url);
   origin_loop->PostTask(
       FROM_HERE, base::Bind(callback, image_data.first, image_data.second));
 }
 
 }  // namespace
 
 namespace enhanced_bookmarks {
 BookmarkImageService::BookmarkImageService(
     scoped_ptr<ImageStore> store,
-    BookmarkModel* bookmark_model,
+    EnhancedBookmarkModel* enhanced_bookmark_model,
     scoped_refptr<base::SequencedWorkerPool> pool)
-    : bookmark_model_(bookmark_model), store_(store.Pass()), pool_(pool) {
+    : enhanced_bookmark_model_(enhanced_bookmark_model),
+      store_(store.Pass()),
+      pool_(pool) {
   DCHECK(CalledOnValidThread());
-  bookmark_model_->AddObserver(this);
+  enhanced_bookmark_model_->bookmark_model()->AddObserver(this);
 }
 
 BookmarkImageService::BookmarkImageService(
     const base::FilePath& path,
-    BookmarkModel* bookmark_model,
+    EnhancedBookmarkModel* enhanced_bookmark_model,
     scoped_refptr<base::SequencedWorkerPool> pool)
-    : bookmark_model_(bookmark_model), pool_(pool) {
+    : enhanced_bookmark_model_(enhanced_bookmark_model), pool_(pool) {
   DCHECK(CalledOnValidThread());
   // PersistentImageStore has to be constructed in the thread it will be used,
   // so we are posting the construction to the thread.  However, we first
   // allocate memory and keep here. The reason is that, before
   // PersistentImageStore construction is done, it's possible that
   // another member function, that posts store_ to the thread, is called.
   // Although the construction might not be finished yet, we still want to post
   // the task since it's guaranteed to be constructed by the time it is used, by
   // the sequential thread task pool.
   //
   // Other alternatives:
   // - Using a lock or WaitableEvent for PersistentImageStore construction.
   //   But waiting on UI thread is discouraged.
   // - Posting the current BookmarkImageService instance instead of store_.
   //   But this will require using a weak pointer and can potentially block
   //   destroying BookmarkImageService.
   PersistentImageStore* store =
       (PersistentImageStore*)::operator new(sizeof(PersistentImageStore));
   store_.reset(store);
   pool_->PostNamedSequencedWorkerTask(
       kSequenceToken,
       FROM_HERE,
       base::Bind(&ConstructPersistentImageStore, store, path));
 }
 
 BookmarkImageService::~BookmarkImageService() {
   DCHECK(CalledOnValidThread());
-  bookmark_model_->RemoveObserver(this);
+  enhanced_bookmark_model_->bookmark_model()->RemoveObserver(this);
   pool_->PostNamedSequencedWorkerTask(
       kSequenceToken,
       FROM_HERE,
       base::Bind(&DeleteImageStore, store_.release()));
 }
 
 void BookmarkImageService::SalientImageForUrl(const GURL& page_url,
                                               Callback callback) {
   DCHECK(CalledOnValidThread());
   SalientImageForUrl(page_url, true, callback);
@@ skipping 16 matching lines @@
 
 void BookmarkImageService::RetrieveSalientImageForPageUrl(
     const GURL& page_url) {
   DCHECK(CalledOnValidThread());
   if (IsPageUrlInProgress(page_url))
     return;  // A request for this URL is already in progress.
 
   in_progress_page_urls_.insert(page_url);
 
   const BookmarkNode* bookmark =
-      bookmark_model_->GetMostRecentlyAddedUserNodeForURL(page_url);
+      enhanced_bookmark_model_->bookmark_model()
+          ->GetMostRecentlyAddedUserNodeForURL(page_url);
   GURL image_url;
   if (bookmark) {
     int width;
     int height;
-    enhanced_bookmarks::ThumbnailImageFromBookmark(
+    enhanced_bookmark_model_->GetThumbnailImage(
         bookmark, &image_url, &width, &height);
   }
 
   RetrieveSalientImage(
       page_url,
       image_url,
       "",
       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
       false);
 }
@@ skipping 44 matching lines @@
 void BookmarkImageService::ProcessNewImage(const GURL& page_url,
                                            bool update_bookmarks,
                                            const gfx::Image& image,
                                            const GURL& image_url) {
   DCHECK(CalledOnValidThread());
   StoreImage(image, image_url, page_url);
   in_progress_page_urls_.erase(page_url);
   ProcessRequests(page_url, image, image_url);
   if (update_bookmarks && image_url.is_valid()) {
     const BookmarkNode* bookmark =
-        bookmark_model_->GetMostRecentlyAddedUserNodeForURL(page_url);
+        enhanced_bookmark_model_->bookmark_model()
+            ->GetMostRecentlyAddedUserNodeForURL(page_url);
     if (bookmark) {
       const gfx::Size& size = image.Size();
-      bool result = enhanced_bookmarks::SetOriginalImageForBookmark(
-          bookmark_model_, bookmark, image_url, size.width(), size.height());
+      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();
 }
 
@@ skipping 125 matching lines @@
     const BookmarkNode* node) {
 }
 
 void BookmarkImageService::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   ClearAll();
 }
 
 }  // namespace enhanced_bookmarks