[Sync] Rename csync namespace to syncer

sync/internal_api/public/util/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;
 //
 //   void ProcessStuff(const LargeObjectList& stuff) {
 //     for (LargeObjectList::const_iterator it = stuff.begin();
 //          it != stuff.end(); ++it) {
 //       ... process it ...
 //     }
 //   }
 //
 //   ...
 //
 //   LargeObjectList my_stuff;
 //   ... fill my_stuff with lots of LargeObjects ...
 //   some_loop->PostTask(FROM_HERE, base::Bind(&ProcessStuff, my_stuff));
 //
 // The last line incurs the cost of copying my_stuff, which is
 // undesirable.  Here's the above code re-written using Immutable<T>:
 //
 //   void ProcessStuff(
-//       const csync::Immutable<LargeObjectList>& stuff) {
+//       const syncer::Immutable<LargeObjectList>& stuff) {
 //     for (LargeObjectList::const_iterator it = stuff.Get().begin();
 //          it != stuff.Get().end(); ++it) {
 //       ... process it ...
 //     }
 //   }
 //
 //   ...
 //
 //   LargeObjectList my_stuff;
 //   ... fill my_stuff with lots of LargeObjects ...
@@ skipping 25 matching lines @@
 #ifndef SYNC_UTIL_IMMUTABLE_H_
 #define SYNC_UTIL_IMMUTABLE_H_
 #pragma once
 
 // For std::swap().
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 
-namespace csync {
+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:
   // wrapper_ is always explicitly default-initialized to handle
@@ skipping 164 matching lines @@
  private:
   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 csync
+}  // namespace syncer
 
 #endif  // SYNC_UTIL_IMMUTABLE_H_