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 13 matching lines @@
   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) {
+    : bookmark_model_(bookmark_model),
+      enhanced_bookmark_model_(enhanced_bookmark_model),
+      store_(store.Pass()),
+      pool_(pool) {
   DCHECK(CalledOnValidThread());
   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) {
+    : bookmark_model_(bookmark_model),
+      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.
   //
@@ skipping 49 matching lines @@
     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);
   GURL image_url;
   if (bookmark) {
     int width;
     int height;
-    enhanced_bookmarks::ThumbnailImageFromBookmark(
+    enhanced_bookmark_model_->GetThumbnailImageForNode(
         bookmark, &image_url, &width, &height);
   }
 
   RetrieveSalientImage(
       page_url,
       image_url,
       "",
       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
       false);
 }
@@ skipping 47 matching lines @@
                                            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);
     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_->SetOriginalImageForNode(
+          bookmark, image_url, size.width(), size.height(), false);

[Yaron, 2014/09/05 03:16:53]

what does stars.userEdit mean? This can be as a result of the user adding a new
bookmark. What happens if this is set incorrectly?

[Rune Fevang, 2014/09/05 03:40:26]

I don't understand the purpose of this field myself, hopefully Mark can answer.

[Mark, 2014/09/08 22:47:08]

The idea is that not all client edits are necessarily done by explicit user
action.  For instance, if we set a meta info field for book-keeping purposes,
this is not a user initiated action.  It has been strongly requested by the
ZipIt team that we only update the last modified timestamp for user initiated
actions and not other actions that may be done behind the scenes.  So, the
purpose of this field is to tell the server not to update the last modified
timestamp.  Does that make sense?

[Yaron, 2014/09/08 23:30:39]

Sure, but then it should be true here which I see reflected now so we're on the
same page.

       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