[Sync] Make Directory's protected methods private where possible

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_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 284 matching lines @@
   // Getter/setters for the per datatype context.
   void GetDataTypeContext(BaseTransaction* trans,
                           ModelType type,
                           sync_pb::DataTypeContext* context) const;
   void SetDataTypeContext(BaseWriteTransaction* trans,
                           ModelType type,
                           const sync_pb::DataTypeContext& context);
 
   ModelTypeSet InitialSyncEndedTypes();
   bool InitialSyncEndedForType(ModelType type);
-  bool InitialSyncEndedForType(BaseTransaction* trans, ModelType type);
-
-  const std::string& name() const { return kernel_->name; }
 
   // (Account) Store birthday is opaque to the client, so we keep it in the
   // format it is in the proto buffer in case we switch to a binary birthday
   // later.
   std::string store_birthday() const;
   void set_store_birthday(const std::string& store_birthday);
 
   // (Account) Bag of chip is an opaque state used by the server to track the
   // client.
   std::string bag_of_chips() const;
   void set_bag_of_chips(const std::string& bag_of_chips);
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
   // Returns a pointer to our Nigori node handler.
   NigoriHandler* GetNigoriHandler();
 
   // Returns a pointer to our cryptographer. Does not transfer ownership.
   // Not thread safe, so should only be accessed while holding a transaction.
   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() {
     if (report_unrecoverable_error_function_) {
       report_unrecoverable_error_function_();
     }
   }
 
   // Called to set the unrecoverable error on the directory and to propagate
   // the error to upper layers.
@@ skipping 275 matching lines @@
                    EntryKernel* entry,
                    EntryKernelSet* entries_to_journal);
 
   // A private version of the public GetMetaHandlesOfType for when you already
   // have a ScopedKernelLock.
   void GetMetaHandlesOfType(const ScopedKernelLock& lock,
                             BaseTransaction* trans,
                             ModelType type,
                             std::vector<int64>* result);
 
+  // Returns true if the initial sync for |type| has completed.
+  bool InitialSyncEndedForType(BaseTransaction* trans, ModelType type);
+
   // Stops sending events to the delegate and the transaction
   // observer.
   void Close();
 
+  // 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;
+
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
   UnrecoverableErrorHandler* const unrecoverable_error_handler_;
   const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
   // Not owned.
   NigoriHandler* const nigori_handler_;
   Cryptographer* const cryptographer_;
 
   InvariantCheckLevel invariant_check_level_;
 
   // Maintain deleted entries not in |kernel_| until it's verified that they
   // are deleted in native models as well.
   scoped_ptr<DeleteJournal> delete_journal_;
 
   DISALLOW_COPY_AND_ASSIGN(Directory);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_