[Sync] Move ChangeRecord into its own file (change_record.{h,cc})

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>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
+#include "chrome/browser/sync/internal_api/change_record.h"
 #include "chrome/browser/sync/internal_api/http_post_provider_factory.h"
 #include "chrome/browser/sync/internal_api/http_post_provider_interface.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/js/js_arg_list.h"
 #include "chrome/browser/sync/js/js_backend.h"
 #include "chrome/browser/sync/js/js_event_handler.h"
@@ skipping 513 matching lines @@
   scoped_ptr<DictionaryValue> details(node.GetDetailsAsValue());
   if (details.get()) {
     CheckNodeValue(node, *details, true);
   } else {
     ADD_FAILURE();
   }
 }
 
 namespace {
 
-void ExpectChangeRecordActionValue(SyncManager::ChangeRecord::Action
-                                       expected_value,
+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 SyncManager::ChangeRecord::ACTION_ADD:
+    case ChangeRecord::ACTION_ADD:
       EXPECT_EQ("Add", str_value);
       break;
-    case SyncManager::ChangeRecord::ACTION_UPDATE:
+    case ChangeRecord::ACTION_UPDATE:
       EXPECT_EQ("Update", str_value);
       break;
-    case SyncManager::ChangeRecord::ACTION_DELETE:
+    case ChangeRecord::ACTION_DELETE:
       EXPECT_EQ("Delete", str_value);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-void CheckNonDeleteChangeRecordValue(const SyncManager::ChangeRecord& record,
+void CheckNonDeleteChangeRecordValue(const ChangeRecord& record,
                                      const DictionaryValue& value,
                                      BaseTransaction* trans) {
-  EXPECT_NE(SyncManager::ChangeRecord::ACTION_DELETE, record.action);
+  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 SyncManager::ChangeRecord& record,
+void CheckDeleteChangeRecordValue(const ChangeRecord& record,
                                   const DictionaryValue& value) {
-  EXPECT_EQ(SyncManager::ChangeRecord::ACTION_DELETE, record.action);
+  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 SyncManager::ExtraPasswordChangeRecordData {
+    : 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());
-    SyncManager::ChangeRecord record;
-    record.action = SyncManager::ChangeRecord::ACTION_ADD;
+    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());
-    SyncManager::ChangeRecord record;
-    record.action = SyncManager::ChangeRecord::ACTION_UPDATE;
+    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());
-    SyncManager::ChangeRecord record;
-    record.action = SyncManager::ChangeRecord::ACTION_DELETE;
+    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());
-    SyncManager::ChangeRecord record;
-    record.action = SyncManager::ChangeRecord::ACTION_DELETE;
+    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));
 
@@ skipping 38 matching lines @@
   virtual HttpPostProviderInterface* Create() OVERRIDE {
     return new TestHttpPostProviderInterface();
   }
   virtual void Destroy(HttpPostProviderInterface* http) OVERRIDE {
     delete http;
   }
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
-  MOCK_METHOD4(OnChangesApplied,
+  MOCK_METHOD3(OnChangesApplied,
                void(ModelType,
                     const BaseTransaction*,
-                    const SyncManager::ChangeRecord*,
-                    int));  // NOLINT
+                    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
-  MOCK_METHOD1(OnMigrationNeededForTypes, void(const ModelTypeSet&));
   MOCK_METHOD0(OnClearServerDataFailed, void());  // NOLINT
   MOCK_METHOD0(OnClearServerDataSucceeded, void());  // NOLINT
   MOCK_METHOD1(OnEncryptionComplete, void(const ModelTypeSet&));  // NOLINT
   MOCK_METHOD1(OnActionableError,
                  void(const browser_sync::SyncProtocolError&));  // NOLINT
 };
 
 class SyncNotifierMock : public sync_notifier::SyncNotifier {
  public:
   MOCK_METHOD1(AddObserver, void(sync_notifier::SyncNotifierObserver*));
@@ skipping 60 matching lines @@
 
     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, _, _, 1))
+      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() {
@@ skipping 707 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