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

components/sync/syncable/entry.h

 // Copyright 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_ENTRY_H_
-#define SYNC_SYNCABLE_ENTRY_H_
+#ifndef COMPONENTS_SYNC_SYNCABLE_ENTRY_H_
+#define COMPONENTS_SYNC_SYNCABLE_ENTRY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
-#include "sync/base/sync_export.h"
-#include "sync/syncable/entry_kernel.h"
+#include "components/sync/base/sync_export.h"
+#include "components/sync/syncable/entry_kernel.h"
 
 namespace syncer {
 class Cryptographer;
 class ReadNode;
 
 namespace syncable {
 
 class Directory;
 class BaseTransaction;
 
 // A read-only meta entry
 // Instead of:
 //   Entry e = transaction.GetById(id);
 // use:
 //   Entry e(transaction, GET_BY_ID, id);
 //
 // Why?  The former would require a copy constructor, and it would be difficult
 // to enforce that an entry never outlived its transaction if there were a copy
 // constructor.
-enum GetById {
-  GET_BY_ID
-};
+enum GetById { GET_BY_ID };
 
-enum GetByClientTag {
-  GET_BY_CLIENT_TAG
-};
+enum GetByClientTag { GET_BY_CLIENT_TAG };
 
 enum GetByServerTag {
   // Server tagged items are deprecated for all types but bookmarks.
   GET_BY_SERVER_TAG
 };
 
-enum GetTypeRoot {
-  GET_TYPE_ROOT
-};
+enum GetTypeRoot { GET_TYPE_ROOT };
 
-enum GetByHandle {
-  GET_BY_HANDLE
-};
+enum GetByHandle { GET_BY_HANDLE };
 
 class SYNC_EXPORT Entry {
  public:
   // After constructing, you must check good() to test whether the Get
   // succeeded.
   Entry(BaseTransaction* trans, GetByHandle, int64_t handle);
   Entry(BaseTransaction* trans, GetById, const Id& id);
   Entry(BaseTransaction* trans, GetTypeRoot, ModelType type);
   Entry(BaseTransaction* trans, GetByClientTag, const std::string& tag);
 
@@ skipping 188 matching lines @@
   // Returns true if this is an entry that is expected to maintain a certain
   // sort ordering relative to its siblings under the same parent.
   bool ShouldMaintainPosition() const;
 
   // Returns true if this is an entry that is expected to maintain hierarchy.
   // ie. Whether or not the PARENT_ID field contains useful information.
   bool ShouldMaintainHierarchy() const;
 
   Directory* dir() const;
 
-  const EntryKernel GetKernelCopy() const {
-    return *kernel_;
-  }
+  const EntryKernel GetKernelCopy() const { return *kernel_; }
 
   // Dumps all entry info into a DictionaryValue and returns it.
   // Transfers ownership of the DictionaryValue to the caller.
   base::DictionaryValue* ToValue(Cryptographer* cryptographer) const;
 
  protected:  // Don't allow creation on heap, except by sync API wrappers.
   void* operator new(size_t size) { return (::operator new)(size); }
 
   inline explicit Entry(BaseTransaction* trans)
-      : basetrans_(trans),
-        kernel_(NULL) { }
+      : basetrans_(trans), kernel_(NULL) {}
 
  protected:
   BaseTransaction* const basetrans_;
 
   EntryKernel* kernel_;
 
  private:
   friend class Directory;
   friend class syncer::ReadNode;
-  friend std::ostream& operator << (std::ostream& s, const Entry& e);
+  friend std::ostream& operator<<(std::ostream& s, const Entry& e);
 
   DISALLOW_COPY_AND_ASSIGN(Entry);
 };
 
 std::ostream& operator<<(std::ostream& os, const Entry& entry);
 
 }  // namespace syncable
 }  // namespace syncer
 
-#endif  // SYNC_SYNCABLE_ENTRY_H_
+#endif  // COMPONENTS_SYNC_SYNCABLE_ENTRY_H_