[Sync] Make DirectoryBackingStore's db_ private.

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 37 matching lines @@
   VERIFY_CHANGES = 1, // Checks only mutated entries.  Does not check hierarchy.
   FULL_DB_VERIFICATION = 2 // Check every entry.  This can be expensive.
 };
 
 // Directory stores and manages EntryKernels.
 //
 // This class is tightly coupled to several other classes via Directory::Kernel.
 // Although Directory's kernel_ is exposed via public accessor it should be
 // treated as pseudo-private.
 class SYNC_EXPORT Directory {
-  friend class SyncableDirectoryTest;
-  friend class syncer::TestUserShare;
-  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, ManageDeleteJournals);
-  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
-                           TakeSnapshotGetsAllDirtyHandlesTest);
-  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
-                           TakeSnapshotGetsOnlyDirtyHandlesTest);
-  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
-                           TakeSnapshotGetsMetahandlesToPurge);
-
  public:
   typedef std::vector<int64> Metahandles;
 
   // Be careful when using these hash_map containers.  According to the spec,
   // inserting into them may invalidate all iterators.
   //
   // It gets worse, though.  The Anroid STL library has a bug that means it may
   // invalidate all iterators when you erase from the map, too.  That means that
   // you can't iterate while erasing.  STLDeleteElements(), std::remove_if(),
   // and other similar functions are off-limits too, until this bug is fixed.
@@ skipping 455 matching lines @@
 
   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;
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, ManageDeleteJournals);
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
+                           TakeSnapshotGetsAllDirtyHandlesTest);
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
+                           TakeSnapshotGetsOnlyDirtyHandlesTest);
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
+                           TakeSnapshotGetsMetahandlesToPurge);
+
   // You'll notice that some of the methods below are private overloads of the
   // public ones declared above. The general pattern is that the public overload
   // constructs a ScopedKernelLock before calling the corresponding private
   // overload with the held ScopedKernelLock.
 
   virtual EntryKernel* GetEntryByHandle(const ScopedKernelLock& lock,
                                         int64 metahandle);
 
   virtual EntryKernel* GetEntryById(const ScopedKernelLock& lock, const Id& id);
 
@@ skipping 97 matching lines @@
   // 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_