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

components/sync/base/immutable_unittest.cc

Index: components/sync/base/immutable_unittest.cc
diff --git a/sync/internal_api/public/util/immutable_unittest.cc b/components/sync/base/immutable_unittest.cc
similarity index 86%
rename from sync/internal_api/public/util/immutable_unittest.cc
rename to components/sync/base/immutable_unittest.cc
index 9d7d0f3c3c48360963346b985c5e860e78e50916..0fb1b69a01377229533378bc0355f6787122be9b 100644
--- a/sync/internal_api/public/util/immutable_unittest.cc
+++ b/components/sync/base/immutable_unittest.cc
@@ -2,7 +2,7 @@
 // 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>
@@ -65,13 +65,9 @@ class TokenBase {
     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 {
@@ -108,8 +104,7 @@ void swap(ADLToken& t1, ADLToken& t2) {
 namespace std {
 
 template <>
-void swap(syncer::SpecializationToken& t1,
-          syncer::SpecializationToken& t2) {
+void swap(syncer::SpecializationToken& t1, syncer::SpecializationToken& t2) {
   t1.Swap(&t2);
 }
 
@@ -165,33 +160,33 @@ void RunTokenTest(const char* token, bool expect_copies) {
 }
 
 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();
@@ -214,30 +209,28 @@ void RunTokenContainerTest(const char* token) {
 }
 
 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