Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / chrome / browser / sync / glue / non_ui_data_type_controller_unittest.cc

diff --git a/src/chrome/browser/sync/glue/non_ui_data_type_controller_unittest.cc b/src/chrome/browser/sync/glue/non_ui_data_type_controller_unittest.cc
index a9c6954..e27684a 100644 (file)
--- a/src/chrome/browser/sync/glue/non_ui_data_type_controller_unittest.cc
+++ b/src/chrome/browser/sync/glue/non_ui_data_type_controller_unittest.cc
@@ -14,10 +14,10 @@
 #include "base/test/test_timeouts.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/sync/glue/non_ui_data_type_controller_mock.h"
-#include "chrome/browser/sync/glue/shared_change_processor_mock.h"
 #include "chrome/browser/sync/profile_sync_components_factory_mock.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "components/sync_driver/data_type_controller_mock.h"
+#include "components/sync_driver/generic_change_processor_factory.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/api/fake_syncable_service.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
@@ -57,6 +57,39 @@ ACTION_P(GetWeakPtrToSyncableService, syncable_service) {
   return syncable_service->AsWeakPtr();
 }
 
+class SharedChangeProcessorMock : public SharedChangeProcessor {
+ public:
+  SharedChangeProcessorMock() {}
+
+  MOCK_METHOD6(Connect, base::WeakPtr<syncer::SyncableService>(
+      browser_sync::SyncApiComponentFactory*,
+      GenericChangeProcessorFactory*,
+      syncer::UserShare*,
+      DataTypeErrorHandler*,
+      syncer::ModelType,
+      const base::WeakPtr<syncer::SyncMergeResult>&));
+  MOCK_METHOD0(Disconnect, bool());
+  MOCK_METHOD2(ProcessSyncChanges,
+               syncer::SyncError(const tracked_objects::Location&,
+                         const syncer::SyncChangeList&));
+  MOCK_CONST_METHOD2(GetAllSyncDataReturnError,
+                     syncer::SyncError(syncer::ModelType,
+                                       syncer::SyncDataList*));
+  MOCK_METHOD0(GetSyncCount, int());
+  MOCK_METHOD1(SyncModelHasUserCreatedNodes,
+               bool(bool*));
+  MOCK_METHOD0(CryptoReadyIfNecessary, bool());
+  MOCK_CONST_METHOD1(GetDataTypeContext, bool(std::string*));
+
+ protected:
+  virtual ~SharedChangeProcessorMock() {}
+  MOCK_METHOD2(OnUnrecoverableError, void(const tracked_objects::Location&,
+                                          const std::string&));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock);
+};
+
 class NonUIDataTypeControllerFake
     : public NonUIDataTypeController {
  public:
@@ -64,14 +97,17 @@ class NonUIDataTypeControllerFake
       ProfileSyncComponentsFactory* profile_sync_factory,
       Profile* profile,
       ProfileSyncService* sync_service,
-      NonUIDataTypeControllerMock* mock)
-      : NonUIDataTypeController(base::MessageLoopProxy::current(),
-                                base::Closure(),
-                                profile_sync_factory,
-                                profile,
-                                sync_service),
+      NonUIDataTypeControllerMock* mock,
+      SharedChangeProcessor* change_processor)
+      : NonUIDataTypeController(
+          base::MessageLoopProxy::current(),
+          base::Closure(),
+          profile_sync_factory,
+          profile,
+          sync_service),
         blocked_(false),
-        mock_(mock) {}
+        mock_(mock),
+        change_processor_(change_processor) {}
 
   virtual syncer::ModelType type() const OVERRIDE {
     return AUTOFILL_PROFILE;
@@ -97,6 +133,10 @@ class NonUIDataTypeControllerFake
     pending_tasks_.clear();
   }
 
+  virtual SharedChangeProcessor* CreateSharedChangeProcessor() OVERRIDE {
+    return change_processor_;
+  }
+
  protected:
   virtual bool PostTaskOnBackendThread(
       const tracked_objects::Location& from_here,
@@ -147,6 +187,7 @@ class NonUIDataTypeControllerFake
   bool blocked_;
   std::vector<PendingTask> pending_tasks_;
   NonUIDataTypeControllerMock* mock_;
+  scoped_refptr<SharedChangeProcessor> change_processor_;
 };
 
 class SyncNonUIDataTypeControllerTest : public testing::Test {
@@ -162,14 +203,14 @@ class SyncNonUIDataTypeControllerTest : public testing::Test {
     profile_sync_factory_.reset(
         new StrictMock<ProfileSyncComponentsFactoryMock>());
     change_processor_ = new SharedChangeProcessorMock();
-
     // All of these are refcounted, so don't need to be released.
     dtc_mock_ = new StrictMock<NonUIDataTypeControllerMock>();
     non_ui_dtc_ =
         new NonUIDataTypeControllerFake(profile_sync_factory_.get(),
                                         &profile_,
                                         &service_,
-                                        dtc_mock_.get());
+                                        dtc_mock_.get(),
+                                        change_processor_);
   }
 
   virtual void TearDown() OVERRIDE {
@@ -192,17 +233,13 @@ class SyncNonUIDataTypeControllerTest : public testing::Test {
   void SetStartExpectations() {
     EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true));
     EXPECT_CALL(model_load_callback_, Run(_, _));
-    EXPECT_CALL(*profile_sync_factory_,
-                CreateSharedChangeProcessor()).
-        WillOnce(Return(change_processor_.get()));
   }
 
   void SetAssociateExpectations() {
-    EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+    EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
         .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
     EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
         .WillOnce(Return(true));
-    EXPECT_CALL(*change_processor_.get(), ActivateDataType(_));
     EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
         .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
     EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_,_))
@@ -270,7 +307,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, StartOk) {
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) {
   SetStartExpectations();
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
@@ -289,9 +326,6 @@ TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) {
 // Start the DTC and have StartModels() return false.  Then, stop the
 // DTC without finishing model startup.  It should stop cleanly.
 TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringStartModels) {
-  EXPECT_CALL(*profile_sync_factory_,
-              CreateSharedChangeProcessor()).
-      WillOnce(Return(change_processor_.get()));
   EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(false));
   EXPECT_CALL(*dtc_mock_.get(), StopModels());
   EXPECT_CALL(model_load_callback_, Run(_, _));
@@ -310,7 +344,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringStartModels) {
 // cleanly.
 TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
@@ -339,7 +373,7 @@ TEST_F(SyncNonUIDataTypeControllerTest,
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::UNRECOVERABLE_ERROR);
   // Set up association to fail with an unrecoverable error.
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillRepeatedly(Return(true));
@@ -356,7 +390,7 @@ TEST_F(SyncNonUIDataTypeControllerTest,
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::NEEDS_CRYPTO);
   // Set up association to fail with a NEEDS_CRYPTO error.
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillRepeatedly(Return(false));
@@ -374,7 +408,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringAssociation) {
 
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::ABORTED);
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
@@ -424,7 +458,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, StartAfterSyncShutdown) {
   Mock::VerifyAndClearExpectations(change_processor_.get());
   Mock::VerifyAndClearExpectations(dtc_mock_.get());
 
-  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _, _))
       .WillOnce(Return(base::WeakPtr<syncer::SyncableService>()));
   non_ui_dtc_->UnblockBackendTasks();
   WaitForDTC();