[Sync] Eliminate friends from Directory by exposing kernel via accessor

sync/syncable/directory_unittest.cc

 // Copyright 2014 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.
 
 #include "sync/syncable/directory_unittest.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/test/values_test_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/syncable/syncable_proto_util.h"
@@ skipping 137 matching lines @@
 void SyncableDirectoryTest::CheckPurgeEntriesWithTypeInSucceeded(
     ModelTypeSet types_to_purge,
     bool before_reload) {
   SCOPED_TRACE(testing::Message("Before reload: ") << before_reload);
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
     MetahandleSet all_set;
     dir_->GetAllMetaHandles(&trans, &all_set);
     EXPECT_EQ(4U, all_set.size());
     if (before_reload)
-      EXPECT_EQ(6U, dir_->kernel_->metahandles_to_purge.size());
+      EXPECT_EQ(6U, dir_->kernel()->metahandles_to_purge.size());
     for (MetahandleSet::iterator iter = all_set.begin(); iter != all_set.end();
          ++iter) {
       Entry e(&trans, GET_BY_HANDLE, *iter);
       const ModelType local_type = e.GetModelType();
       const ModelType server_type = e.GetServerModelType();
 
       // Note the dance around incrementing |it|, since we sometimes erase().
       if ((IsRealDataType(local_type) && types_to_purge.Has(local_type)) ||
           (IsRealDataType(server_type) && types_to_purge.Has(server_type))) {
         FAIL() << "Illegal type should have been deleted.";
@@ skipping 11 matching lines @@
     ReadTransaction trans(FROM_HERE, dir_.get());
     sync_pb::DataTypeContext context;
     dir_->GetDataTypeContext(&trans, it.Get(), &context);
     EXPECT_TRUE(context.SerializeAsString().empty());
   }
   EXPECT_FALSE(types_to_purge.Has(BOOKMARKS));
   EXPECT_TRUE(dir_->InitialSyncEndedForType(BOOKMARKS));
 }
 
 bool SyncableDirectoryTest::IsInDirtyMetahandles(int64 metahandle) {
-  return 1 == dir_->kernel_->dirty_metahandles.count(metahandle);
+  return 1 == dir_->kernel()->dirty_metahandles.count(metahandle);
 }
 
 bool SyncableDirectoryTest::IsInMetahandlesToPurge(int64 metahandle) {
-  return 1 == dir_->kernel_->metahandles_to_purge.count(metahandle);
+  return 1 == dir_->kernel()->metahandles_to_purge.count(metahandle);
 }
 
 scoped_ptr<Directory>& SyncableDirectoryTest::dir() {
   return dir_;
 }
 
 DirectoryChangeDelegate* SyncableDirectoryTest::directory_change_delegate() {
   return &delegate_;
 }
 
@@ skipping 44 matching lines @@
       }
       e.PutSpecifics(specs);
       e.PutServerSpecifics(specs);
     }
   }
 
   ModelTypeSet to_purge(BOOKMARKS);
   dir()->PurgeEntriesWithTypeIn(to_purge, ModelTypeSet(), ModelTypeSet());
 
   Directory::SaveChangesSnapshot snapshot1;
-  base::AutoLock scoped_lock(dir()->kernel_->save_changes_mutex);
+  base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
   dir()->TakeSnapshotForSaveChanges(&snapshot1);
   EXPECT_TRUE(expected_purges == snapshot1.metahandles_to_purge);
 
   to_purge.Clear();
   to_purge.Put(PREFERENCES);
   dir()->PurgeEntriesWithTypeIn(to_purge, ModelTypeSet(), ModelTypeSet());
 
   dir()->HandleSaveChangesFailure(snapshot1);
 
   Directory::SaveChangesSnapshot snapshot2;
   dir()->TakeSnapshotForSaveChanges(&snapshot2);
   EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
   const int metahandles_to_create = 100;
   std::vector<int64> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     for (int i = 0; i < metahandles_to_create; i++) {
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.GetMetahandle());
       e.PutIsUnsynced(true);
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
-    base::AutoLock scoped_lock(dir()->kernel_->save_changes_mutex);
+    base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     ASSERT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
          i != snapshot.dirty_metas.end();
          ++i) {
       ASSERT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
@@ skipping 15 matching lines @@
       e2.PutIsUnsynced(true);
       new_dirty_metahandles.push_back(e2.GetMetahandle());
     }
     expected_dirty_metahandles.insert(expected_dirty_metahandles.end(),
                                       new_dirty_metahandles.begin(),
                                       new_dirty_metahandles.end());
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
-    base::AutoLock scoped_lock(dir()->kernel_->save_changes_mutex);
+    base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
          i != snapshot.dirty_metas.end();
          ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
@@ skipping 46 matching lines @@
          i != expected_dirty_metahandles.end();
          ++i) {
       MutableEntry e(&trans, GET_BY_HANDLE, *i);
       ASSERT_TRUE(e.good());
       // We aren't doing anything to dirty these entries.
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
-    base::AutoLock scoped_lock(dir()->kernel_->save_changes_mutex);
+    base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there are no dirty_metahandles.
     EXPECT_EQ(0u, snapshot.dirty_metas.size());
     dir()->VacuumAfterSaveChanges(snapshot);
   }
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     bool should_change = false;
     for (std::vector<int64>::const_iterator i =
              expected_dirty_metahandles.begin();
          i != expected_dirty_metahandles.end();
          ++i) {
       // Maybe change entries by flipping IS_DIR.
       MutableEntry e(&trans, GET_BY_HANDLE, *i);
       ASSERT_TRUE(e.good());
       should_change = !should_change;
       if (should_change) {
         bool not_dir = !e.GetIsDir();
         e.PutIsDir(not_dir);
         e.PutIsUnsynced(true);
       }
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
-    base::AutoLock scoped_lock(dir()->kernel_->save_changes_mutex);
+    base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each changed metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(number_changed, snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
          i != snapshot.dirty_metas.end();
          ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
@@ skipping 1573 matching lines @@
 
     Entry item2(&trans, GET_BY_ID, item2_id);
     EXPECT_EQ(item1_id, item2.GetPredecessorId());
     EXPECT_EQ(Id(), item2.GetSuccessorId());
   }
 }
 
 }  // namespace syncable
 
 }  // namespace syncer