[Sync] Tidy up SyncBackendHost interface.

chrome/browser/sync/profile_sync_service_password_unittest.cc

 // Copyright (c) 2010 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/password_change_processor.h"
 #include "chrome/browser/sync/glue/password_data_type_controller.h"
 #include "chrome/browser/sync/glue/password_model_associator.h"
-#include "chrome/browser/sync/glue/sync_backend_host_mock.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/profile_sync_factory_mock.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_observer_mock.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "chrome/test/profile_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webkit/glue/password_form.h"
 
 using base::Time;
 using browser_sync::PasswordChangeProcessor;
 using browser_sync::PasswordDataTypeController;
 using browser_sync::PasswordModelAssociator;
-using browser_sync::SyncBackendHostMock;
 using browser_sync::TestIdFactory;
 using browser_sync::UnrecoverableErrorHandler;
 using sync_api::SyncManager;
 using sync_api::UserShare;
 using syncable::BASE_VERSION;
 using syncable::CREATE;
 using syncable::DirectoryManager;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNAPPLIED_UPDATE;
@@ skipping 42 matching lines @@
                const base::Time&));
   MOCK_METHOD2(GetLoginsImpl, void(GetLoginsRequest*, const PasswordForm&));
   MOCK_METHOD1(GetAutofillableLoginsImpl, void(GetLoginsRequest*));
   MOCK_METHOD1(GetBlacklistLoginsImpl, void(GetLoginsRequest*));
   MOCK_METHOD1(FillAutofillableLogins,
       bool(std::vector<PasswordForm*>*));
   MOCK_METHOD1(FillBlacklistLogins,
       bool(std::vector<PasswordForm*>*));
 };
 
+class PasswordTestProfileSyncService : public TestProfileSyncService {
+ public:
+  PasswordTestProfileSyncService(ProfileSyncFactory* factory,
+                                 Profile* profile,
+                                 const std::string& test_user,
+                                 bool synchronous_backend_initialization,
+                                 Task* initial_condition_setup_task,
+                                 Task* passphrase_accept_task)
+      : TestProfileSyncService(factory, profile, test_user,
+                               synchronous_backend_initialization,
+                               initial_condition_setup_task),
+        passphrase_accept_task_(passphrase_accept_task) {}
+
+  virtual ~PasswordTestProfileSyncService() {}
+
+  virtual void OnPassphraseRequired(bool for_decryption) {
+    TestProfileSyncService::OnPassphraseRequired(for_decryption);
+    ADD_FAILURE();
+  }
+
+  virtual void OnPassphraseAccepted() {
+    TestProfileSyncService::OnPassphraseAccepted();
+
+    if (passphrase_accept_task_) {
+      passphrase_accept_task_->Run();
+    }
+  }
+
+ private:
+  Task* passphrase_accept_task_;
+};
+
 class ProfileSyncServicePasswordTest : public AbstractProfileSyncServiceTest {
  protected:
   ProfileSyncServicePasswordTest()
       : db_thread_(BrowserThread::DB) {
   }
 
   virtual void SetUp() {
     password_store_ = new MockPasswordStore();
     db_thread_.Start();
 
     notification_service_ = new ThreadNotificationService(&db_thread_);
     notification_service_->Init();
     registrar_.Add(&observer_,
-        NotificationType::SYNC_PASSPHRASE_ACCEPTED,
-        NotificationService::AllSources());
-    registrar_.Add(&observer_,
         NotificationType::SYNC_CONFIGURE_DONE,
         NotificationService::AllSources());
-
-    // We shouldn't ever get this. Gmock will complain if we do.
-    registrar_.Add(&observer_,
-        NotificationType::SYNC_PASSPHRASE_REQUIRED,
-        NotificationService::AllSources());
   }
 
   virtual void TearDown() {
     service_.reset();
     notification_service_->TearDown();
     db_thread_.Stop();
     MessageLoop::current()->RunAllPending();
   }
 
   void StartSyncService(Task* root_task, Task* node_task) {
     StartSyncService(root_task, node_task, 2, 2);
   }
 
   void StartSyncService(Task* root_task, Task* node_task,
                         int num_resume_expectations,
                         int num_pause_expectations) {
     if (!service_.get()) {
-      service_.reset(new TestProfileSyncService(&factory_, &profile_,
-                                                "test_user", false, root_task));
+      service_.reset(new PasswordTestProfileSyncService(
+          &factory_, &profile_, "test_user", false, root_task, node_task));
       service_->RegisterPreferences();
       profile_.GetPrefs()->SetBoolean(prefs::kSyncPasswords, true);
       service_->set_num_expected_resumes(num_resume_expectations);
       service_->set_num_expected_pauses(num_pause_expectations);
       PasswordDataTypeController* data_type_controller =
           new PasswordDataTypeController(&factory_,
                                          &profile_,
                                          service_.get());
 
       EXPECT_CALL(factory_, CreatePasswordSyncComponents(_, _, _)).
@@ skipping 15 matching lines @@
           WillRepeatedly(Return(password_store_.get()));
 
       EXPECT_CALL(observer_,
           Observe(
               NotificationType(NotificationType::SYNC_CONFIGURE_DONE),_,_));
 
       service_->RegisterDataTypeController(data_type_controller);
       service_->Initialize();
       MessageLoop::current()->Run();
 
-
       EXPECT_CALL(
           observer_,
           Observe(
-              NotificationType(NotificationType::SYNC_PASSPHRASE_ACCEPTED),
-              _,_)).
-          WillOnce(InvokeTask(node_task));
-      EXPECT_CALL(
-          observer_,
-          Observe(
               NotificationType(NotificationType::SYNC_CONFIGURE_DONE),
               _,_)).
           WillOnce(QuitUIMessageLoop());
       service_->SetPassphrase("foo", false, true);
       MessageLoop::current()->Run();
     }
   }
 
   void AddPasswordSyncNode(const PasswordForm& entry) {
     sync_api::WriteTransaction trans(
@@ skipping 306 matching lines @@
   AddPasswordEntriesTask node_task(this, sync_forms);
 
   StartSyncService(&root_task, &node_task);
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(1U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
 }