[Sync] Convert SyncSessionSnapshot to a copy-able class.

sync/engine/sync_scheduler_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 27 matching lines @@
 
 class MockSyncer : public Syncer {
  public:
   MOCK_METHOD3(SyncShare, void(sessions::SyncSession*, SyncerStep,
                                SyncerStep));
 };
 
 // Used when tests want to record syncing activity to examine later.
 struct SyncShareRecords {
   std::vector<TimeTicks> times;
-  std::vector<linked_ptr<SyncSessionSnapshot> > snapshots;
+  std::vector<SyncSessionSnapshot> snapshots;
 };
 
 void QuitLoopNow() {
   // We use QuitNow() instead of Quit() as the latter may get stalled
   // indefinitely in the presence of repeated timers with low delays
   // and a slow test (e.g., ThrottlingDoesThrottle [which has a poll
   // delay of 5ms] run under TSAN on the trybots).
   MessageLoop::current()->QuitNow();
 }
 
@@ skipping 64 matching lines @@
 
   void AnalyzePollRun(const SyncShareRecords& records, size_t min_num_samples,
       const TimeTicks& optimal_start, const TimeDelta& poll_interval) {
     const std::vector<TimeTicks>& data(records.times);
     EXPECT_GE(data.size(), min_num_samples);
     for (size_t i = 0; i < data.size(); i++) {
       SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
       TimeTicks optimal_next_sync = optimal_start + poll_interval * i;
       EXPECT_GE(data[i], optimal_next_sync);
       EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
-                records.snapshots[i]->source.updates_source);
+                records.snapshots[i].source().updates_source);
     }
   }
 
   void DoQuitLoopNow() {
     QuitLoopNow();
   }
 
   void StartSyncScheduler(SyncScheduler::Mode mode) {
     scheduler()->Start(
         mode,
@@ skipping 69 matching lines @@
   }
 
   void TearDown() {
     StopSyncScheduler();
     SyncSchedulerTest::TearDown();
   }
 };
 
 void RecordSyncShareImpl(SyncSession* s, SyncShareRecords* record) {
   record->times.push_back(TimeTicks::Now());
-  record->snapshots.push_back(make_linked_ptr(new SyncSessionSnapshot(
-      s->TakeSnapshot())));
+  record->snapshots.push_back(s->TakeSnapshot());
 }
 
 ACTION_P(RecordSyncShare, record) {
   RecordSyncShareImpl(arg0, record);
   QuitLoopNow();
 }
 
 ACTION_P2(RecordSyncShareMultiple, record, quit_after) {
   RecordSyncShareImpl(arg0, record);
   EXPECT_LE(record->times.size(), quit_after);
@@ skipping 23 matching lines @@
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records.snapshots[0]->source.types));
+      records.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records.snapshots[0]->source.updates_source);
+            records.snapshots[0].source().updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareRecords records2;
   model_types.Remove(syncable::BOOKMARKS);
   model_types.Put(syncable::AUTOFILL);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records2.snapshots[0]->source.types));
+      records2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records2.snapshots[0]->source.updates_source);
+            records2.snapshots[0].source().updates_source);
 }
 
 // Make sure a regular config command is scheduled fine in the absence of any
 // errors.
 TEST_F(SyncSchedulerTest, Config) {
   SyncShareRecords records;
   const ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records.snapshots[0]->source.types));
+      records.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[0]->source.updates_source);
+            records.snapshots[0].source().updates_source);
 }
 
 // Simulate a failure and make sure the config request is retried.
 TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
   SyncShareRecords records;
   const ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
   scheduler()->ScheduleConfig(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records.snapshots[1]->source.types));
+      records.snapshots[1].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[1]->source.updates_source);
+            records.snapshots[1].source().updates_source);
 }
 
 // Issue 2 config commands. Second one right after the first has failed
 // and make sure LATEST is executed.
 TEST_F(SyncSchedulerTest, MultipleConfigWithBackingOff) {
   const ModelTypeSet
       model_types1(syncable::BOOKMARKS),
       model_types2(syncable::AUTOFILL);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
@@ skipping 19 matching lines @@
   ASSERT_EQ(1U, records.snapshots.size());
   scheduler()->ScheduleConfig(
       model_types2, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(3U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types2,
-      records.snapshots[2]->source.types));
+      records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[2]->source.updates_source);
+            records.snapshots[2].source().updates_source);
 }
 
 // Issue a nudge when the config has failed. Make sure both the config and
 // nudge are executed.
 TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
   const ModelTypeSet model_types(syncable::BOOKMARKS);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(50)));
   SyncShareRecords records;
@@ skipping 25 matching lines @@
   RunLoop();
 
   // Now change the mode so nudge can execute.
   ASSERT_EQ(3U, records.snapshots.size());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   ASSERT_EQ(4U, records.snapshots.size());
 
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records.snapshots[2]->source.types));
+      records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[2]->source.updates_source);
+            records.snapshots[2].source().updates_source);
 
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
-      records.snapshots[3]->source.types));
+      records.snapshots[3].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records.snapshots[3]->source.updates_source);
+            records.snapshots[3].source().updates_source);
 
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   const ModelTypeSet
       types1(syncable::BOOKMARKS),
       types2(syncable::AUTOFILL),
       types3(syncable::THEMES);
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
   scheduler()->ScheduleNudge(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(
-      Union(types1, types2), r.snapshots[0]->source.types));
+      Union(types1, types2), r.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0]->source.updates_source);
+            r.snapshots[0].source().updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   SyncShareRecords r2;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r2))));
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(types3,
-      r2.snapshots[0]->source.types));
+      r2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
-            r2.snapshots[0]->source.updates_source);
+            r2.snapshots[0].source().updates_source);
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
@@ skipping 11 matching lines @@
       zero(), NUDGE_SOURCE_UNKNOWN, types2, FROM_HERE);
 
   TimeTicks min_time = TimeTicks::Now();
   TimeTicks max_time = TimeTicks::Now() + delay;
 
   RunLoop();
 
   // Make sure the sync has happened.
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(
-      Union(types1, types2), r.snapshots[0]->source.types));
+      Union(types1, types2), r.snapshots[0].source().types));
 
   // Make sure the sync happened at the right time.
   EXPECT_GE(r.times[0], min_time);
   EXPECT_LE(r.times[0], max_time);
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, NudgeWithPayloads) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   SyncShareRecords records;
   syncable::ModelTypePayloadMap model_types_with_payloads;
   model_types_with_payloads[syncable::BOOKMARKS] = "test";
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
   scheduler()->ScheduleNudgeWithPayloads(
       zero(), NUDGE_SOURCE_LOCAL, model_types_with_payloads, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_EQ(model_types_with_payloads, records.snapshots[0]->source.types);
+  EXPECT_EQ(model_types_with_payloads, records.snapshots[0].source().types);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records.snapshots[0]->source.updates_source);
+            records.snapshots[0].source().updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareRecords records2;
   model_types_with_payloads.erase(syncable::BOOKMARKS);
   model_types_with_payloads[syncable::AUTOFILL] = "test2";
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
   scheduler()->ScheduleNudgeWithPayloads(
       zero(), NUDGE_SOURCE_LOCAL, model_types_with_payloads, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_EQ(model_types_with_payloads, records2.snapshots[0]->source.types);
+  EXPECT_EQ(model_types_with_payloads, records2.snapshots[0].source().types);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records2.snapshots[0]->source.updates_source);
+            records2.snapshots[0].source().updates_source);
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeWithPayloadsCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   syncable::ModelTypePayloadMap types1, types2, types3;
   types1[syncable::BOOKMARKS] = "test1";
   types2[syncable::AUTOFILL] = "test2";
   types3[syncable::THEMES] = "test3";
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
   scheduler()->ScheduleNudgeWithPayloads(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
   scheduler()->ScheduleNudgeWithPayloads(
       zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
   syncable::ModelTypePayloadMap coalesced_types;
   syncable::CoalescePayloads(&coalesced_types, types1);
   syncable::CoalescePayloads(&coalesced_types, types2);
-  EXPECT_EQ(coalesced_types, r.snapshots[0]->source.types);
+  EXPECT_EQ(coalesced_types, r.snapshots[0].source().types);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0]->source.updates_source);
+            r.snapshots[0].source().updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   SyncShareRecords r2;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r2))));
   scheduler()->ScheduleNudgeWithPayloads(
       zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_EQ(types3, r2.snapshots[0]->source.types);
+  EXPECT_EQ(types3, r2.snapshots[0].source().types);
   EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
-            r2.snapshots[0]->source.updates_source);
+            r2.snapshots[0].source().updates_source);
 }
 
 // Test that polling works as expected.
 TEST_F(SyncSchedulerTest, Polling) {
   SyncShareRecords records;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
            WithArg<0>(RecordSyncShareMultiple(&records, kMinNumSamples))));
 
@@ skipping 172 matching lines @@
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
 
   const ModelTypeSet config_types(syncable::BOOKMARKS);
 
   scheduler()->ScheduleConfig(
       config_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(config_types,
-      records.snapshots[0]->source.types));
+      records.snapshots[0].source().types));
 }
 
 // Have the sycner fail during commit.  Expect that the scheduler enters
 // backoff.
 TEST_F(BackoffTriggersSyncSchedulerTest, FailCommitOnce) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       QuitLoopNowAction()));
   EXPECT_TRUE(RunAndGetBackoff());
 }
@@ skipping 46 matching lines @@
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   // This nudge should fail and put us into backoff.  Thanks to our mock
   // GetDelay() setup above, this will be a long backoff.
   scheduler()->ScheduleNudge(zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
   ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL, r.snapshots[0]->source.updates_source);
+  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
+            r.snapshots[0].source().updates_source);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(1)
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
           RecordSyncShare(&r)));
 
   // We schedule a nudge with enough delay (10X poll interval) that at least
   // one or two polls would have taken place.  The nudge should succeed.
   scheduler()->ScheduleNudge(poll * 10, NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
   ASSERT_EQ(2U, r.snapshots.size());
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL, r.snapshots[1]->source.updates_source);
+  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
+            r.snapshots[1].source().updates_source);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(0);
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
       types, GetUpdatesCallerInfo::RECONFIGURATION);
   PumpLoop();
@@ skipping 76 matching lines @@
   RunLoop();
 
   StopSyncScheduler();
 
   EXPECT_EQ(kMinNumSamples, r.times.size());
 
   // The first nudge ran as soon as possible.  It failed.
   TimeTicks optimal_job_time = optimal_start;
   EXPECT_GE(r.times[0], optimal_job_time);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0]->source.updates_source);
+            r.snapshots[0].source().updates_source);
 
   // It was followed by a successful retry nudge shortly afterward.
   optimal_job_time = optimal_job_time + backoff;
   EXPECT_GE(r.times[1], optimal_job_time);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[1]->source.updates_source);
+            r.snapshots[1].source().updates_source);
   // After that, we went back to polling.
   for (size_t i = 2; i < r.snapshots.size(); i++) {
     optimal_job_time = optimal_job_time + poll;
     SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
     EXPECT_GE(r.times[i], optimal_job_time);
     EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
-              r.snapshots[i]->source.updates_source);
+              r.snapshots[i].source().updates_source);
   }
 }
 
 // Test that poll failures are ignored.  They should have no effect on
 // subsequent poll attempts, nor should they trigger a backoff/retry.
 // This test is flaky under memory tools, see http://crbug.com/118370.
 TEST_F(SyncSchedulerTest, FLAKY_TransientPollFailure) {
   SyncShareRecords r;
   const TimeDelta poll_interval(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
@@ skipping 155 matching lines @@
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace browser_sync