Adding ExtensiveChanges state to BookmarkModel.

Some BookmarkModelObservers needs to know when the BookmarkModel might see
extensive changes, such as during import and sync. Import already has
functionality to inform observers about it, and this uses the same framework
for the same types of messages while syncing.

Since observers such as the NTP might be created after the BookmarkModel sends
out the initial BookmarkModelObserver::ExtensiveBookmarkChangesBeginning(...)
event, the state is also kept so observers can call
BookmarkModel::IsDoingExtensiveChanges() during their own initialization.

BUG=113666
TEST=unit_tests

Review URL: http://codereview.chromium.org/9380015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@122404 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 193 insertions, 44 deletions

diff --git a/chrome/browser/bookmarks/bookmark_extension_api.cc b/chrome/browser/bookmarks/bookmark_extension_api.cc
index c40ec70..be6e8a5 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api.cc
+++ b/chrome/browser/bookmarks/bookmark_extension_api.cc
@@ -266,7 +266,7 @@ void BookmarkExtensionEventRouter::BookmarkNodeChildrenReordered(
 }
 
 void BookmarkExtensionEventRouter::
-    BookmarkImportBeginning(BookmarkModel* model) {
+    ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {
   ListValue args;
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
@@ -275,7 +275,8 @@ void BookmarkExtensionEventRouter::
                 json_args);
 }
 
-void BookmarkExtensionEventRouter::BookmarkImportEnding(BookmarkModel* model) {
+void BookmarkExtensionEventRouter::ExtensiveBookmarkChangesEnded(
+    BookmarkModel* model) {
   ListValue args;
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
diff --git a/chrome/browser/bookmarks/bookmark_extension_api.h b/chrome/browser/bookmarks/bookmark_extension_api.h
index cce002f..ef2f8d6 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api.h
+++ b/chrome/browser/bookmarks/bookmark_extension_api.h
@@ -54,8 +54,8 @@ class BookmarkExtensionEventRouter : public BookmarkModelObserver {
                                           const BookmarkNode* node) OVERRIDE;
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
                                              const BookmarkNode* node) OVERRIDE;
-  virtual void BookmarkImportBeginning(BookmarkModel* model) OVERRIDE;
-  virtual void BookmarkImportEnding(BookmarkModel* model) OVERRIDE;
+  virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE;
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE;
 
  private:
   // Helper to actually dispatch an event to extension listeners.
diff --git a/chrome/browser/bookmarks/bookmark_model.cc b/chrome/browser/bookmarks/bookmark_model.cc
index d370df8..fcb608c 100644
--- a/chrome/browser/bookmarks/bookmark_model.cc
+++ b/chrome/browser/bookmarks/bookmark_model.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -133,7 +133,8 @@ BookmarkModel::BookmarkModel(Profile* profile)
       mobile_node_(NULL),
       next_node_id_(1),
       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
-      loaded_signal_(true, false) {
+      loaded_signal_(true, false),
+      extensive_changes_(0) {
   if (!profile_) {
     // Profile is null during testing.
     DoneLoading(CreateLoadDetails());
@@ -209,14 +210,20 @@ void BookmarkModel::RemoveObserver(BookmarkModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void BookmarkModel::BeginImportMode() {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkImportBeginning(this));
+void BookmarkModel::BeginExtensiveChanges() {
+  if (++extensive_changes_ == 1) {
+    FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
+                      ExtensiveBookmarkChangesBeginning(this));
+  }
 }
 
-void BookmarkModel::EndImportMode() {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkImportEnding(this));
+void BookmarkModel::EndExtensiveChanges() {
+  --extensive_changes_;
+  DCHECK_GE(extensive_changes_, 0);
+  if (extensive_changes_ == 0) {
+    FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
+                      ExtensiveBookmarkChangesEnded(this));
+  }
 }
 
 void BookmarkModel::Remove(const BookmarkNode* parent, int index) {
diff --git a/chrome/browser/bookmarks/bookmark_model.h b/chrome/browser/bookmarks/bookmark_model.h
index a07b5bd..91cd1c8 100644
--- a/chrome/browser/bookmarks/bookmark_model.h
+++ b/chrome/browser/bookmarks/bookmark_model.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -245,10 +245,19 @@ class BookmarkModel : public content::NotificationObserver,
   void AddObserver(BookmarkModelObserver* observer);
   void RemoveObserver(BookmarkModelObserver* observer);
 
-  // Notifies the observers that an import is about to happen, so they can delay
-  // any expensive UI updates until it's finished.
-  void BeginImportMode();
-  void EndImportMode();
+  // Notifies the observers that that an extensive set of changes is about to
+  // happen, such as during import or sync, so they can delay any expensive
+  // UI updates until it's finished.
+  void BeginExtensiveChanges();
+  void EndExtensiveChanges();
+
+  // Returns true if this bookmark model is currently in a mode where extensive
+  // changes might happen, such as for import and sync. This is helpful for
+  // observers that are created after the mode has started, and
+  // want to check state during their own initializer, such as the NTP.
+  bool IsDoingExtensiveChanges() const {
+    return extensive_changes_ > 0;
+  }
 
   // Removes the node at the given |index| from |parent|. Removing a folder node
   // recursively removes all nodes. Observers are notified immediately.
@@ -484,6 +493,9 @@ class BookmarkModel : public content::NotificationObserver,
 
   base::WaitableEvent loaded_signal_;
 
+  // See description of IsDoingExtensiveChanges above.
+  int extensive_changes_;
+
   scoped_ptr<BookmarkExpandedStateTracker> expanded_state_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
diff --git a/chrome/browser/bookmarks/bookmark_model_observer.h b/chrome/browser/bookmarks/bookmark_model_observer.h
index 4881391..eadd2d3 100644
--- a/chrome/browser/bookmarks/bookmark_model_observer.h
+++ b/chrome/browser/bookmarks/bookmark_model_observer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -54,16 +54,18 @@ class BookmarkModelObserver {
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
                                              const BookmarkNode* node) = 0;
 
-  // Invoked before a batch import begins.  This tells UI intensive observers
-  // to wait until the updates finish to update themselves.
-  // These methods should only be used for imports. Observers should still
-  // respond to BookmarkNodeRemoved immediately, to avoid holding onto
-  // stale node pointers.
-  virtual void BookmarkImportBeginning(BookmarkModel* model) {}
+  // Invoked before an extensive set of model changes is about to begin.
+  // This tells UI intensive observers to wait until the updates finish to
+  // update themselves.
+  // These methods should only be used for imports and sync.
+  // Observers should still respond to BookmarkNodeRemoved immediately,
+  // to avoid holding onto stale node pointers.
+  virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {}
 
-  // Invoked after a batch import finishes.  This tells observers to update
-  // themselves if they were waiting for the update to finish.
-  virtual void BookmarkImportEnding(BookmarkModel* model) {}
+  // Invoked after an extensive set of model changes has ended.
+  // This tells observers to update themselves if they were waiting for the
+  // update to finish.
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) {}
 
  protected:
   virtual ~BookmarkModelObserver() {}
diff --git a/chrome/browser/bookmarks/bookmark_model_unittest.cc b/chrome/browser/bookmarks/bookmark_model_unittest.cc
index 8425055..2421ba8 100644
--- a/chrome/browser/bookmarks/bookmark_model_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_model_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -169,9 +169,19 @@ class BookmarkModelTest : public testing::Test,
     // gets invoked.
   }
 
+  virtual void ExtensiveBookmarkChangesBeginning(
+      BookmarkModel* model) OVERRIDE {
+    ++extensive_changes_beginning_count_;
+  }
+
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE {
+    ++extensive_changes_ended_count_;
+  }
+
   void ClearCounts() {
     added_count_ = moved_count_ = removed_count_ = changed_count_ =
-        reordered_count_ = 0;
+        reordered_count_ = extensive_changes_beginning_count_ =
+        extensive_changes_ended_count_ = 0;
   }
 
   void AssertObserverCount(int added_count,
@@ -186,6 +196,14 @@ class BookmarkModelTest : public testing::Test,
     EXPECT_EQ(reordered_count_, reordered_count);
   }
 
+  void AssertExtensiveChangesObserverCount(
+      int extensive_changes_beginning_count,
+      int extensive_changes_ended_count) {
+    EXPECT_EQ(extensive_changes_beginning_count_,
+              extensive_changes_beginning_count);
+    EXPECT_EQ(extensive_changes_ended_count_, extensive_changes_ended_count);
+  }
+
  protected:
   BookmarkModel model_;
   ObserverDetails observer_details_;
@@ -196,6 +214,8 @@ class BookmarkModelTest : public testing::Test,
   int removed_count_;
   int changed_count_;
   int reordered_count_;
+  int extensive_changes_beginning_count_;
+  int extensive_changes_ended_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModelTest);
 };
@@ -1115,4 +1135,32 @@ TEST_F(BookmarkModelTest, MobileNodeVisibileWithChildren) {
   EXPECT_TRUE(model_.mobile_node()->IsVisible());
 }
 
+TEST_F(BookmarkModelTest, ExtensiveChangesObserver) {
+  AssertExtensiveChangesObserverCount(0, 0);
+  EXPECT_FALSE(model_.IsDoingExtensiveChanges());
+  model_.BeginExtensiveChanges();
+  EXPECT_TRUE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 0);
+  model_.EndExtensiveChanges();
+  EXPECT_FALSE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 1);
+}
+
+TEST_F(BookmarkModelTest, MultipleExtensiveChangesObserver) {
+  AssertExtensiveChangesObserverCount(0, 0);
+  EXPECT_FALSE(model_.IsDoingExtensiveChanges());
+  model_.BeginExtensiveChanges();
+  EXPECT_TRUE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 0);
+  model_.BeginExtensiveChanges();
+  EXPECT_TRUE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 0);
+  model_.EndExtensiveChanges();
+  EXPECT_TRUE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 0);
+  model_.EndExtensiveChanges();
+  EXPECT_FALSE(model_.IsDoingExtensiveChanges());
+  AssertExtensiveChangesObserverCount(1, 1);
+}
+
 }  // namespace
diff --git a/chrome/browser/importer/profile_writer.cc b/chrome/browser/importer/profile_writer.cc
index 8b8bfa8..f93a32d 100644
--- a/chrome/browser/importer/profile_writer.cc
+++ b/chrome/browser/importer/profile_writer.cc
@@ -146,7 +146,7 @@ void ProfileWriter::AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
   // for unnecessary nesting.
   bool add_all_to_top_level = import_to_top_level && toolbar_bookmarks.empty();
 
-  model->BeginImportMode();
+  model->BeginExtensiveChanges();
 
   std::set<const BookmarkNode*> folders_added_to;
   const BookmarkNode* top_level_folder = NULL;
@@ -217,7 +217,7 @@ void ProfileWriter::AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
     model->ResetDateFolderModified(*i);
   }
 
-  model->EndImportMode();
+  model->EndExtensiveChanges();
 
   // If the user was previously using a toolbar, we should show the bar.
   if (import_to_top_level && !add_all_to_top_level)
diff --git a/chrome/browser/sync/glue/bookmark_model_associator.cc b/chrome/browser/sync/glue/bookmark_model_associator.cc
index aa23ad5..a7d212c 100644
--- a/chrome/browser/sync/glue/bookmark_model_associator.cc
+++ b/chrome/browser/sync/glue/bookmark_model_associator.cc
@@ -96,6 +96,23 @@ class BookmarkNodeFinder {
   DISALLOW_COPY_AND_ASSIGN(BookmarkNodeFinder);
 };
 
+class ScopedAssociationUpdater {
+ public:
+  explicit ScopedAssociationUpdater(BookmarkModel* model) {
+    model_ = model;
+    model->BeginExtensiveChanges();
+  }
+
+  ~ScopedAssociationUpdater() {
+    model_->EndExtensiveChanges();
+  }
+
+ private:
+  BookmarkModel* model_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAssociationUpdater);
+};
+
 BookmarkNodeFinder::BookmarkNodeFinder(const BookmarkNode* parent_node)
     : parent_node_(parent_node) {
   for (int i = 0; i < parent_node_->child_count(); ++i) {
@@ -334,6 +351,8 @@ bool BookmarkModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
 }
 
 bool BookmarkModelAssociator::AssociateModels(SyncError* error) {
+  scoped_ptr<ScopedAssociationUpdater> association_updater(
+      new ScopedAssociationUpdater(bookmark_model_));
   // Try to load model associations from persisted associations first. If that
   // succeeds, we don't need to run the complex model matching algorithm.
   if (LoadAssociations())
diff --git a/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc b/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
index 4f84fb7..b12b81f 100644
--- a/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
@@ -20,6 +20,7 @@
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
@@ -274,6 +275,46 @@ class FakeServerChange {
   sync_api::ChangeRecordList changes_;
 };
 
+class ExtensiveChangesBookmarkModelObserver : public BaseBookmarkModelObserver {
+ public:
+  explicit ExtensiveChangesBookmarkModelObserver()
+      : started_count_(0),
+        completed_count_at_started_(0),
+        completed_count_(0) {}
+
+  virtual void ExtensiveBookmarkChangesBeginning(
+      BookmarkModel* model) OVERRIDE {
+    ++started_count_;
+    completed_count_at_started_ = completed_count_;
+  }
+
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE {
+    ++completed_count_;
+  }
+
+  void BookmarkModelChanged() {}
+
+  int get_started() const {
+    return started_count_;
+  }
+
+  int get_completed_count_at_started() const {
+    return completed_count_at_started_;
+  }
+
+  int get_completed() const {
+    return completed_count_;
+  }
+
+ private:
+  int started_count_;
+  int completed_count_at_started_;
+  int completed_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensiveChangesBookmarkModelObserver);
+};
+
+
 class ProfileSyncServiceBookmarkTest : public testing::Test {
  protected:
   enum LoadOption { LOAD_FROM_STORAGE, DELETE_EXISTING_STORAGE };
@@ -1434,6 +1475,23 @@ TEST_F(ProfileSyncServiceBookmarkTestWithData,
   ExpectModelMatch();
 }
 
+// Verify that the bookmark model is updated about whether the
+// associator is currently running.
+TEST_F(ProfileSyncServiceBookmarkTest, AssociationState) {
+  LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
+
+  ExtensiveChangesBookmarkModelObserver observer;
+  model_->AddObserver(&observer);
+
+  StartSync();
+
+  EXPECT_EQ(1, observer.get_started());
+  EXPECT_EQ(0, observer.get_completed_count_at_started());
+  EXPECT_EQ(1, observer.get_completed());
+
+  model_->RemoveObserver(&observer);
+}
+
 }  // namespace
 
 }  // namespace browser_sync
diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.h b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.h
index 3ef2338..9537656 100644
--- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.h
+++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -46,8 +46,8 @@ class BookmarkBarBridge : public BookmarkModelObserver {
                                           const BookmarkNode* node) OVERRIDE;
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
                                              const BookmarkNode* node) OVERRIDE;
-  virtual void BookmarkImportBeginning(BookmarkModel* model) OVERRIDE;
-  virtual void BookmarkImportEnding(BookmarkModel* model) OVERRIDE;
+  virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE;
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE;
 
  private:
   BookmarkBarController* controller_;  // weak; owns me
diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.mm
index 48fd829..92b60df 100644
--- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.mm
+++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_bridge.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -72,11 +72,12 @@ void BookmarkBarBridge::BookmarkNodeChildrenReordered(
   [controller_ nodeChildrenReordered:model node:node];
 }
 
-void BookmarkBarBridge::BookmarkImportBeginning(BookmarkModel* model) {
+void BookmarkBarBridge::ExtensiveBookmarkChangesBeginning(
+    BookmarkModel* model) {
   batch_mode_ = true;
 }
 
-void BookmarkBarBridge::BookmarkImportEnding(BookmarkModel* model) {
+void BookmarkBarBridge::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
   batch_mode_ = false;
   [controller_ loaded:model];
 }
diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm
index f628bba..38d57b6 100644
--- a/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm
+++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm
@@ -139,13 +139,14 @@ class BookmarkEditorBaseControllerBridge : public BookmarkModelObserver {
     // I care nothing for these 'favicons': I only show folders.
   }
 
-  virtual void BookmarkImportBeginning(BookmarkModel* model) OVERRIDE {
+  virtual void ExtensiveBookmarkChangesBeginning(
+      BookmarkModel* model) OVERRIDE {
     importing_ = true;
   }
 
   // Invoked after a batch import finishes.  This tells observers to update
   // themselves if they were waiting for the update to finish.
-  virtual void BookmarkImportEnding(BookmarkModel* model) OVERRIDE {
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE {
     importing_ = false;
     [controller_ modelChangedPreserveSelection:YES];
   }
diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.h b/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.h
index 2ea721b..add6eb5 100644
--- a/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.h
+++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -56,7 +56,7 @@ class BookmarkModelObserverForCocoa : public BookmarkModelObserver {
                                    const BookmarkNode* node) OVERRIDE;
   virtual void BookmarkNodeChanged(BookmarkModel* model,
                                    const BookmarkNode* node) OVERRIDE;
-  virtual void BookmarkImportBeginning(BookmarkModel* model) OVERRIDE;
+  virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE;
 
   // Some notifications we don't care about, but by being pure virtual
   // in the base class we must implement them.
@@ -74,7 +74,7 @@ class BookmarkModelObserverForCocoa : public BookmarkModelObserver {
       const BookmarkNode* node) OVERRIDE {
   }
 
-  virtual void BookmarkImportEnding(BookmarkModel* model) OVERRIDE {
+  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE {
   }
 
  private:
diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.mm
index 3345497..0303959 100644
--- a/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.mm
+++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -53,7 +53,7 @@ void BookmarkModelObserverForCocoa::BookmarkNodeChanged(
     Notify();
 }
 
-void BookmarkModelObserverForCocoa::BookmarkImportBeginning(
+void BookmarkModelObserverForCocoa::ExtensiveBookmarkChangesBeginning(
     BookmarkModel* model) {
   // Be conservative.
   Notify();