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

components/sync/base/immutable_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/internal_api/public/util/immutable.h"
+#include "components/sync/base/immutable.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <deque>
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 42 matching lines @@
   TokenBase(const TokenBase& other) : core_(other.core_) {
     core_->RecordCopy();
   }
 
   TokenBase& operator=(const TokenBase& other) {
     core_ = other.core_;
     core_->RecordCopy();
     return *this;
   }
 
-  const char* GetToken() const {
-    return core_->GetToken();
-  }
+  const char* GetToken() const { return core_->GetToken(); }
 
-  int GetCopyCount() const {
-    return core_->GetCopyCount();
-  }
+  int GetCopyCount() const { return core_->GetCopyCount(); }
 
   // For associative containers.
   bool operator<(const TokenBase& other) const {
     return std::string(GetToken()) < std::string(other.GetToken());
   }
 
   // STL-style swap.
   void swap(TokenBase& other) {
     using std::swap;
     swap(other.core_, core_);
@@ skipping 16 matching lines @@
 void swap(ADLToken& t1, ADLToken& t2) {
   t1.Swap(&t2);
 }
 
 }  // namespace syncer
 
 // Allowed by the standard (17.4.3.1/1).
 namespace std {
 
 template <>
-void swap(syncer::SpecializationToken& t1,
-          syncer::SpecializationToken& t2) {
+void swap(syncer::SpecializationToken& t1, syncer::SpecializationToken& t2) {
   t1.Swap(&t2);
 }
 
 }  // namespace std
 
 namespace syncer {
 namespace {
 
 class ImmutableTest : public ::testing::Test {};
 
@@ skipping 35 matching lines @@
   EXPECT_EQ(0, t.GetCopyCount());
 
   ImmutableT immutable_t(&t);
   EXPECT_EQ(token, immutable_t.Get().GetToken());
   EXPECT_EQ(kEmptyToken, t.GetToken());
   EXPECT_EQ(expect_copies, immutable_t.Get().GetCopyCount() > 0);
   EXPECT_EQ(expect_copies, t.GetCopyCount() > 0);
 }
 
 TEST_F(ImmutableTest, Token) {
-  RunTokenTest<Token, Immutable<Token> >("Token", true /* expect_copies */);
+  RunTokenTest<Token, Immutable<Token>>("Token", true /* expect_copies */);
 }
 
 TEST_F(ImmutableTest, TokenSwapMemFnByRef) {
-  RunTokenTest<Token, Immutable<Token, HasSwapMemFnByRef<Token> > >(
+  RunTokenTest<Token, Immutable<Token, HasSwapMemFnByRef<Token>>>(
       "TokenSwapMemFnByRef", false /* expect_copies */);
 }
 
 TEST_F(ImmutableTest, TokenSwapMemFnByPtr) {
-  RunTokenTest<Token, Immutable<Token, HasSwapMemFnByPtr<Token> > >(
+  RunTokenTest<Token, Immutable<Token, HasSwapMemFnByPtr<Token>>>(
       "TokenSwapMemFnByPtr", false /* expect_copies */);
 }
 
 TEST_F(ImmutableTest, ADLToken) {
-  RunTokenTest<ADLToken, Immutable<ADLToken> >(
-      "ADLToken", false /* expect_copies */);
+  RunTokenTest<ADLToken, Immutable<ADLToken>>("ADLToken",
+                                              false /* expect_copies */);
 }
 
 TEST_F(ImmutableTest, SpecializationToken) {
-  RunTokenTest<SpecializationToken, Immutable<SpecializationToken> >(
+  RunTokenTest<SpecializationToken, Immutable<SpecializationToken>>(
       "SpecializationToken", false /* expect_copies */);
 }
 
 template <typename C, typename ImmutableC>
 void RunTokenContainerTest(const char* token) {
   SCOPED_TRACE(token);
-  const Token tokens[] = { Token(), Token(token) };
+  const Token tokens[] = {Token(), Token(token)};
   const size_t token_count = arraysize(tokens);
   C c(tokens, tokens + token_count);
   const int copy_count = c.begin()->GetCopyCount();
   EXPECT_GT(copy_count, 0);
   for (typename C::const_iterator it = c.begin(); it != c.end(); ++it) {
     EXPECT_EQ(copy_count, it->GetCopyCount());
   }
 
   // Make sure that making the container immutable doesn't incur any
   // copies of the tokens.
   ImmutableC immutable_c(&c);
   EXPECT_TRUE(c.empty());
   ASSERT_EQ(token_count, immutable_c.Get().size());
   int i = 0;
   for (typename C::const_iterator it = c.begin(); it != c.end(); ++it) {
     EXPECT_EQ(tokens[i].GetToken(), it->GetToken());
     EXPECT_EQ(copy_count, it->GetCopyCount());
     ++i;
   }
 }
 
 TEST_F(ImmutableTest, Vector) {
-  RunTokenContainerTest<std::vector<Token>, Immutable<std::vector<Token> > >(
+  RunTokenContainerTest<std::vector<Token>, Immutable<std::vector<Token>>>(
       "Vector");
 }
 
 TEST_F(ImmutableTest, VectorSwapMemFnByRef) {
   RunTokenContainerTest<
-    std::vector<Token>,
-    Immutable<std::vector<Token>, HasSwapMemFnByRef<std::vector<Token> > > >(
-        "VectorSwapMemFnByRef");
+      std::vector<Token>,
+      Immutable<std::vector<Token>, HasSwapMemFnByRef<std::vector<Token>>>>(
+      "VectorSwapMemFnByRef");
 }
 
 TEST_F(ImmutableTest, Deque) {
-  RunTokenContainerTest<std::deque<Token>, Immutable<std::deque<Token> > >(
+  RunTokenContainerTest<std::deque<Token>, Immutable<std::deque<Token>>>(
       "Deque");
 }
 
 TEST_F(ImmutableTest, List) {
-  RunTokenContainerTest<std::list<Token>, Immutable<std::list<Token> > >(
-      "List");
+  RunTokenContainerTest<std::list<Token>, Immutable<std::list<Token>>>("List");
 }
 
 TEST_F(ImmutableTest, Set) {
-  RunTokenContainerTest<std::set<Token>, Immutable<std::set<Token> > >(
-      "Set");
+  RunTokenContainerTest<std::set<Token>, Immutable<std::set<Token>>>("Set");
 }
 
 }  // namespace
 }  // namespace syncer