[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

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_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 189 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(
-      syncer::Encryptor* encryptor,
-      syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
-      syncer::ReportUnrecoverableErrorFunction
+      Encryptor* encryptor,
+      UnrecoverableErrorHandler* unrecoverable_error_handler,
+      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 syncer::WeakHandle<TransactionObserver>&
+                     const 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.
-  syncer::Cryptographer* GetCryptographer(const BaseTransaction* trans);
+  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 syncer::WeakHandle<TransactionObserver>&
-          transaction_observer);
+      const 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:
   typedef std::vector<int64> ChildHandles;
@@ skipping 149 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 syncer::WeakHandle<TransactionObserver>&
-          transaction_observer);
+      const 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 syncer::WeakHandle<TransactionObserver>&
-               transaction_observer);
+           const 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;
 
     // The name of this directory.
@@ skipping 46 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 syncer::WeakHandle<TransactionObserver> transaction_observer;
+    const 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 12 matching lines @@
   void AppendChildHandles(
       const ScopedKernelLock& lock,
       const Id& parent_id, Directory::ChildHandles* result);
 
   // Return a pointer to what is probably (but not certainly) the
   // first child of |parent_id|, or NULL if |parent_id| definitely has
   // no children.
   EntryKernel* GetPossibleFirstChild(
       const ScopedKernelLock& lock, const Id& parent_id);
 
-  syncer::Cryptographer cryptographer_;
+  Cryptographer cryptographer_;
 
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
-  syncer::UnrecoverableErrorHandler* const unrecoverable_error_handler_;
-  const syncer::ReportUnrecoverableErrorFunction
-      report_unrecoverable_error_function_;
+  UnrecoverableErrorHandler* const unrecoverable_error_handler_;
+  const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
   InvariantCheckLevel invariant_check_level_;
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_