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

components/sync/base/immutable.h

 // 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.
 
 // Immutable<T> provides an easy, cheap, and thread-safe way to pass
 // large immutable data around.
 //
 // For example, consider the following code:
 //
 //  typedef std::vector<LargeObject> LargeObjectList;
@@ skipping 43 matching lines @@
 // for discussion) Immutable<T> should be able to find it.
 //
 // Alternatively, you could explicitly control which swap function is
 // used by providing your own traits class or using one of the
 // pre-defined ones below.  See comments on traits below for details.
 //
 // NOTE: Some complexity is necessary in order to use Immutable<T>
 // with forward-declared types.  See comments on traits below for
 // details.
 
-#ifndef SYNC_INTERNAL_API_PUBLIC_UTIL_IMMUTABLE_H_
-#define SYNC_INTERNAL_API_PUBLIC_UTIL_IMMUTABLE_H_
+#ifndef COMPONENTS_SYNC_BASE_IMMUTABLE_H_
+#define COMPONENTS_SYNC_BASE_IMMUTABLE_H_
 
 // For std::swap().
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 
 namespace syncer {
 
 namespace internal {
 // This class is part of the Immutable implementation.  DO NOT USE
 // THIS CLASS DIRECTLY YOURSELF.
 
 template <typename T, typename Traits>
 class ImmutableCore
-    : public base::RefCountedThreadSafe<ImmutableCore<T, Traits> > {
+    : public base::RefCountedThreadSafe<ImmutableCore<T, Traits>> {
  public:
   // wrapper_ is always explicitly default-initialized to handle
   // primitive types and the case where Traits::Wrapper == T.
 
-  ImmutableCore() : wrapper_() {
-    Traits::InitializeWrapper(&wrapper_);
-  }
+  ImmutableCore() : wrapper_() { Traits::InitializeWrapper(&wrapper_); }
 
   explicit ImmutableCore(T* t) : wrapper_() {
     Traits::InitializeWrapper(&wrapper_);
     Traits::Swap(Traits::UnwrapMutable(&wrapper_), t);
   }
 
-  const T& Get() const {
-    return Traits::Unwrap(wrapper_);
-  }
+  const T& Get() const { return Traits::Unwrap(wrapper_); }
 
  private:
   friend class base::RefCountedThreadSafe<ImmutableCore<T, Traits>>;
 
-  ~ImmutableCore() {
-    Traits::DestroyWrapper(&wrapper_);
-  }
+  ~ImmutableCore() { Traits::DestroyWrapper(&wrapper_); }
 
   // This is semantically const, but we can't mark it a such as we
   // modify it in the constructor.
   typename Traits::Wrapper wrapper_;
 
   DISALLOW_COPY_AND_ASSIGN(ImmutableCore);
 };
 
 }  // namespace internal
 
@@ skipping 94 matching lines @@
     // http://en.wikipedia.org/wiki/Argument-dependent_name_lookup).
     using std::swap;
     swap(*t1, *t2);
   }
 };
 
 // Most STL containers have by-reference swap() member functions,
 // although they usually already overload std::swap() to use those.
 template <typename T>
 struct HasSwapMemFnByRef : public DefaultImmutableTraits<T> {
-  static void Swap(T* t1, T* t2) {
-    t1->swap(*t2);
-  }
+  static void Swap(T* t1, T* t2) { t1->swap(*t2); }
 };
 
 // Most Google-style objects have by-pointer Swap() member functions
 // (for example, generated protocol buffer classes).
 template <typename T>
 struct HasSwapMemFnByPtr : public DefaultImmutableTraits<T> {
-  static void Swap(T* t1, T* t2) {
-    t1->Swap(t2);
-  }
+  static void Swap(T* t1, T* t2) { t1->Swap(t2); }
 };
 
-template <typename T, typename Traits = DefaultImmutableTraits<T> >
+template <typename T, typename Traits = DefaultImmutableTraits<T>>
 class Immutable {
  public:
   // Puts the underlying object in a default-initialized state.
   Immutable() : core_(new internal::ImmutableCore<T, Traits>()) {}
 
   // Copy constructor and assignment welcome.
 
   // Resets |t| to a default-initialized state.
-  explicit Immutable(T* t)
-      : core_(new internal::ImmutableCore<T, Traits>(t)) {}
+  explicit Immutable(T* t) : core_(new internal::ImmutableCore<T, Traits>(t)) {}
 
-  const T& Get() const {
-    return core_->Get();
-  }
+  const T& Get() const { return core_->Get(); }
 
  private:
-  scoped_refptr<const internal::ImmutableCore<T, Traits> > core_;
+  scoped_refptr<const internal::ImmutableCore<T, Traits>> core_;
 };
 
 // Helper function to avoid having to write out template arguments.
 template <typename T>
 Immutable<T> MakeImmutable(T* t) {
   return Immutable<T>(t);
 }
 
 }  // namespace syncer
 
-#endif  // SYNC_INTERNAL_API_PUBLIC_UTIL_IMMUTABLE_H_
+#endif  // COMPONENTS_SYNC_BASE_IMMUTABLE_H_