[Sync] Fixing sync_driver lint violations and adding PRESUBMIT lint check.

components/sync_driver/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 "components/sync_driver/device_info_sync_service.h"
+
+#include <string>
+
 #include "base/message_loop/message_loop.h"
-#include "components/sync_driver/device_info_sync_service.h"
 #include "components/sync_driver/local_device_info_provider_mock.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;
@@ skipping 106 matching lines @@
       specifics.set_backup_timestamp(backup_timestamp);
     }
 
     return SyncData::CreateRemoteData(1,
                                       entity,
                                       base::Time(),
                                       AttachmentIdList(),
                                       AttachmentServiceProxyForTest::Create());
   }
 
-  void AddInitialData(SyncDataList& sync_data_list,
+  void AddInitialData(SyncDataList* sync_data_list,
                       const std::string& client_id,
                       const std::string& client_name) {
     SyncData sync_data = CreateRemoteData(client_id, client_name);
-    sync_data_list.push_back(sync_data);
+    sync_data_list->push_back(sync_data);
   }
 
-  void AddChange(SyncChangeList& change_list,
+  void AddChange(SyncChangeList* change_list,
                  SyncChange::SyncChangeType change_type,
                  const std::string& client_id,
                  const std::string& client_name) {
     SyncData sync_data = CreateRemoteData(client_id, client_name);
     SyncChange sync_change(FROM_HERE, change_type, sync_data);
-    change_list.push_back(sync_change);
+    change_list->push_back(sync_change);
   }
 
  protected:
   int num_device_info_changed_callbacks_;
   base::MessageLoopForUI message_loop_;
   scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
   scoped_ptr<DeviceInfoSyncService> sync_service_;
   scoped_ptr<TestChangeProcessor> sync_processor_;
 };
 
@@ skipping 32 matching lines @@
   EXPECT_TRUE(sync_service_->IsSyncing());
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   sync_service_->StopSyncing(syncer::DEVICE_INFO);
   EXPECT_FALSE(sync_service_->IsSyncing());
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
 }
 
 // Sync with initial data matching the local device data.
 TEST_F(DeviceInfoSyncServiceTest, StartSyncMatchingInitialData) {
   SyncDataList sync_data;
-  AddInitialData(sync_data, "guid_1", "client_1");
+  AddInitialData(&sync_data, "guid_1", "client_1");
 
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               sync_data,
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(1, merge_result.num_items_before_association());
   EXPECT_EQ(1, merge_result.num_items_after_association());
 
   // No changes expected because the device info matches.
   EXPECT_EQ(0U, sync_processor_->change_list_size());
 
   EXPECT_EQ(1U, sync_service_->GetAllSyncData(syncer::DEVICE_INFO).size());
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 // Sync with misc initial data.
 TEST_F(DeviceInfoSyncServiceTest, StartSync) {
   SyncDataList sync_data;
-  AddInitialData(sync_data, "guid_2", "foo");
-  AddInitialData(sync_data, "guid_3", "bar");
+  AddInitialData(&sync_data, "guid_2", "foo");
+  AddInitialData(&sync_data, "guid_3", "bar");
   // This guid matches the local device but the client name is different.
-  AddInitialData(sync_data, "guid_1", "baz");
+  AddInitialData(&sync_data, "guid_1", "baz");
 
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               sync_data,
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(2, merge_result.num_items_added());
   EXPECT_EQ(1, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
@@ skipping 22 matching lines @@
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               SyncDataList(),
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   // There should be only one item corresponding to the local device
   EXPECT_EQ(1, merge_result.num_items_after_association());
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
 
   // Add a new device info with a non-matching guid.
   SyncChangeList change_list;
-  AddChange(change_list, SyncChange::ACTION_ADD, "guid_2", "foo");
+  AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
 
   EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size());
 
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_1"));
   EXPECT_TRUE(sync_service_->GetDeviceInfo("guid_2"));
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_0"));
 }
 
 // Process multiple sync change with ACTION_UPDATE and ACTION_ADD.
 // Verify that callback is called multiple times.
 TEST_F(DeviceInfoSyncServiceTest, ProcessMultipleChanges) {
   SyncDataList sync_data;
-  AddInitialData(sync_data, "guid_2", "foo");
-  AddInitialData(sync_data, "guid_3", "bar");
+  AddInitialData(&sync_data, "guid_2", "foo");
+  AddInitialData(&sync_data, "guid_3", "bar");
 
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               sync_data,
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(3, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
-  AddChange(change_list, SyncChange::ACTION_UPDATE, "guid_2", "foo_2");
+  AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   EXPECT_EQ(3U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("foo_2", sync_service_->GetDeviceInfo("guid_2")->client_name());
 
   change_list.clear();
-  AddChange(change_list, SyncChange::ACTION_UPDATE, "guid_3", "bar_3");
-  AddChange(change_list, SyncChange::ACTION_ADD, "guid_4", "baz_4");
+  AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_3", "bar_3");
+  AddChange(&change_list, SyncChange::ACTION_ADD, "guid_4", "baz_4");
 
   error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(2, num_device_info_changed_callbacks_);
   EXPECT_EQ(4U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("bar_3", sync_service_->GetDeviceInfo("guid_3")->client_name());
   EXPECT_EQ("baz_4", sync_service_->GetDeviceInfo("guid_4")->client_name());
 }
 
 // Process update to the local device info and verify that it is ignored.
 TEST_F(DeviceInfoSyncServiceTest, ProcessUpdateChangeMatchingLocalDevice) {
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               SyncDataList(),
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
-  AddChange(change_list, SyncChange::ACTION_UPDATE, "guid_1", "foo_1");
+  AddChange(&change_list, SyncChange::ACTION_UPDATE, "guid_1", "foo_1");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
   // Callback shouldn't be sent in this case.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
   // Should still have the old local device Info.
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_EQ("client_1", sync_service_->GetDeviceInfo("guid_1")->client_name());
 }
 
 // Process sync change with ACTION_DELETE.
 TEST_F(DeviceInfoSyncServiceTest, ProcessDeleteChange) {
   SyncDataList sync_data;
-  AddInitialData(sync_data, "guid_2", "foo");
-  AddInitialData(sync_data, "guid_3", "bar");
+  AddInitialData(&sync_data, "guid_2", "foo");
+  AddInitialData(&sync_data, "guid_3", "bar");
 
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               sync_data,
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(3, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
-  AddChange(change_list, SyncChange::ACTION_DELETE, "guid_2", "foo_2");
+  AddChange(&change_list, SyncChange::ACTION_DELETE, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(1, num_device_info_changed_callbacks_);
   EXPECT_EQ(2U, sync_service_->GetAllDeviceInfo().size());
   EXPECT_FALSE(sync_service_->GetDeviceInfo("guid_2"));
 }
 
 // Process sync change with unexpected action.
 TEST_F(DeviceInfoSyncServiceTest, ProcessInvalidChange) {
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               SyncDataList(),
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
-  AddChange(change_list, (SyncChange::SyncChangeType)100, "guid_2", "foo_2");
+  AddChange(&change_list, (SyncChange::SyncChangeType)100, "guid_2", "foo_2");
 
   SyncError error = sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_TRUE(error.IsSet());
 
   // The number of callback should still be zero.
   EXPECT_EQ(0, num_device_info_changed_callbacks_);
   EXPECT_EQ(1U, sync_service_->GetAllDeviceInfo().size());
 }
 
 // Process sync change after unsubscribing from notifications.
 TEST_F(DeviceInfoSyncServiceTest, ProcessChangesAfterUnsubscribing) {
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
                                               SyncDataList(),
                                               PassProcessor(),
                                               CreateAndPassSyncErrorFactory());
   EXPECT_EQ(1, merge_result.num_items_after_association());
   // reset callbacks counter
   num_device_info_changed_callbacks_ = 0;
 
   SyncChangeList change_list;
-  AddChange(change_list, SyncChange::ACTION_ADD, "guid_2", "foo_2");
+  AddChange(&change_list, SyncChange::ACTION_ADD, "guid_2", "foo_2");
 
   // 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_);
 }
@@ skipping 140 matching lines @@
   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 sync_driver