[Sync] Rename csync namespace to syncer

sync/syncable/directory.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.
 
 #ifndef SYNC_SYNCABLE_DIRECTORY_H_
 #define SYNC_SYNCABLE_DIRECTORY_H_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/gtest_prod_util.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/syncable/dir_open_result.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/scoped_kernel_lock.h"
 #include "sync/util/cryptographer.h"
 
-namespace csync {
+namespace syncer {
 class Encryptor;
 class UnrecoverableErrorHandler;
 }
 
 namespace syncable {
 
 class DirectoryChangeDelegate;
 class TransactionObserver;
 class BaseTransaction;
 class WriteTransaction;
@@ skipping 161 matching lines @@
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     EntryKernelSet dirty_metas;
     MetahandleSet metahandles_to_purge;
   };
 
   // Does not take ownership of |encryptor|.
   // |report_unrecoverable_error_function| may be NULL.
   // Takes ownership of |store|.
   Directory(
-      csync::Encryptor* encryptor,
-      csync::UnrecoverableErrorHandler* unrecoverable_error_handler,
-      csync::ReportUnrecoverableErrorFunction
+      syncer::Encryptor* encryptor,
+      syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
+      syncer::ReportUnrecoverableErrorFunction
           report_unrecoverable_error_function,
       DirectoryBackingStore* store);
   virtual ~Directory();
 
   // Does not take ownership of |delegate|, which must not be NULL.
   // Starts sending events to |delegate| if the returned result is
   // OPENED.  Note that events to |delegate| may be sent from *any*
   // thread.  |transaction_observer| must be initialized.
   DirOpenResult Open(const std::string& name,
                      DirectoryChangeDelegate* delegate,
-                     const csync::WeakHandle<TransactionObserver>&
+                     const syncer::WeakHandle<TransactionObserver>&
                          transaction_observer);
 
   // Stops sending events to the delegate and the transaction
   // observer.
   void Close();
 
   int64 NextMetahandle();
   // Always returns a negative id.  Positive client ids are generated
   // by the server only.
   Id NextId();
@@ skipping 27 matching lines @@
 
   std::string GetNotificationState() const;
   void SetNotificationState(const std::string& notification_state);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
   // Returns a pointer to our cryptographer.  Does not transfer ownership.  The
   // cryptographer is not thread safe; it should not be accessed after the
   // transaction has been released.
-  csync::Cryptographer* GetCryptographer(const BaseTransaction* trans);
+  syncer::Cryptographer* GetCryptographer(const BaseTransaction* trans);
 
   // Returns true if the directory had encountered an unrecoverable error.
   // Note: Any function in |Directory| that can be called without holding a
   // transaction need to check if the Directory already has an unrecoverable
   // error on it.
   bool unrecoverable_error_set(const BaseTransaction* trans) const;
 
   // Called to immediately report an unrecoverable error (but don't
   // propagate it up).
   void ReportUnrecoverableError() {
@@ skipping 25 matching lines @@
   // These don't do semantic checking.
   // The semantic checking is implemented higher up.
   bool UnlinkEntryFromOrder(EntryKernel* entry,
                             WriteTransaction* trans,
                             ScopedKernelLock* lock,
                             UnlinkReason unlink_reason);
 
   DirOpenResult OpenImpl(
       const std::string& name,
       DirectoryChangeDelegate* delegate,
-      const csync::WeakHandle<TransactionObserver>&
+      const syncer::WeakHandle<TransactionObserver>&
           transaction_observer);
 
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
 
   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
 
  public:
@@ skipping 147 matching lines @@
   // items that had a duplicated ID in the end, resulting in a DB key
   // violation. ID reassociation would fail after an attempted commit.
   typedef Index<ClientTagIndexer>::Set ClientTagIndex;
 
  protected:
   // Used by tests. |delegate| must not be NULL.
   // |transaction_observer| must be initialized.
   void InitKernelForTest(
       const std::string& name,
       DirectoryChangeDelegate* delegate,
-      const csync::WeakHandle<TransactionObserver>&
+      const syncer::WeakHandle<TransactionObserver>&
           transaction_observer);
 
  private:
   struct Kernel {
     // |delegate| must not be NULL.  |transaction_observer| must be
     // initialized.
     Kernel(const std::string& name, const KernelLoadInfo& info,
            DirectoryChangeDelegate* delegate,
-           const csync::WeakHandle<TransactionObserver>&
+           const syncer::WeakHandle<TransactionObserver>&
                transaction_observer);
 
     ~Kernel();
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     base::Lock transaction_mutex;
 
     // Protected by transaction_mutex.  Used by WriteTransactions.
     int64 next_write_transaction_id;
 
@@ skipping 47 matching lines @@
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64 next_metahandle;
 
     // The delegate for directory change events.  Must not be NULL.
     DirectoryChangeDelegate* const delegate;
 
     // The transaction observer.
-    const csync::WeakHandle<TransactionObserver> transaction_observer;
+    const syncer::WeakHandle<TransactionObserver> transaction_observer;
   };
 
   // Helper method used to do searches on |parent_id_child_index|.
   ParentIdChildIndex::iterator LocateInParentChildIndex(
       const ScopedKernelLock& lock,
       const Id& parent_id,
       int64 position_in_parent,
       const Id& item_id_for_tiebreaking);
 
   // Return an iterator to the beginning of the range of the children of
@@ skipping 18 matching lines @@
   // no children.
   EntryKernel* GetPossibleFirstChild(
       const ScopedKernelLock& lock, const Id& parent_id);
 
   // Return a pointer to what is probably (but not certainly) the last
   // child of |parent_id|, or NULL if |parent_id| definitely has no
   // children.
   EntryKernel* GetPossibleLastChildForTest(
       const ScopedKernelLock& lock, const Id& parent_id);
 
-  csync::Cryptographer cryptographer_;
+  syncer::Cryptographer cryptographer_;
 
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
-  csync::UnrecoverableErrorHandler* const unrecoverable_error_handler_;
-  const csync::ReportUnrecoverableErrorFunction
+  syncer::UnrecoverableErrorHandler* const unrecoverable_error_handler_;
+  const syncer::ReportUnrecoverableErrorFunction
       report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 };
 
-} // namespace syncable
+}  // namespace syncable
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_