[Sync] Move //sync to //components/sync.

components/sync/sessions_impl/nudge_tracker_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 "sync/sessions/nudge_tracker.h"
+#include "components/sync/sessions_impl/nudge_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "sync/internal_api/public/base/model_type_test_util.h"
-#include "sync/test/mock_invalidation.h"
-#include "sync/test/mock_invalidation_tracker.h"
-#include "sync/test/trackable_mock_invalidation.h"
+#include "components/sync/base/model_type_test_util.h"
+#include "components/sync/test/mock_invalidation.h"
+#include "components/sync/test/mock_invalidation_tracker.h"
+#include "components/sync/test/trackable_mock_invalidation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 testing::AssertionResult ModelTypeSetEquals(ModelTypeSet a, ModelTypeSet b) {
   if (a == b) {
     return testing::AssertionSuccess();
   } else {
     return testing::AssertionFailure()
-        << "Left side " << ModelTypeSetToString(a)
-        << ", does not match rigth side: " << ModelTypeSetToString(b);
+           << "Left side " << ModelTypeSetToString(a)
+           << ", does not match rigth side: " << ModelTypeSetToString(b);
   }
 }
 
 }  // namespace
 
 namespace sessions {
 
 class NudgeTrackerTest : public ::testing::Test {
  public:
-  NudgeTrackerTest() {
-    SetInvalidationsInSync();
-  }
+  NudgeTrackerTest() { SetInvalidationsInSync(); }
 
   static size_t GetHintBufferSize() {
     // Assumes that no test has adjusted this size.
     return NudgeTracker::kDefaultMaxPayloadsPerType;
   }
 
   bool InvalidationsOutOfSync() const {
     // We don't currently track invalidations out of sync on a per-type basis.
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
@@ skipping 181 matching lines @@
                                           BuildInvalidation(1000, "new_hint"));
 
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_TRUE(gu_trigger.client_dropped_hints());
     ASSERT_EQ(GetHintBufferSize(),
               static_cast<size_t>(gu_trigger.notification_hint_size()));
 
     // Verify the newest hint was not dropped and is the last in the list.
-    EXPECT_EQ("new_hint", gu_trigger.notification_hint(GetHintBufferSize()-1));
+    EXPECT_EQ("new_hint",
+              gu_trigger.notification_hint(GetHintBufferSize() - 1));
 
     // Verify the oldest hint, too.
     EXPECT_EQ("hint", gu_trigger.notification_hint(0));
   }
 }
 
 // Tests the receipt of 'unknown version' invalidations.
 TEST_F(NudgeTrackerTest, DropHintsAtServer_Alone) {
   // Record the unknown version invalidation.
   nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
@@ skipping 183 matching lines @@
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
 
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
   // A local change to sessions enables the flag.
   nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
 
   // But the throttling of sessions unsets it.
-  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS),
-                                       throttle_length,
-                                       t0);
+  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS), throttle_length,
+                                        t0);
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
   // A refresh request for bookmarks means we have reason to sync again.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
 
   // A successful sync cycle means we took care of bookmarks.
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
@@ skipping 11 matching lines @@
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
 
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   // A refresh request to sessions enables the flag.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
 
   // But the throttling of sessions unsets it.
-  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS),
-                                       throttle_length,
-                                       t0);
+  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS), throttle_length,
+                                        t0);
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   // A refresh request for bookmarks means we have reason to sync again.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
 
   // A successful sync cycle means we took care of bookmarks.
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
@@ skipping 12 matching lines @@
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
 // Tests throttling-related getter functions when some types are throttled.
 TEST_F(NudgeTrackerTest, ThrottleAndUnthrottle) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
 
   nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, PREFERENCES),
-                                       throttle_length,
-                                       t0);
+                                        throttle_length, t0);
 
   EXPECT_TRUE(nudge_tracker_.IsAnyTypeThrottled());
   EXPECT_TRUE(nudge_tracker_.IsTypeThrottled(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.IsTypeThrottled(PREFERENCES));
   EXPECT_FALSE(nudge_tracker_.GetThrottledTypes().Empty());
   EXPECT_EQ(throttle_length, nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
 
   nudge_tracker_.UpdateTypeThrottlingState(t1);
 
   EXPECT_FALSE(nudge_tracker_.IsAnyTypeThrottled());
   EXPECT_FALSE(nudge_tracker_.IsTypeThrottled(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
 TEST_F(NudgeTrackerTest, OverlappingThrottleIntervals) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle1_length = base::TimeDelta::FromMinutes(10);
   const base::TimeDelta throttle2_length = base::TimeDelta::FromMinutes(20);
   const base::TimeTicks t1 = t0 + throttle1_length;
   const base::TimeTicks t2 = t0 + throttle2_length;
 
   // Setup the longer of two intervals.
   nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, PREFERENCES),
-                                       throttle2_length,
-                                       t0);
-  EXPECT_TRUE(ModelTypeSetEquals(
-          ModelTypeSet(SESSIONS, PREFERENCES),
-          nudge_tracker_.GetThrottledTypes()));
-  EXPECT_EQ(throttle2_length,
-            nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
+                                        throttle2_length, t0);
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
+                                 nudge_tracker_.GetThrottledTypes()));
+  EXPECT_EQ(throttle2_length, nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
 
   // Setup the shorter interval.
   nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, BOOKMARKS),
-                                       throttle1_length,
-                                       t0);
-  EXPECT_TRUE(ModelTypeSetEquals(
-          ModelTypeSet(SESSIONS, PREFERENCES, BOOKMARKS),
-          nudge_tracker_.GetThrottledTypes()));
-  EXPECT_EQ(throttle1_length,
-            nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
+                                        throttle1_length, t0);
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES, BOOKMARKS),
+                                 nudge_tracker_.GetThrottledTypes()));
+  EXPECT_EQ(throttle1_length, nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
 
   // Expire the first interval.
   nudge_tracker_.UpdateTypeThrottlingState(t1);
 
   // SESSIONS appeared in both intervals.  We expect it will be throttled for
   // the longer of the two, so it's still throttled at time t1.
-  EXPECT_TRUE(ModelTypeSetEquals(
-          ModelTypeSet(SESSIONS, PREFERENCES),
-          nudge_tracker_.GetThrottledTypes()));
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
+                                 nudge_tracker_.GetThrottledTypes()));
   EXPECT_EQ(throttle2_length - throttle1_length,
             nudge_tracker_.GetTimeUntilNextUnthrottle(t1));
 
   // Expire the second interval.
   nudge_tracker_.UpdateTypeThrottlingState(t2);
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
 TEST_F(NudgeTrackerTest, Retry) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
@@ skipping 327 matching lines @@
 // Test dropping when the buffer overflows and subsequent drop recovery.
 TEST_F(NudgeTrackerAckTrackingTest, OverflowAndRecover) {
   std::vector<int> invalidation_ids;
 
   int inv10_id = SendInvalidation(BOOKMARKS, 10, "hint");
   for (size_t i = 1; i < GetHintBufferSize(); ++i) {
     invalidation_ids.push_back(SendInvalidation(BOOKMARKS, i + 10, "hint"));
   }
 
   for (std::vector<int>::iterator it = invalidation_ids.begin();
-       it != invalidation_ids.end();
-       ++it) {
+       it != invalidation_ids.end(); ++it) {
     EXPECT_TRUE(IsInvalidationUnacknowledged(*it));
   }
 
   // This invalidation, though arriving the most recently, has the oldest
   // version number so it should be dropped first.
   int inv5_id = SendInvalidation(BOOKMARKS, 5, "old_hint");
   EXPECT_TRUE(IsInvalidationDropped(inv5_id));
 
   // This invalidation has a larger version number, so it will force a
   // previously delivered invalidation to be dropped.
   int inv100_id = SendInvalidation(BOOKMARKS, 100, "new_hint");
   EXPECT_TRUE(IsInvalidationDropped(inv10_id));
 
   // This should recover from the drop and bring us back into sync.
   RecordSuccessfulSyncCycle();
 
   for (std::vector<int>::iterator it = invalidation_ids.begin();
-       it != invalidation_ids.end();
-       ++it) {
+       it != invalidation_ids.end(); ++it) {
     EXPECT_TRUE(IsInvalidationAcknowledged(*it));
   }
   EXPECT_TRUE(IsInvalidationAcknowledged(inv100_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 // Test receipt of an unknown version invalidation from the server.
 TEST_F(NudgeTrackerAckTrackingTest, UnknownVersionFromServer_Simple) {
   int inv_id = SendUnknownVersionInvalidation(BOOKMARKS);
@@ skipping 26 matching lines @@
   EXPECT_TRUE(IsInvalidationAcknowledged(inv2_id));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv4_id));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv5_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 }  // namespace sessions
 }  // namespace syncer