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

components/sync/syncable/directory.h

 // Copyright 2013 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_
+#ifndef COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_
+#define COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_util.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/values.h"
-#include "sync/api/attachments/attachment_id.h"
-#include "sync/base/sync_export.h"
-#include "sync/internal_api/public/util/weak_handle.h"
-#include "sync/syncable/dir_open_result.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/entry_kernel.h"
-#include "sync/syncable/metahandle_set.h"
-#include "sync/syncable/parent_child_index.h"
-#include "sync/syncable/syncable_delete_journal.h"
+#include "components/sync/api/attachments/attachment_id.h"
+#include "components/sync/base/sync_export.h"
+#include "components/sync/base/weak_handle.h"
+#include "components/sync/syncable/dir_open_result.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/entry_kernel.h"
+#include "components/sync/syncable/metahandle_set.h"
+#include "components/sync/syncable/parent_child_index.h"
+#include "components/sync/syncable/syncable_delete_journal.h"
 
 namespace syncer {
 
 class Cryptographer;
 class TestUserShare;
 class UnrecoverableErrorHandler;
 
 namespace syncable {
 
 class BaseTransaction;
@@ skipping 71 matching lines @@
     // The per-datatype context.
     sync_pb::DataTypeContext datatype_context[MODEL_TYPE_COUNT];
   };
 
   // What the Directory needs on initialization to create itself and its Kernel.
   // Filled by DirectoryBackingStore::Load.
   struct KernelLoadInfo {
     PersistedKernelInfo kernel_info;
     std::string cache_guid;  // Created on first initialization, never changes.
     int64_t max_metahandle;  // Computed (using sql MAX aggregate) on init.
-    KernelLoadInfo() : max_metahandle(0) {
-    }
+    KernelLoadInfo() : max_metahandle(0) {}
   };
 
   // When the Directory is told to SaveChanges, a SaveChangesSnapshot is
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SYNC_EXPORT SaveChangesSnapshot {
     SaveChangesSnapshot();
     ~SaveChangesSnapshot();
 
     // Returns true if this snapshot has any unsaved metahandle changes.
     bool HasUnsavedMetahandleChanges() const;
 
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     EntryKernelSet dirty_metas;
     MetahandleSet metahandles_to_purge;
     EntryKernelSet delete_journals;
     MetahandleSet delete_journals_to_purge;
   };
 
   struct Kernel {
     // |delegate| must not be NULL.  |transaction_observer| must be
     // initialized.
-    Kernel(const std::string& name, const KernelLoadInfo& info,
+    Kernel(const std::string& name,
+           const KernelLoadInfo& info,
            DirectoryChangeDelegate* delegate,
            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_t next_write_transaction_id;
@@ skipping 90 matching lines @@
       const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       NigoriHandler* nigori_handler,
       Cryptographer* cryptographer);
   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 WeakHandle<TransactionObserver>&
-                         transaction_observer);
+  DirOpenResult Open(
+      const std::string& name,
+      DirectoryChangeDelegate* delegate,
+      const WeakHandle<TransactionObserver>& transaction_observer);
 
   int64_t NextMetahandle();
   // Generates next client ID based on a randomly generated GUID.
   syncable::Id NextId();
 
   bool good() const { return NULL != kernel_; }
 
   // The download progress is an opaque token provided by the sync server
   // to indicate the continuation state of the next GetUpdates operation.
-  void GetDownloadProgress(
-      ModelType type,
-      sync_pb::DataTypeProgressMarker* value_out) const;
-  void GetDownloadProgressAsString(
-      ModelType type,
-      std::string* value_out) const;
-  void SetDownloadProgress(
-      ModelType type,
-      const sync_pb::DataTypeProgressMarker& value);
+  void GetDownloadProgress(ModelType type,
+                           sync_pb::DataTypeProgressMarker* value_out) const;
+  void GetDownloadProgressAsString(ModelType type,
+                                   std::string* value_out) const;
+  void SetDownloadProgress(ModelType type,
+                           const sync_pb::DataTypeProgressMarker& value);
   bool HasEmptyDownloadProgress(ModelType type) const;
 
   // Gets the total number of entries in the directory.
   size_t GetEntriesCount() const;
 
   // Gets/Increments transaction version of a model type. Must be called when
   // holding kernel mutex.
   int64_t GetTransactionVersion(ModelType type) const;
   void IncrementTransactionVersion(ModelType type);
 
@@ skipping 38 matching lines @@
   Cryptographer* GetCryptographer(const BaseTransaction* trans);
 
   // Called to immediately report an unrecoverable error (but don't
   // propagate it up).
   void ReportUnrecoverableError();
 
   // Called to set the unrecoverable error on the directory and to propagate
   // the error to upper layers.
   void OnUnrecoverableError(const BaseTransaction* trans,
                             const tracked_objects::Location& location,
-                            const std::string & message);
+                            const std::string& message);
 
   DeleteJournal* delete_journal();
 
   // Returns the child meta handles (even those for deleted/unlinked
   // nodes) for given parent id.  Clears |result| if there are no
   // children.
-  bool GetChildHandlesById(BaseTransaction*, const Id& parent_id,
-      Metahandles* result);
+  bool GetChildHandlesById(BaseTransaction*,
+                           const Id& parent_id,
+                           Metahandles* result);
 
   // Counts all items under the given node, including the node itself.
   int GetTotalNodeCount(BaseTransaction*, EntryKernel* kernel_) const;
 
   // Returns this item's position within its parent folder.
   // The left-most item is 0, second left-most is 1, etc.
   int GetPositionIndex(BaseTransaction*, EntryKernel* kernel_) const;
 
   // Returns true iff |id| has children.
   bool HasChildren(BaseTransaction* trans, const Id& id);
@@ skipping 33 matching lines @@
   //
   // WARNING: THIS METHOD PERFORMS SYNCHRONOUS I/O VIA SQLITE.
   bool SaveChanges();
 
   // Returns the number of entities with the unsynced bit set.
   int64_t unsynced_entity_count() const;
 
   // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
   // before any new entries have been created. The intention is that the
   // syncer should call it from its PerformSyncQueries member.
-  void GetUnsyncedMetaHandles(BaseTransaction* trans,
-                              Metahandles* result);
+  void GetUnsyncedMetaHandles(BaseTransaction* trans, Metahandles* result);
 
   // Returns whether or not this |type| has unapplied updates.
   bool TypeHasUnappliedUpdates(ModelType type);
 
   // Get all the metahandles for unapplied updates for a given set of
   // server types.
   void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
                                      FullModelTypeSet server_types,
                                      std::vector<int64_t>* result);
 
@@ skipping 12 matching lines @@
   // Returns a ListValue serialization of all nodes for the given type.
   std::unique_ptr<base::ListValue> GetNodeDetailsForType(BaseTransaction* trans,
                                                          ModelType type);
 
   // Sets the level of invariant checking performed after transactions.
   void SetInvariantCheckLevel(InvariantCheckLevel check_level);
 
   // Checks tree metadata consistency following a transaction.  It is intended
   // to provide a reasonable tradeoff between performance and comprehensiveness
   // and may be used in release code.
-  bool CheckInvariantsOnTransactionClose(
-      syncable::BaseTransaction* trans,
-      const MetahandleSet& modified_handles);
+  bool CheckInvariantsOnTransactionClose(syncable::BaseTransaction* trans,
+                                         const MetahandleSet& modified_handles);
 
   // Forces a full check of the directory.  This operation may be slow and
   // should not be invoked outside of tests.
-  bool FullyCheckTreeInvariants(BaseTransaction *trans);
+  bool FullyCheckTreeInvariants(BaseTransaction* trans);
 
   // Purges data associated with any entries whose ModelType or ServerModelType
   // is found in |disabled_types|, from sync directory _both_ in memory and on
   // disk. Only valid, "real" model types are allowed in |disabled_types| (see
   // model_type.h for definitions).
   // 1. Data associated with |types_to_journal| is saved in the delete journal
   // to help prevent back-from-dead problem due to offline delete in the next
   // sync session. |types_to_journal| must be a subset of |disabled_types|.
   // 2. Data associated with |types_to_unapply| is reset to an "unapplied"
   // state, wherein all local data is deleted and IS_UNAPPLIED is set to true.
@@ skipping 49 matching lines @@
   void UpdateAttachmentIndex(const int64_t metahandle,
                              const sync_pb::AttachmentMetadata& old_metadata,
                              const sync_pb::AttachmentMetadata& new_metadata);
 
   virtual EntryKernel* GetEntryById(const Id& id);
   virtual EntryKernel* GetEntryByClientTag(const std::string& tag);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
 
   virtual EntryKernel* GetEntryByHandle(int64_t handle);
 
-  bool ReindexId(BaseWriteTransaction* trans, EntryKernel* const entry,
+  bool ReindexId(BaseWriteTransaction* trans,
+                 EntryKernel* const entry,
                  const Id& new_id);
 
-  bool ReindexParentId(BaseWriteTransaction* trans, EntryKernel* const entry,
+  bool ReindexParentId(BaseWriteTransaction* trans,
+                       EntryKernel* const entry,
                        const Id& new_parent_id);
 
   // Accessors for the underlying Kernel. Although these are public methods, the
   // number of classes that call these should be limited.
   Kernel* kernel();
   const Kernel* kernel() const;
 
  private:
   friend class SyncableDirectoryTest;
   friend class syncer::TestUserShare;
@@ skipping 127 matching lines @@
   std::unique_ptr<DeleteJournal> delete_journal_;
 
   base::WeakPtrFactory<Directory> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Directory);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
-#endif  // SYNC_SYNCABLE_DIRECTORY_H_
+#endif  // COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_