Make Directory's code style a little more consistent.

sync/syncable/directory.cc

 // 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.
 
 #include "sync/syncable/directory.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
@@ skipping 144 matching lines @@
     if (!entry->ref(UNIQUE_CLIENT_TAG).empty()) {
       DCHECK(kernel_->server_tags_map.find(entry->ref(UNIQUE_SERVER_TAG)) ==
              kernel_->server_tags_map.end())
           << "Unexpected duplicate use of server tag";
       kernel_->client_tags_map[entry->ref(UNIQUE_CLIENT_TAG)] = entry;
     }
     DCHECK(kernel_->ids_map.find(entry->ref(ID).value()) ==
            kernel_->ids_map.end()) << "Unexpected duplicate use of ID";
     kernel_->ids_map[entry->ref(ID).value()] = entry;
     DCHECK(!entry->is_dirty());
-    AddToAttachmentIndex(metahandle, entry->ref(ATTACHMENT_METADATA), lock);
+    AddToAttachmentIndex(lock, metahandle, entry->ref(ATTACHMENT_METADATA));
   }
 }
 
 DirOpenResult Directory::OpenImpl(
     const string& name,
     DirectoryChangeDelegate* delegate,
     const WeakHandle<TransactionObserver>&
         transaction_observer) {
   KernelLoadInfo info;
   // Temporary indices before kernel_ initialized in case Load fails. We 0(1)
@@ skipping 42 matching lines @@
                                      const tracked_objects::Location& location,
                                      const std::string & message) {
   DCHECK(trans != NULL);
   unrecoverable_error_set_ = true;
   unrecoverable_error_handler_->OnUnrecoverableError(location,
                                                      message);
 }
 
 EntryKernel* Directory::GetEntryById(const Id& id) {
   ScopedKernelLock lock(this);
-  return GetEntryById(id, &lock);
+  return GetEntryById(lock, id);
 }
 
-EntryKernel* Directory::GetEntryById(const Id& id,
-                                     ScopedKernelLock* const lock) {
+EntryKernel* Directory::GetEntryById(const ScopedKernelLock& lock,
+                                     const Id& id) {
   DCHECK(kernel_);
   // Find it in the in memory ID index.
   IdsMap::iterator id_found = kernel_->ids_map.find(id.value());
   if (id_found != kernel_->ids_map.end()) {
     return id_found->second;
   }
   return NULL;
 }
 
 EntryKernel* Directory::GetEntryByClientTag(const string& tag) {
@@ skipping 12 matching lines @@
   DCHECK(kernel_);
   TagsMap::iterator it = kernel_->server_tags_map.find(tag);
   if (it != kernel_->server_tags_map.end()) {
     return it->second;
   }
   return NULL;
 }
 
 EntryKernel* Directory::GetEntryByHandle(int64 metahandle) {
   ScopedKernelLock lock(this);
-  return GetEntryByHandle(metahandle, &lock);
+  return GetEntryByHandle(lock, metahandle);
 }
 
-EntryKernel* Directory::GetEntryByHandle(int64 metahandle,
-                                         ScopedKernelLock* lock) {
+EntryKernel* Directory::GetEntryByHandle(const ScopedKernelLock& lock,
+                                         int64 metahandle) {
   // Look up in memory
   MetahandlesMap::iterator found =
       kernel_->metahandles_map.find(metahandle);
   if (found != kernel_->metahandles_map.end()) {
     // Found it in memory.  Easy.
     return found->second;
   }
   return NULL;
 }
 
@@ skipping 55 matching lines @@
     EntryKernel* kernel) const {
   const OrderedChildSet* siblings =
       kernel_->parent_child_index.GetChildren(kernel->ref(PARENT_ID));
 
   OrderedChildSet::const_iterator it = siblings->find(kernel);
   return std::distance(siblings->begin(), it);
 }
 
 bool Directory::InsertEntry(BaseWriteTransaction* trans, EntryKernel* entry) {
   ScopedKernelLock lock(this);
-  return InsertEntry(trans, entry, &lock);
+  return InsertEntry(lock, trans, entry);
 }
 
-bool Directory::InsertEntry(BaseWriteTransaction* trans,
-                            EntryKernel* entry,
-                            ScopedKernelLock* lock) {
-  DCHECK(NULL != lock);
+bool Directory::InsertEntry(const ScopedKernelLock& lock,
+                            BaseWriteTransaction* trans,
+                            EntryKernel* entry) {
   if (!SyncAssert(NULL != entry, FROM_HERE, "Entry is null", trans))
     return false;
 
   static const char error[] = "Entry already in memory index.";
 
   if (!SyncAssert(
           kernel_->metahandles_map.insert(
               std::make_pair(entry->ref(META_HANDLE), entry)).second,
           FROM_HERE,
           error,
@@ skipping 10 matching lines @@
   }
   if (ParentChildIndex::ShouldInclude(entry)) {
     if (!SyncAssert(kernel_->parent_child_index.Insert(entry),
                     FROM_HERE,
                     error,
                     trans)) {
       return false;
     }
   }
   AddToAttachmentIndex(
-      entry->ref(META_HANDLE), entry->ref(ATTACHMENT_METADATA), *lock);
+      lock, entry->ref(META_HANDLE), entry->ref(ATTACHMENT_METADATA));
 
   // Should NEVER be created with a client tag or server tag.
   if (!SyncAssert(entry->ref(UNIQUE_SERVER_TAG).empty(), FROM_HERE,
                   "Server tag should be empty", trans)) {
     return false;
   }
   if (!SyncAssert(entry->ref(UNIQUE_CLIENT_TAG).empty(), FROM_HERE,
                   "Client tag should be empty", trans))
     return false;
 
   return true;
 }
 
 bool Directory::ReindexId(BaseWriteTransaction* trans,
                           EntryKernel* const entry,
                           const Id& new_id) {
   ScopedKernelLock lock(this);
-  if (NULL != GetEntryById(new_id, &lock))
+  if (NULL != GetEntryById(lock, new_id))
     return false;
 
   {
     // Update the indices that depend on the ID field.
     ScopedParentChildIndexUpdater updater_b(lock, entry,
         &kernel_->parent_child_index);
     size_t num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
     DCHECK_EQ(1U, num_erased);
     entry->put(ID, new_id);
     kernel_->ids_map[entry->ref(ID).value()] = entry;
   }
   return true;
 }
 
 bool Directory::ReindexParentId(BaseWriteTransaction* trans,
                                 EntryKernel* const entry,
                                 const Id& new_parent_id) {
   ScopedKernelLock lock(this);
 
   {
     // Update the indices that depend on the PARENT_ID field.
     ScopedParentChildIndexUpdater index_updater(lock, entry,
         &kernel_->parent_child_index);
     entry->put(PARENT_ID, new_parent_id);
   }
   return true;
 }
 
 void Directory::RemoveFromAttachmentIndex(
+    const ScopedKernelLock& lock,
     const int64 metahandle,
-    const sync_pb::AttachmentMetadata& attachment_metadata,
-    const ScopedKernelLock& lock) {
+    const sync_pb::AttachmentMetadata& attachment_metadata) {
   for (int i = 0; i < attachment_metadata.record_size(); ++i) {
     AttachmentIdUniqueId unique_id =
         attachment_metadata.record(i).id().unique_id();
     IndexByAttachmentId::iterator iter =
         kernel_->index_by_attachment_id.find(unique_id);
     if (iter != kernel_->index_by_attachment_id.end()) {
       iter->second.erase(metahandle);
       if (iter->second.empty()) {
         kernel_->index_by_attachment_id.erase(iter);
       }
     }
   }
 }
 
 void Directory::AddToAttachmentIndex(
+    const ScopedKernelLock& lock,
     const int64 metahandle,
-    const sync_pb::AttachmentMetadata& attachment_metadata,
-    const ScopedKernelLock& lock) {
+    const sync_pb::AttachmentMetadata& attachment_metadata) {
   for (int i = 0; i < attachment_metadata.record_size(); ++i) {
     AttachmentIdUniqueId unique_id =
         attachment_metadata.record(i).id().unique_id();
     IndexByAttachmentId::iterator iter =
         kernel_->index_by_attachment_id.find(unique_id);
     if (iter == kernel_->index_by_attachment_id.end()) {
       iter = kernel_->index_by_attachment_id.insert(std::make_pair(
                                                         unique_id,
                                                         MetahandleSet())).first;
     }
     iter->second.insert(metahandle);
   }
 }
 
 void Directory::UpdateAttachmentIndex(
     const int64 metahandle,
     const sync_pb::AttachmentMetadata& old_metadata,
     const sync_pb::AttachmentMetadata& new_metadata) {
   ScopedKernelLock lock(this);
-  RemoveFromAttachmentIndex(metahandle, old_metadata, lock);
-  AddToAttachmentIndex(metahandle, new_metadata, lock);
+  RemoveFromAttachmentIndex(lock, metahandle, old_metadata);
+  AddToAttachmentIndex(lock, metahandle, new_metadata);
 }
 
 void Directory::GetMetahandlesByAttachmentId(
     BaseTransaction* trans,
     const sync_pb::AttachmentIdProto& attachment_id_proto,
     Metahandles* result) {
   DCHECK(result);
   result->clear();
   ScopedKernelLock lock(this);
   IndexByAttachmentId::const_iterator index_iter =
       kernel_->index_by_attachment_id.find(attachment_id_proto.unique_id());
   if (index_iter == kernel_->index_by_attachment_id.end())
     return;
   const MetahandleSet& metahandle_set = index_iter->second;
   std::copy(
       metahandle_set.begin(), metahandle_set.end(), back_inserter(*result));
 }
 
 bool Directory::unrecoverable_error_set(const BaseTransaction* trans) const {
   DCHECK(trans != NULL);
   return unrecoverable_error_set_;
 }
 
-void Directory::ClearDirtyMetahandles() {
+void Directory::ClearDirtyMetahandles(const ScopedKernelLock& lock) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->dirty_metahandles.clear();
 }
 
 bool Directory::SafeToPurgeFromMemory(WriteTransaction* trans,
                                       const EntryKernel* const entry) const {
   bool safe = entry->ref(IS_DEL) && !entry->is_dirty() &&
       !entry->ref(SYNCING) && !entry->ref(IS_UNAPPLIED_UPDATE) &&
       !entry->ref(IS_UNSYNCED);
 
@@ skipping 25 matching lines @@
   ScopedKernelLock lock(this);
 
   // If there is an unrecoverable error then just bail out.
   if (unrecoverable_error_set(&trans))
     return;
 
   // Deep copy dirty entries from kernel_->metahandles_index into snapshot and
   // clear dirty flags.
   for (MetahandleSet::const_iterator i = kernel_->dirty_metahandles.begin();
        i != kernel_->dirty_metahandles.end(); ++i) {
-    EntryKernel* entry = GetEntryByHandle(*i, &lock);
+    EntryKernel* entry = GetEntryByHandle(lock, *i);
     if (!entry)
       continue;
     // Skip over false positives; it happens relatively infrequently.
     if (!entry->is_dirty())
       continue;
     snapshot->dirty_metas.insert(snapshot->dirty_metas.end(),
                                  new EntryKernel(*entry));
     DCHECK_EQ(1U, kernel_->dirty_metahandles.count(*i));
     // We don't bother removing from the index here as we blow the entire thing
     // in a moment, and it unnecessarily complicates iteration.
     entry->clear_dirty(NULL);
   }
-  ClearDirtyMetahandles();
+  ClearDirtyMetahandles(lock);
 
   // Set purged handles.
   DCHECK(snapshot->metahandles_to_purge.empty());
   snapshot->metahandles_to_purge.swap(kernel_->metahandles_to_purge);
 
   // Fill kernel_info_status and kernel_info.
   snapshot->kernel_info = kernel_->persisted_info;
   // To avoid duplicates when the process crashes, we record the next_id to be
   // greater magnitude than could possibly be reached before the next save
   // changes.  In other words, it's effectively impossible for the user to
@@ skipping 56 matching lines @@
         num_erased =
             kernel_->client_tags_map.erase(entry->ref(UNIQUE_CLIENT_TAG));
         DCHECK_EQ(1u, num_erased);
       }
       if (!SyncAssert(!kernel_->parent_child_index.Contains(entry),
                       FROM_HERE,
                       "Deleted entry still present",
                       (&trans)))
         return false;
       RemoveFromAttachmentIndex(
-          entry->ref(META_HANDLE), entry->ref(ATTACHMENT_METADATA), lock);
+          lock, entry->ref(META_HANDLE), entry->ref(ATTACHMENT_METADATA));
 
       delete entry;
     }
     if (trans.unrecoverable_error_set())
       return false;
   }
   return true;
 }
 
 void Directory::UnapplyEntry(EntryKernel* entry) {
@@ skipping 38 matching lines @@
     entry->put(BASE_VERSION, CHANGES_VERSION);
     entry->mark_dirty(&kernel_->dirty_metahandles);
   }
 
   // At this point locally created items that aren't synced will become locally
   // deleted items, and purged on the next snapshot. All other items will match
   // the state they would have had if they were just created via a server
   // update. See MutableEntry::MutableEntry(.., CreateNewUpdateItem, ..).
 }
 
-void Directory::DeleteEntry(bool save_to_journal,
+void Directory::DeleteEntry(const ScopedKernelLock& lock,
+                            bool save_to_journal,
                             EntryKernel* entry,
-                            EntryKernelSet* entries_to_journal,
-                            const ScopedKernelLock& lock) {
+                            EntryKernelSet* entries_to_journal) {
   int64 handle = entry->ref(META_HANDLE);
   ModelType server_type = GetModelTypeFromSpecifics(
       entry->ref(SERVER_SPECIFICS));
 
   kernel_->metahandles_to_purge.insert(handle);
 
   size_t num_erased = 0;
   num_erased = kernel_->metahandles_map.erase(entry->ref(META_HANDLE));
   DCHECK_EQ(1u, num_erased);
   num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
   DCHECK_EQ(1u, num_erased);
   num_erased = kernel_->unsynced_metahandles.erase(handle);
   DCHECK_EQ(entry->ref(IS_UNSYNCED), num_erased > 0);
   num_erased =
       kernel_->unapplied_update_metahandles[server_type].erase(handle);
   DCHECK_EQ(entry->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
   if (kernel_->parent_child_index.Contains(entry))
     kernel_->parent_child_index.Remove(entry);
 
   if (!entry->ref(UNIQUE_CLIENT_TAG).empty()) {
     num_erased =
         kernel_->client_tags_map.erase(entry->ref(UNIQUE_CLIENT_TAG));
     DCHECK_EQ(1u, num_erased);
   }
   if (!entry->ref(UNIQUE_SERVER_TAG).empty()) {
     num_erased =
         kernel_->server_tags_map.erase(entry->ref(UNIQUE_SERVER_TAG));
     DCHECK_EQ(1u, num_erased);
   }
-  RemoveFromAttachmentIndex(handle, entry->ref(ATTACHMENT_METADATA), lock);
+  RemoveFromAttachmentIndex(lock, handle, entry->ref(ATTACHMENT_METADATA));
 
   if (save_to_journal) {
     entries_to_journal->insert(entry);
   } else {
     delete entry;
   }
 }
 
 bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet disabled_types,
                                        ModelTypeSet types_to_journal,
@@ skipping 59 matching lines @@
 
         if (types_to_unapply.Has(local_type) ||
             types_to_unapply.Has(server_type)) {
           UnapplyEntry(entry);
         } else {
           bool save_to_journal =
               (types_to_journal.Has(local_type) ||
                types_to_journal.Has(server_type)) &&
               (delete_journal_->IsDeleteJournalEnabled(local_type) ||
                delete_journal_->IsDeleteJournalEnabled(server_type));
-          DeleteEntry(save_to_journal, entry, &entries_to_journal, lock);
+          DeleteEntry(lock, save_to_journal, entry, &entries_to_journal);
         }
       }
 
       delete_journal_->AddJournalBatch(&trans, entries_to_journal);
 
       // Ensure meta tracking for these data types reflects the purged state.
       for (ModelTypeSet::Iterator it = disabled_types.First();
            it.Good(); it.Inc()) {
         kernel_->persisted_info.transaction_version[it.Get()] = 0;
 
@@ skipping 20 matching lines @@
   if (!type_root)
     return false;
 
   ScopedKernelLock lock(this);
   const Id& type_root_id = type_root->ref(ID);
   Directory::Metahandles children;
   AppendChildHandles(lock, type_root_id, &children);
 
   for (Metahandles::iterator it = children.begin(); it != children.end();
        ++it) {
-    EntryKernel* entry = GetEntryByHandle(*it, &lock);
+    EntryKernel* entry = GetEntryByHandle(lock, *it);
     if (!entry)
       continue;
     if (entry->ref(BASE_VERSION) > 1)
       entry->put(BASE_VERSION, 1);
     if (entry->ref(SERVER_VERSION) > 1)
       entry->put(SERVER_VERSION, 1);
 
     // Note that we do not unset IS_UNSYNCED or IS_UNAPPLIED_UPDATE in order
     // to ensure no in-transit data is lost.
 
@@ skipping 635 matching lines @@
   AttachmentIdSet on_server_id_set;
   AttachmentIdSet not_on_server_id_set;
   std::vector<int64> metahandles;
   {
     ScopedKernelLock lock(this);
     GetMetaHandlesOfType(lock, trans, type, &metahandles);
     std::vector<int64>::const_iterator iter = metahandles.begin();
     const std::vector<int64>::const_iterator end = metahandles.end();
     // For all of this type's entries...
     for (; iter != end; ++iter) {
-      EntryKernel* entry = GetEntryByHandle(*iter, &lock);
+      EntryKernel* entry = GetEntryByHandle(lock, *iter);
       DCHECK(entry);
       const sync_pb::AttachmentMetadata metadata =
           entry->ref(ATTACHMENT_METADATA);
       // for each of this entry's attachments...
       for (int i = 0; i < metadata.record_size(); ++i) {
         AttachmentId id =
             AttachmentId::CreateFromProto(metadata.record(i).id());
         // if this attachment is known to be on the server, remember it for
         // later,
         if (metadata.record(i).is_on_server()) {
@@ skipping 16 matching lines @@
   // TODO(maniscalco): Eliminate redundant metadata storage (bug 415203).
   std::set_difference(not_on_server_id_set.begin(),
                       not_on_server_id_set.end(),
                       on_server_id_set.begin(),
                       on_server_id_set.end(),
                       std::inserter(*id_set, id_set->end()));
 }
 
 }  // namespace syncable
 }  // namespace syncer