Reduce frequency of requesting bookmark clusters.

components/enhanced_bookmarks/enhanced_bookmark_model_unittest.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/enhanced_bookmark_model.h"
 
 #include "base/base64.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 
 class EnhancedBookmarkModelTest
     : public testing::Test,
       public enhanced_bookmarks::EnhancedBookmarkModelObserver {
  public:
   EnhancedBookmarkModelTest()
       : loaded_calls_(0),
         shutting_down_calls_(0),
         added_calls_(0),
         removed_calls_(0),
+        changed_calls_(0),
         all_user_nodes_removed_calls_(0),
         remote_id_changed_calls_(0),
         last_added_(NULL),
         last_removed_(NULL),
+        last_changed_(NULL),
         last_remote_id_node_(NULL) {}
   ~EnhancedBookmarkModelTest() override {}
 
   void SetUp() override {
     message_loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_DEFAULT));
     bookmark_client_.reset(new bookmarks::TestBookmarkClient());
     bookmark_model_.reset(bookmark_client_->CreateModel().release());
     model_.reset(new EnhancedBookmarkModel(bookmark_model_.get(), "v1.0"));
     model_->AddObserver(this);
   }
@@ skipping 59 matching lines @@
   void EnhancedBookmarkModelLoaded() override { loaded_calls_++; }
   void EnhancedBookmarkModelShuttingDown() override { shutting_down_calls_++; }
   void EnhancedBookmarkAdded(const BookmarkNode* node) override {
     added_calls_++;
     last_added_ = node;
   }
   void EnhancedBookmarkRemoved(const BookmarkNode* node) override {
     removed_calls_++;
     last_removed_ = node;
   }
+  void EnhancedBookmarkNodeChanged(const BookmarkNode* node) override {
+    changed_calls_++;
+    last_changed_ = node;
+  }
   void EnhancedBookmarkAllUserNodesRemoved() override {
     all_user_nodes_removed_calls_++;
   }
   void EnhancedBookmarkRemoteIdChanged(const BookmarkNode* node,
                                        const std::string& old_remote_id,
                                        const std::string& remote_id) override {
     remote_id_changed_calls_++;
     last_remote_id_node_ = node;
     last_old_remote_id_ = old_remote_id;
     last_remote_id_ = remote_id;
   }
 
   // Observer call counters:
   int loaded_calls_;
   int shutting_down_calls_;
   int added_calls_;
   int removed_calls_;
+  int changed_calls_;
   int all_user_nodes_removed_calls_;
   int remote_id_changed_calls_;
 
   // Observer parameter cache:
   const BookmarkNode* last_added_;
   const BookmarkNode* last_removed_;
+  const BookmarkNode* last_changed_;
   const BookmarkNode* last_remote_id_node_;
   std::string last_old_remote_id_;
   std::string last_remote_id_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EnhancedBookmarkModelTest);
 };
 
 TEST_F(EnhancedBookmarkModelTest, TestEmptySnippet) {
   const BookmarkNode* node = AddBookmark();
@@ skipping 431 matching lines @@
   bookmark_model_->Remove(node->parent(), node->parent()->GetIndexOf(node));
   EXPECT_EQ(1, removed_calls_);
   EXPECT_EQ(node, last_removed_);
 
   bookmark_model_->Remove(folder->parent(),
                           folder->parent()->GetIndexOf(folder));
   EXPECT_EQ(2, removed_calls_);
   EXPECT_EQ(folder, last_removed_);
 }
 
+TEST_F(EnhancedBookmarkModelTest, ObserverNodeChangedEvent) {
+  const BookmarkNode* node = AddBookmark();
+
+  EXPECT_EQ(0, changed_calls_);
+  bookmark_model_->SetTitle(node, base::ASCIIToUTF16("New Title"));
+  EXPECT_EQ(1, changed_calls_);
+  EXPECT_EQ(node, last_changed_);
+}
+
 TEST_F(EnhancedBookmarkModelTest, ObserverAllUserNodesRemovedEvent) {
   AddBookmark();
   AddFolder();
   EXPECT_EQ(0, all_user_nodes_removed_calls_);
   bookmark_model_->RemoveAllUserBookmarks();
   EXPECT_EQ(0, removed_calls_);
   EXPECT_EQ(1, all_user_nodes_removed_calls_);
 }
 
 TEST_F(EnhancedBookmarkModelTest, ObserverRemoteIdChangedEvent) {
@@ skipping 123 matching lines @@
 TEST_F(EnhancedBookmarkModelTest,
        NodeRemovedWhileSetNeedsOfflineProcessingIsScheduled) {
   const BookmarkNode* node =
       bookmark_model_->AddURL(bookmark_model_->other_node(),
                               0,
                               base::ASCIIToUTF16("Some title"),
                               GURL(BOOKMARK_URL));
   bookmark_model_->Remove(node->parent(), node->parent()->GetIndexOf(node));
   base::RunLoop().RunUntilIdle();
 }