Refactor syncable DEVICE_INFO type from ChangeProcessor to SyncableService - part 3.

chrome/browser/sync/glue/device_info_sync_service_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 "base/message_loop/message_loop.h"
 #include "chrome/browser/sync/glue/device_info_sync_service.h"
 #include "chrome/browser/sync/glue/local_device_info_provider_mock.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
+#include "sync/util/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using syncer::AttachmentIdList;
 using syncer::AttachmentServiceProxyForTest;
 using syncer::ModelType;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 using syncer::SyncChangeProcessor;
 using syncer::SyncChangeProcessorWrapperForTest;
 using syncer::SyncData;
@@ skipping 81 matching lines @@
   scoped_ptr<SyncChangeProcessor> PassProcessor() {
     return scoped_ptr<SyncChangeProcessor>(
         new SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   }
 
   scoped_ptr<SyncErrorFactory> CreateAndPassSyncErrorFactory() {
     return scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock());
   }
 
   SyncData CreateRemoteData(const std::string& client_id,
-                            const std::string& client_name) {
+                            const std::string& client_name,
+                            int64 backup_timestamp = 0) {
     sync_pb::EntitySpecifics entity;
     sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info();
 
     specifics.set_cache_guid(client_id);
     specifics.set_client_name(client_name);
     specifics.set_chrome_version("Chromium 10k");
     specifics.set_sync_user_agent("Chrome 10k");
     specifics.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
     specifics.set_signin_scoped_device_id("device_id");
 
+    if (backup_timestamp != 0) {
+      specifics.set_backup_timestamp(backup_timestamp);
+    }
+
     return SyncData::CreateRemoteData(1,
                                       entity,
                                       base::Time(),
                                       AttachmentIdList(),
                                       AttachmentServiceProxyForTest::Create());
   }
 
   void AddInitialData(SyncDataList& sync_data_list,
                       const std::string& client_id,
                       const std::string& client_name) {
@@ skipping 257 matching lines @@
   // Unsubscribe observer before processing changes.
   sync_service_->RemoveObserver(this);
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   // The number of callback should still be zero.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
 }
 
+// Verifies setting backup timestamp after the initial sync.
+TEST_F(DeviceInfoSyncServiceTest, UpdateLocalDeviceBackupTime) {
+  // Shouldn't have backuptime initially.
+  base::Time backup_time = sync_service_->GetLocalDeviceBackupTime();
+  EXPECT_TRUE(backup_time.is_null());
+
+  // Perform the initial sync with empty data.
+  SyncMergeResult merge_result =
+      sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
+                                              SyncDataList(),
+                                              PassProcessor(),
+                                              CreateAndPassSyncErrorFactory());
+
+  // Should have local device after the initial sync.
+  EXPECT_EQ(1U, sync_processor_->change_list_size());
+  EXPECT_EQ(SyncChange::ACTION_ADD, sync_processor_->change_type_at(0));
+
+  // Shouldn't have backup time initially.
+  EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
+  EXPECT_FALSE(sync_processor_->device_info_at(0).has_backup_timestamp());
+
+  sync_service_->UpdateLocalDeviceBackupTime(base::Time::FromTimeT(1000));
+
+  // Should have local device info updated with the specified backup timestamp.
+  EXPECT_EQ(1U, sync_processor_->change_list_size());
+  EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0));
+  EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
+  EXPECT_TRUE(sync_processor_->device_info_at(0).has_backup_timestamp());
+
+  backup_time = syncer::ProtoTimeToTime(
+      sync_processor_->device_info_at(0).backup_timestamp());
+  EXPECT_EQ(1000, backup_time.ToTimeT());
+
+  // Also verify that we get the same backup time directly from the service.
+  backup_time = sync_service_->GetLocalDeviceBackupTime();
+  EXPECT_EQ(1000, backup_time.ToTimeT());
+}
+
+// Verifies setting backup timestamp prior to the initial sync.
+TEST_F(DeviceInfoSyncServiceTest, UpdateLocalDeviceBackupTimeBeforeSync) {
+  // Set the backup timestamp.
+  sync_service_->UpdateLocalDeviceBackupTime(base::Time::FromTimeT(2000));
+  // Verify that we get it back.
+  base::Time backup_time = sync_service_->GetLocalDeviceBackupTime();
+  EXPECT_EQ(2000, backup_time.ToTimeT());
+
+  // Now perform the initial sync with empty data.
+  SyncMergeResult merge_result =
+      sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
+                                              SyncDataList(),
+                                              PassProcessor(),
+                                              CreateAndPassSyncErrorFactory());
+
+  // Should have local device after the initial sync.
+  // Should have the backup timestamp set.
+  EXPECT_EQ(1U, sync_processor_->change_list_size());
+  EXPECT_EQ(SyncChange::ACTION_ADD, sync_processor_->change_type_at(0));
+  EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
+  EXPECT_TRUE(sync_processor_->device_info_at(0).has_backup_timestamp());
+
+  backup_time = syncer::ProtoTimeToTime(
+      sync_processor_->device_info_at(0).backup_timestamp());
+  EXPECT_EQ(2000, backup_time.ToTimeT());
+}
+
+// Verifies that the backup timestamp that comes in the intial sync data
+// gets preserved when there are no changes to the local device.
+TEST_F(DeviceInfoSyncServiceTest, PreserveBackupTimeWithMatchingLocalDevice) {
+  base::Time backup_time = base::Time::FromTimeT(3000);
+  SyncDataList sync_data;
+  sync_data.push_back(CreateRemoteData(
+      "guid_1", "client_1", syncer::TimeToProtoTime(backup_time)));
+
+  SyncMergeResult merge_result =
+      sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
+                                              sync_data,
+                                              PassProcessor(),
+                                              CreateAndPassSyncErrorFactory());
+
+  // Everything is matching so there should be no updates.
+  EXPECT_EQ(0U, sync_processor_->change_list_size());
+
+  // Verify that we get back the same time.
+  backup_time = sync_service_->GetLocalDeviceBackupTime();
+  EXPECT_EQ(3000, backup_time.ToTimeT());
+}
+
+// Verifies that the backup timestamp that comes in the intial sync data
+// gets merged with the local device data.
+TEST_F(DeviceInfoSyncServiceTest, MergeBackupTimeWithMatchingLocalDevice) {
+  base::Time backup_time = base::Time::FromTimeT(4000);
+  SyncDataList sync_data;
+  sync_data.push_back(CreateRemoteData(
+      "guid_1", "foo_1", syncer::TimeToProtoTime(backup_time)));
+
+  SyncMergeResult merge_result =
+      sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
+                                              sync_data,
+                                              PassProcessor(),
+                                              CreateAndPassSyncErrorFactory());
+
+  // Should be one change because of the client name mismatch.
+  // However the backup time passed in the initial data should be merged into
+  // the change.
+  EXPECT_EQ(1U, sync_processor_->change_list_size());
+
+  EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0));
+  EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
+  EXPECT_EQ("client_1", sync_processor_->client_name_at(0));
+
+  backup_time = syncer::ProtoTimeToTime(
+      sync_processor_->device_info_at(0).backup_timestamp());
+  EXPECT_EQ(4000, backup_time.ToTimeT());
+}
+
+// Verifies that mismatching backup timestamp generates an update even
+// when the rest of local device data is matching.
+TEST_F(DeviceInfoSyncServiceTest,
+       MergeMismatchingBackupTimeWithMatchingLocalDevice) {
+  base::Time backup_time = base::Time::FromTimeT(5000);
+  SyncDataList sync_data;
+  sync_data.push_back(CreateRemoteData(
+      "guid_1", "client_1", syncer::TimeToProtoTime(backup_time)));
+
+  // Set the backup timestamp different than the one in the sync data.
+  sync_service_->UpdateLocalDeviceBackupTime(base::Time::FromTimeT(6000));
+
+  SyncMergeResult merge_result =
+      sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
+                                              sync_data,
+                                              PassProcessor(),
+                                              CreateAndPassSyncErrorFactory());
+
+  // Should generate and update due to timestamp mismatch.
+  // The locally set timestamp wins.
+  EXPECT_EQ(1U, sync_processor_->change_list_size());
+
+  EXPECT_EQ(SyncChange::ACTION_UPDATE, sync_processor_->change_type_at(0));
+  EXPECT_EQ("guid_1", sync_processor_->cache_guid_at(0));
+  EXPECT_EQ("client_1", sync_processor_->client_name_at(0));
+
+  backup_time = syncer::ProtoTimeToTime(
+      sync_processor_->device_info_at(0).backup_timestamp());
+  EXPECT_EQ(6000, backup_time.ToTimeT());
+}
+
 }  // namespace
 
 }  // namespace browser_sync