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

sync/syncable/syncable_write_transaction.cc

 // 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.
 
 #include "sync/syncable/syncable_write_transaction.h"
 
 #include "sync/syncable/directory.h"
 #include "sync/syncable/directory_change_delegate.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/transaction_observer.h"
@@ skipping 27 matching lines @@
   }
   // Insert only if it's not already there.
   const int64 handle = entry->ref(META_HANDLE);
   EntryKernelMutationMap::iterator it = mutations_.lower_bound(handle);
   if (it == mutations_.end() || it->first != handle) {
     mutations_[handle].original = *entry;
   }
 }
 
 ImmutableEntryKernelMutationMap WriteTransaction::RecordMutations() {
-  directory_->kernel_->transaction_mutex.AssertAcquired();
+  directory_->kernel()->transaction_mutex.AssertAcquired();
   for (syncable::EntryKernelMutationMap::iterator it = mutations_.begin();
        it != mutations_.end();) {
     EntryKernel* kernel = directory()->GetEntryByHandle(it->first);
     if (!kernel) {
       NOTREACHED();
       continue;
     }
     if (kernel->is_dirty()) {
       it->second.mutated = *kernel;
       ++it;
@@ skipping 17 matching lines @@
   Unlock();
 
   // Work after mutex is relased.
   if (has_mutations) {
     NotifyTransactionComplete(models_with_changes);
   }
 }
 
 ModelTypeSet WriteTransaction::NotifyTransactionChangingAndEnding(
     const ImmutableEntryKernelMutationMap& mutations) {
-  directory_->kernel_->transaction_mutex.AssertAcquired();
+  directory_->kernel()->transaction_mutex.AssertAcquired();
   DCHECK(!mutations.Get().empty());
 
   WriteTransactionInfo write_transaction_info(
-      directory_->kernel_->next_write_transaction_id,
+      directory_->kernel()->next_write_transaction_id,
       from_here_, writer_, mutations);
-  ++directory_->kernel_->next_write_transaction_id;
+  ++directory_->kernel()->next_write_transaction_id;
 
   ImmutableWriteTransactionInfo immutable_write_transaction_info(
       &write_transaction_info);
-  DirectoryChangeDelegate* const delegate = directory_->kernel_->delegate;
+  DirectoryChangeDelegate* const delegate = directory_->kernel()->delegate;
   std::vector<int64> entry_changed;
   if (writer_ == syncable::SYNCAPI) {
     delegate->HandleCalculateChangesChangeEventFromSyncApi(
         immutable_write_transaction_info, this, &entry_changed);
   } else {
     delegate->HandleCalculateChangesChangeEventFromSyncer(
         immutable_write_transaction_info, this, &entry_changed);
   }
   UpdateTransactionVersion(entry_changed);
 
   ModelTypeSet models_with_changes =
       delegate->HandleTransactionEndingChangeEvent(
           immutable_write_transaction_info, this);
 
-  directory_->kernel_->transaction_observer.Call(FROM_HERE,
+  directory_->kernel()->transaction_observer.Call(FROM_HERE,
       &TransactionObserver::OnTransactionWrite,
       immutable_write_transaction_info, models_with_changes);
 
   return models_with_changes;
 }
 
 void WriteTransaction::NotifyTransactionComplete(
     ModelTypeSet models_with_changes) {
-  directory_->kernel_->delegate->HandleTransactionCompleteChangeEvent(
+  directory_->kernel()->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
 void WriteTransaction::UpdateTransactionVersion(
     const std::vector<int64>& entry_changed) {
   syncer::ModelTypeSet type_seen;
   for (uint32 i = 0; i < entry_changed.size(); ++i) {
     MutableEntry entry(this, GET_BY_HANDLE, entry_changed[i]);
     if (entry.good()) {
       ModelType type = GetModelTypeFromSpecifics(entry.GetSpecifics());
@@ skipping 48 matching lines @@
     ENUM_CASE(SYNCAPI);
   };
   NOTREACHED();
   return std::string();
 }
 
 #undef ENUM_CASE
 
 }  // namespace syncable
 }  // namespace syncer