sync/glue: Convert BookmarkDataTypeController to BaseBookmarkModelObserver.

chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc

Index: chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc
diff --git a/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc b/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc
index a688552fe2f22485bd2d8e3a37c05f46630b4c8e..bfa351b93b0c99deb631556fe5a685c3edfcece8 100644
--- a/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc
+++ b/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc
@@ -2,20 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "testing/gtest/include/gtest/gtest.h"
+#include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/run_loop.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/refcounted_profile_keyed_service.h"
-#include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
 #include "chrome/browser/sync/glue/change_processor_mock.h"
 #include "chrome/browser/sync/glue/data_type_controller_mock.h"
 #include "chrome/browser/sync/glue/model_associator_mock.h"
@@ -23,10 +23,12 @@
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/profile_mock.h"
+#include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/api/sync_error.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 using browser_sync::BookmarkDataTypeController;
 using browser_sync::ChangeProcessorMock;
@@ -43,13 +45,6 @@ using testing::SetArgumentPointee;
 
 namespace {
 
-class BookmarkModelMock : public BookmarkModel {
- public:
-  BookmarkModelMock() : BookmarkModel(NULL) {}
-  MOCK_CONST_METHOD0(IsLoaded, bool(void));
-};
-
-
 class HistoryMock : public HistoryService {
  public:
   explicit HistoryMock(Profile* profile) : HistoryService(profile) {}
@@ -59,9 +54,14 @@ class HistoryMock : public HistoryService {
   virtual ~HistoryMock() {}
 };
 
-ProfileKeyedService* BuildBookmarkModel(
-      Profile* profile) {
-  return new BookmarkModelMock;
+ProfileKeyedService* BuildBookmarkModel(Profile* profile) {
+  BookmarkModel* bookmark_model = new BookmarkModel(profile);
+  bookmark_model->Load();
+  return bookmark_model;
+}
+
+ProfileKeyedService* BuildBookmarkModelWithoutLoading(Profile* profile) {
+  return new BookmarkModel(profile);
 }
 
 ProfileKeyedService* BuildHistoryService(Profile* profile) {
@@ -81,21 +81,34 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test {
     history_service_ = static_cast<HistoryMock*>(
         HistoryServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, BuildHistoryService));
-    bookmark_model_ = static_cast<BookmarkModelMock*>(
-        BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
-            &profile_, BuildBookmarkModel));
     profile_sync_factory_.reset(
         new ProfileSyncComponentsFactoryMock(model_associator_,
-                                   change_processor_));
-    bookmark_dtc_ =
-        new BookmarkDataTypeController(profile_sync_factory_.get(),
-                                       &profile_,
-                                       &service_);
+                                             change_processor_));
+    bookmark_dtc_ = new BookmarkDataTypeController(profile_sync_factory_.get(),
+                                                   &profile_,
+                                                   &service_);
   }
 
  protected:
+  enum BookmarkLoadPolicy {
+    DONT_LOAD_MODEL,
+    LOAD_MODEL,
+  };
+
+  void CreateBookmarkModel(BookmarkLoadPolicy bookmark_load_policy) {
+    if (bookmark_load_policy == LOAD_MODEL) {
+      bookmark_model_ = static_cast<BookmarkModel*>(
+          BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
+              &profile_, BuildBookmarkModel));
+      ui_test_utils::WaitForBookmarkModelToLoad(bookmark_model_);
+    } else {
+      bookmark_model_ = static_cast<BookmarkModel*>(
+          BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
+              &profile_, BuildBookmarkModelWithoutLoading));
+    }
+  }
+
   void SetStartExpectations() {
-    EXPECT_CALL(*bookmark_model_, IsLoaded()).WillRepeatedly(Return(true));
     EXPECT_CALL(*history_service_,
                 BackendLoaded()).WillRepeatedly(Return(true));
     EXPECT_CALL(model_load_callback_, Run(_, _));
@@ -132,20 +145,17 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test {
   scoped_refptr<BookmarkDataTypeController> bookmark_dtc_;
   scoped_ptr<ProfileSyncComponentsFactoryMock> profile_sync_factory_;
   ProfileMock profile_;
-  BookmarkModelMock* bookmark_model_;
+  BookmarkModel* bookmark_model_;
   HistoryMock* history_service_;
   ProfileSyncServiceMock service_;
   ModelAssociatorMock* model_associator_;
   ChangeProcessorMock* change_processor_;
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
-
-  void PumpLoop() {
-    message_loop_.RunUntilIdle();
-  }
 };
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartDependentsReady) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
 
@@ -157,23 +167,18 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartDependentsReady) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartBookmarkModelNotReady) {
+  CreateBookmarkModel(DONT_LOAD_MODEL);
   SetStartExpectations();
-  EXPECT_CALL(*bookmark_model_, IsLoaded()).WillRepeatedly(Return(false));
   SetAssociateExpectations();
 
   EXPECT_CALL(start_callback_, Run(DataTypeController::OK, _, _));
-      bookmark_dtc_->LoadModels(
-        base::Bind(&ModelLoadCallbackMock::Run,
-                   base::Unretained(&model_load_callback_)));
+  bookmark_dtc_->LoadModels(
+      base::Bind(&ModelLoadCallbackMock::Run,
+                 base::Unretained(&model_load_callback_)));
   EXPECT_EQ(DataTypeController::MODEL_STARTING, bookmark_dtc_->state());
-  testing::Mock::VerifyAndClearExpectations(bookmark_model_);
-  EXPECT_CALL(*bookmark_model_, IsLoaded()).WillRepeatedly(Return(true));
 
-  // Send the notification that the bookmark model has started.
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
-      content::Source<Profile>(&profile_),
-      content::NotificationService::NoDetails());
+  bookmark_model_->Load();
+  ui_test_utils::WaitForBookmarkModelToLoad(bookmark_model_);
   EXPECT_EQ(DataTypeController::MODEL_LOADED, bookmark_dtc_->state());
 
   bookmark_dtc_->StartAssociating(
@@ -184,6 +189,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartBookmarkModelNotReady) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartHistoryServiceNotReady) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   EXPECT_CALL(*history_service_,
               BackendLoaded()).WillRepeatedly(Return(false));
@@ -205,6 +211,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartHistoryServiceNotReady) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartFirstRun) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
@@ -214,7 +221,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartFirstRun) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartBusy) {
-  EXPECT_CALL(*bookmark_model_, IsLoaded()).WillRepeatedly(Return(false));
+  CreateBookmarkModel(LOAD_MODEL);
   EXPECT_CALL(*history_service_, BackendLoaded()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(model_load_callback_, Run(_, _));
@@ -227,6 +234,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartBusy) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartOk) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
@@ -237,6 +245,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartOk) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartAssociationFailed) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   // Set up association to fail.
   EXPECT_CALL(*profile_sync_factory_, CreateBookmarkSyncComponents(_, _));
@@ -257,6 +266,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartAssociationFailed) {
 
 TEST_F(SyncBookmarkDataTypeControllerTest,
        StartAssociationTriggersUnrecoverableError) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   // Set up association to fail with an unrecoverable error.
   EXPECT_CALL(*profile_sync_factory_, CreateBookmarkSyncComponents(_, _));
@@ -271,7 +281,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest,
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, StartAborted) {
-  EXPECT_CALL(*bookmark_model_, IsLoaded()).WillRepeatedly(Return(false));
+  CreateBookmarkModel(LOAD_MODEL);
   EXPECT_CALL(*history_service_, BackendLoaded()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(model_load_callback_, Run(_, _));
@@ -284,6 +294,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, StartAborted) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, Stop) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
   SetStopExpectations();
@@ -298,6 +309,7 @@ TEST_F(SyncBookmarkDataTypeControllerTest, Stop) {
 }
 
 TEST_F(SyncBookmarkDataTypeControllerTest, OnSingleDatatypeUnrecoverableError) {
+  CreateBookmarkModel(LOAD_MODEL);
   SetStartExpectations();
   SetAssociateExpectations();
   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
@@ -311,5 +323,5 @@ TEST_F(SyncBookmarkDataTypeControllerTest, OnSingleDatatypeUnrecoverableError) {
   Start();
   // This should cause bookmark_dtc_->Stop() to be called.
   bookmark_dtc_->OnSingleDatatypeUnrecoverableError(FROM_HERE, "Test");
-  PumpLoop();
+  base::RunLoop().RunUntilIdle();
 }