Add a ClientAction used by SyncRollbackManager to notify PSS that rollback is

sync/internal_api/sync_rollback_manager_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 "sync/internal_api/sync_rollback_manager.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
+#include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/test/test_internal_components_factory.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/sync_backup_manager.h"
 #include "sync/syncable/entry.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/test_directory_backing_store.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoDefault;
 using ::testing::Invoke;
+using ::testing::Truly;
 using ::testing::WithArgs;
 
 namespace syncer {
 
 namespace {
 
 class TestChangeDelegate : public SyncManager::ChangeDelegate {
  public:
   TestChangeDelegate() {
     ON_CALL(*this, OnChangesApplied(_, _, _, _))
@@ skipping 21 matching lines @@
       EXPECT_EQ(ChangeRecord::ACTION_DELETE, change.action);
       EXPECT_TRUE(deleted.find(change.id) == deleted.end());
       deleted.insert(change.id);
     }
     EXPECT_TRUE(expected_deletes_ == deleted);
   }
 
   std::set<int64> expected_deletes_;
 };
 
-class SyncRollbackManagerTest : public testing::Test {
+class SyncRollbackManagerTest : public testing::Test,
+                                public SyncManager::Observer {
  protected:
   virtual void SetUp() OVERRIDE {
     CHECK(temp_dir_.CreateUniqueTempDir());
 
     worker_ = new FakeModelWorker(GROUP_UI);
   }
 
+  MOCK_METHOD1(OnSyncCycleCompleted,
+               void(const sessions::SyncSessionSnapshot&));
+  MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));
+  MOCK_METHOD4(OnInitializationComplete,
+      void(const WeakHandle<JsBackend>&,
+           const WeakHandle<DataTypeDebugInfoListener>&,
+           bool, ModelTypeSet));
+  MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&));
+  MOCK_METHOD1(OnMigrationRequested, void(ModelTypeSet));;
+  MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));
+
   void OnConfigDone(bool success) {
     EXPECT_TRUE(success);
   }
 
   int64 CreateEntry(UserShare* user_share, ModelType type,
                     const std::string& client_tag) {
     WriteTransaction trans(FROM_HERE, user_share);
     ReadNode type_root(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               type_root.InitByTagLookup(ModelTypeToRootTag(type)));
 
     WriteNode node(&trans);
     EXPECT_EQ(WriteNode::INIT_SUCCESS,
               node.InitUniqueByCreation(type, type_root, client_tag));
     return node.GetEntry()->GetMetahandle();
   }
 
   void InitManager(SyncManager* manager, ModelTypeSet types,
                    TestChangeDelegate* delegate) {
+    manager->AddObserver(this);
     TestInternalComponentsFactory factory(InternalComponentsFactory::Switches(),
                                           STORAGE_ON_DISK);
 
     manager->Init(temp_dir_.path(),
                   MakeWeakHandle(base::WeakPtr<JsEventHandler>()),
                   "", 0, true, scoped_ptr<HttpPostProviderFactory>().Pass(),
                   std::vector<scoped_refptr<ModelSafeWorker> >(1,
                                                                worker_.get()),
                   NULL, delegate, SyncCredentials(), "", "", "", &factory,
                   NULL, scoped_ptr<UnrecoverableErrorHandler>().Pass(),
@@ skipping 23 matching lines @@
     ReadTransaction trans(FROM_HERE, user_share);
     ReadNode node(&trans);
     return BaseNode::INIT_OK == node.InitByClientTagLookup(type, client_tag);
   }
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<ModelSafeWorker> worker_;
   base::MessageLoop loop_;    // Needed for WeakHandle
 };
 
+bool IsRollbackDoneAction(SyncProtocolError e) {
+  return e.action == syncer::ROLLBACK_DONE;
+}
+
 TEST_F(SyncRollbackManagerTest, RollbackBasic) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
   SyncRollbackManager rollback_manager;
   InitManager(&rollback_manager, ModelTypeSet(PREFERENCES), &delegate);
 
   // Simulate a new entry added during type initialization.
   int64 new_pref_id =
       CreateEntry(rollback_manager.GetUserShare(), PREFERENCES, "pref2");
 
   delegate.add_expected_delete(new_pref_id);
   EXPECT_CALL(delegate, OnChangesApplied(_, _, _, _))
       .Times(1)
       .WillOnce(DoDefault());
   EXPECT_CALL(delegate, OnChangesComplete(_)).Times(1);
+  EXPECT_CALL(*this, OnActionableError(Truly(IsRollbackDoneAction))).Times(1);
 
   ModelSafeRoutingInfo routing_info;
   routing_info[PREFERENCES] = GROUP_UI;
   rollback_manager.StartSyncingNormally(routing_info);
 }
 
 TEST_F(SyncRollbackManagerTest, NoRollbackOfTypesNotBackedUp) {
   PrepopulateDb(PREFERENCES, "pref1");
 
   TestChangeDelegate delegate;
@@ skipping 36 matching lines @@
   // Verify new entry was not persisted.
   rollback_manager.reset(new SyncRollbackManager);
   InitManager(rollback_manager.get(), ModelTypeSet(PREFERENCES), &delegate);
   EXPECT_FALSE(VerifyEntry(rollback_manager->GetUserShare(), PREFERENCES,
                            "pref2"));
 }
 
 }  // anonymous namespace
 
 }  // namespace syncer