[Sync] Move change-related methods out of SyncManager::Observer

chrome/browser/sync/internal_api/syncapi_unittest.cc

 // Copyright (c) 2011 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 54 matching lines @@
 using browser_sync::MockJsReplyHandler;
 using browser_sync::ModelSafeRoutingInfo;
 using browser_sync::ModelSafeWorker;
 using browser_sync::ModelSafeWorkerRegistrar;
 using browser_sync::sessions::SyncSessionSnapshot;
 using browser_sync::WeakHandle;
 using syncable::GetAllRealModelTypes;
 using syncable::kEncryptedString;
 using syncable::ModelType;
 using syncable::ModelTypeSet;
-using test::ExpectDictDictionaryValue;
 using test::ExpectDictStringValue;
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::InSequence;
 using testing::Invoke;
 using testing::SaveArg;
 using testing::StrictMock;
 
 namespace sync_api {
@@ skipping 464 matching lines @@
   scoped_ptr<DictionaryValue> details(node.GetDetailsAsValue());
   if (details.get()) {
     CheckNodeValue(node, *details, true);
   } else {
     ADD_FAILURE();
   }
 }
 
 namespace {
 
-void ExpectChangeRecordActionValue(ChangeRecord::Action
-                                       expected_value,
-                                   const DictionaryValue& value,
-                                   const std::string& key) {
-  std::string str_value;
-  EXPECT_TRUE(value.GetString(key, &str_value));
-  switch (expected_value) {
-    case ChangeRecord::ACTION_ADD:
-      EXPECT_EQ("Add", str_value);
-      break;
-    case ChangeRecord::ACTION_UPDATE:
-      EXPECT_EQ("Update", str_value);
-      break;
-    case ChangeRecord::ACTION_DELETE:
-      EXPECT_EQ("Delete", str_value);
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-void CheckNonDeleteChangeRecordValue(const ChangeRecord& record,
-                                     const DictionaryValue& value,
-                                     BaseTransaction* trans) {
-  EXPECT_NE(ChangeRecord::ACTION_DELETE, record.action);
-  ExpectChangeRecordActionValue(record.action, value, "action");
-  {
-    ReadNode node(trans);
-    EXPECT_TRUE(node.InitByIdLookup(record.id));
-    scoped_ptr<DictionaryValue> expected_details(node.GetDetailsAsValue());
-    ExpectDictDictionaryValue(*expected_details, value, "node");
-  }
-}
-
-void CheckDeleteChangeRecordValue(const ChangeRecord& record,
-                                  const DictionaryValue& value) {
-  EXPECT_EQ(ChangeRecord::ACTION_DELETE, record.action);
-  ExpectChangeRecordActionValue(record.action, value, "action");
-  DictionaryValue* node_value = NULL;
-  EXPECT_TRUE(value.GetDictionary("node", &node_value));
-  if (node_value) {
-    ExpectInt64Value(record.id, *node_value, "id");
-    scoped_ptr<DictionaryValue> expected_specifics_value(
-        browser_sync::EntitySpecificsToValue(record.specifics));
-    ExpectDictDictionaryValue(*expected_specifics_value,
-                              *node_value, "specifics");
-    scoped_ptr<DictionaryValue> expected_extra_value;
-    if (record.extra.get()) {
-      expected_extra_value.reset(record.extra->ToValue());
-    }
-    Value* extra_value = NULL;
-    EXPECT_EQ(record.extra.get() != NULL,
-              node_value->Get("extra", &extra_value));
-    EXPECT_TRUE(Value::Equals(extra_value, expected_extra_value.get()));
-  }
-}
-
-class MockExtraChangeRecordData
-    : public ExtraPasswordChangeRecordData {
- public:
-  MOCK_CONST_METHOD0(ToValue, DictionaryValue*());
-};
-
-}  // namespace
-
-TEST_F(SyncApiTest, ChangeRecordToValue) {
-  int64 child_id = MakeNode(test_user_share_.user_share(),
-                            syncable::BOOKMARKS, "testtag");
-  sync_pb::EntitySpecifics child_specifics;
-  {
-    ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(child_id));
-    child_specifics = node.GetEntry()->Get(syncable::SPECIFICS);
-  }
-
-  // Add
-  {
-    ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    ChangeRecord record;
-    record.action = ChangeRecord::ACTION_ADD;
-    record.id = 1;
-    record.specifics = child_specifics;
-    record.extra.reset(new StrictMock<MockExtraChangeRecordData>());
-    scoped_ptr<DictionaryValue> value(record.ToValue(&trans));
-    CheckNonDeleteChangeRecordValue(record, *value, &trans);
-  }
-
-  // Update
-  {
-    ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    ChangeRecord record;
-    record.action = ChangeRecord::ACTION_UPDATE;
-    record.id = child_id;
-    record.specifics = child_specifics;
-    record.extra.reset(new StrictMock<MockExtraChangeRecordData>());
-    scoped_ptr<DictionaryValue> value(record.ToValue(&trans));
-    CheckNonDeleteChangeRecordValue(record, *value, &trans);
-  }
-
-  // Delete (no extra)
-  {
-    ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    ChangeRecord record;
-    record.action = ChangeRecord::ACTION_DELETE;
-    record.id = child_id + 1;
-    record.specifics = child_specifics;
-    scoped_ptr<DictionaryValue> value(record.ToValue(&trans));
-    CheckDeleteChangeRecordValue(record, *value);
-  }
-
-  // Delete (with extra)
-  {
-    ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    ChangeRecord record;
-    record.action = ChangeRecord::ACTION_DELETE;
-    record.id = child_id + 1;
-    record.specifics = child_specifics;
-
-    DictionaryValue extra_value;
-    extra_value.SetString("foo", "bar");
-    scoped_ptr<StrictMock<MockExtraChangeRecordData> > extra(
-        new StrictMock<MockExtraChangeRecordData>());
-    EXPECT_CALL(*extra, ToValue()).Times(2).WillRepeatedly(
-        Invoke(&extra_value, &DictionaryValue::DeepCopy));
-
-    record.extra.reset(extra.release());
-    scoped_ptr<DictionaryValue> value(record.ToValue(&trans));
-    CheckDeleteChangeRecordValue(record, *value);
-  }
-}
-
-namespace {
-
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
 
   virtual void SetUserAgent(const char* user_agent) OVERRIDE {}
   virtual void SetExtraRequestHeaders(const char* headers) OVERRIDE {}
   virtual void SetURL(const char* url, int port) OVERRIDE {}
   virtual void SetPostPayload(const char* content_type,
                               int content_length,
                               const char* content) OVERRIDE {}
@@ skipping 20 matching lines @@
   virtual HttpPostProviderInterface* Create() OVERRIDE {
     return new TestHttpPostProviderInterface();
   }
   virtual void Destroy(HttpPostProviderInterface* http) OVERRIDE {
     delete http;
   }
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
-  MOCK_METHOD3(OnChangesApplied,
-               void(ModelType,
-                    const BaseTransaction*,
-                    const ImmutableChangeRecordList&));  // NOLINT
-  MOCK_METHOD1(OnChangesComplete, void(ModelType));  // NOLINT
   MOCK_METHOD1(OnSyncCycleCompleted,
                void(const SyncSessionSnapshot*));  // NOLINT
   MOCK_METHOD2(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&, bool));  // NOLINT
   MOCK_METHOD1(OnAuthError, void(const GoogleServiceAuthError&));  // NOLINT
   MOCK_METHOD1(OnPassphraseRequired,
                void(sync_api::PassphraseRequiredReason));  // NOLINT
   MOCK_METHOD1(OnPassphraseAccepted, void(const std::string&));  // NOLINT
   MOCK_METHOD0(OnStopSyncingPermanently, void());  // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
@@ skipping 12 matching lines @@
   MOCK_METHOD1(SetUniqueId, void(const std::string&));
   MOCK_METHOD1(SetState, void(const std::string&));
   MOCK_METHOD2(UpdateCredentials,
                void(const std::string&, const std::string&));
   MOCK_METHOD1(UpdateEnabledTypes,
                void(const syncable::ModelTypeSet&));
   MOCK_METHOD1(SendNotification, void(const syncable::ModelTypeSet&));
 };
 
 class SyncManagerTest : public testing::Test,
-                        public ModelSafeWorkerRegistrar {
+                        public ModelSafeWorkerRegistrar,
+                        public SyncManager::ChangeDelegate {
  protected:
   SyncManagerTest()
       : ui_thread_(BrowserThread::UI, &ui_loop_),
         sync_notifier_mock_(NULL),
         sync_manager_("Test sync manager"),
         sync_notifier_observer_(NULL),
         update_enabled_types_call_count_(0) {}
 
   virtual ~SyncManagerTest() {
     EXPECT_FALSE(sync_notifier_mock_);
@@ skipping 25 matching lines @@
     EXPECT_CALL(observer_, OnInitializationComplete(_, _)).
         WillOnce(SaveArg<0>(&js_backend_));
 
     EXPECT_FALSE(sync_notifier_observer_);
     EXPECT_FALSE(js_backend_.IsInitialized());
 
     // Takes ownership of |sync_notifier_mock_|.
     sync_manager_.Init(temp_dir_.path(),
                        WeakHandle<JsEventHandler>(),
                        "bogus", 0, false,
-                       new TestHttpPostProviderFactory(), this, "bogus",
+                       new TestHttpPostProviderFactory(), this, this, "bogus",
                        credentials, sync_notifier_mock_, "",
                        true /* setup_for_test_mode */);
 
     EXPECT_TRUE(sync_notifier_observer_);
     EXPECT_TRUE(js_backend_.IsInitialized());
 
     EXPECT_EQ(1, update_enabled_types_call_count_);
 
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
     for (ModelSafeRoutingInfo::iterator i = routes.begin(); i != routes.end();
          ++i) {
-      EXPECT_CALL(observer_, OnChangesApplied(i->first, _, _))
-          .RetiresOnSaturation();
-      EXPECT_CALL(observer_, OnChangesComplete(i->first))
-          .RetiresOnSaturation();
       type_roots_[i->first] = MakeServerNodeForType(
           sync_manager_.GetUserShare(), i->first);
     }
     PumpLoop();
   }
 
   void TearDown() {
     sync_manager_.RemoveObserver(&observer_);
     sync_manager_.Shutdown();
     sync_notifier_mock_ = NULL;
     EXPECT_FALSE(sync_notifier_observer_);
     PumpLoop();
   }
 
   // ModelSafeWorkerRegistrar implementation.
-  virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) {
+  virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) OVERRIDE {
     NOTIMPLEMENTED();
     out->clear();
   }
-  virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
+  virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) OVERRIDE {
     (*out)[syncable::NIGORI] = browser_sync::GROUP_PASSIVE;
     (*out)[syncable::BOOKMARKS] = browser_sync::GROUP_PASSIVE;
     (*out)[syncable::THEMES] = browser_sync::GROUP_PASSIVE;
     (*out)[syncable::SESSIONS] = browser_sync::GROUP_PASSIVE;
     (*out)[syncable::PASSWORDS] = browser_sync::GROUP_PASSIVE;
   }
 
+  virtual void OnChangesApplied(
+      syncable::ModelType model_type,
+      const BaseTransaction* trans,
+      const ImmutableChangeRecordList& changes) OVERRIDE {}
+
+  virtual void OnChangesComplete(syncable::ModelType model_type) OVERRIDE {}
+
   // Helper methods.
   bool SetUpEncryption() {
     // Mock the Mac Keychain service. The real Keychain can block on user input.
     #if defined(OS_MACOSX)
       Encryptor::UseMockKeychain(true);
     #endif
 
     // We need to create the nigori node as if it were an applied server update.
     UserShare* share = sync_manager_.GetUserShare();
     int64 nigori_id = GetIdForDataType(syncable::NIGORI);
@@ skipping 677 matching lines @@
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(node1));
     EXPECT_EQ(syncable::BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
   }
 }
 
 }  // namespace browser_sync