[Sync] Rework SharedValue<T> into Immutable<T>

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 72 matching lines @@
     ENUM_CASE(VACUUM_AFTER_SAVE);
     ENUM_CASE(PURGE_ENTRIES);
     ENUM_CASE(SYNCAPI);
   };
   NOTREACHED();
   return "";
 }
 
 #undef ENUM_CASE
 
-SharedEntryKernelMutationMap::SharedEntryKernelMutationMap()
-    : mutations_(new SharedMutationMap()) {}
-
-SharedEntryKernelMutationMap::SharedEntryKernelMutationMap(
-    EntryKernelMutationMap* mutations)
-    : mutations_(new SharedMutationMap(mutations)) {}
-
-SharedEntryKernelMutationMap::~SharedEntryKernelMutationMap() {}
-
-const EntryKernelMutationMap& SharedEntryKernelMutationMap::Get() const {
-  return mutations_->Get();
-}
-
-void SharedEntryKernelMutationMap::MutationMapTraits::Swap(
-    EntryKernelMutationMap* mutations1, EntryKernelMutationMap* mutations2) {
-  mutations1->swap(*mutations2);
-}
-
 namespace {
 
 DictionaryValue* EntryKernelMutationToValue(
     const EntryKernelMutation& mutation) {
   DictionaryValue* dict = new DictionaryValue();
   dict->Set("original", mutation.original.ToValue());
   dict->Set("mutated", mutation.mutated.ToValue());
   return dict;
 }
 
@@ skipping 1100 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) {
     EntryKernelMutation mutation;
     mutation.original = *entry;
     ignore_result(mutations_.insert(it, std::make_pair(handle, mutation)));
   }
 }
 
-SharedEntryKernelMutationMap WriteTransaction::RecordMutations() {
+ImmutableEntryKernelMutationMap WriteTransaction::RecordMutations() {
   dirkernel_->transaction_mutex.AssertAcquired();
   for (syncable::EntryKernelMutationMap::iterator it = mutations_.begin();
        it != mutations_.end(); ++it) {
     EntryKernel* kernel = directory()->GetEntryByHandle(it->first);
     if (!kernel) {
       NOTREACHED();
       continue;
     }
     it->second.mutated = *kernel;
   }
-  return SharedEntryKernelMutationMap(&mutations_);
+  return ImmutableEntryKernelMutationMap(&mutations_);
 }
 
 void WriteTransaction::UnlockAndNotify(
-    const SharedEntryKernelMutationMap& mutations) {
+    const ImmutableEntryKernelMutationMap& mutations) {
   // Work while transaction mutex is held.
   ModelTypeBitSet models_with_changes;
   bool has_mutations = !mutations.Get().empty();
   if (has_mutations) {
     models_with_changes = NotifyTransactionChangingAndEnding(mutations);
   }
   Unlock();
 
   // Work after mutex is relased.
   if (has_mutations) {
     NotifyTransactionComplete(models_with_changes);
   }
 }
 
 ModelTypeBitSet WriteTransaction::NotifyTransactionChangingAndEnding(
-    const SharedEntryKernelMutationMap& mutations) {
+    const ImmutableEntryKernelMutationMap& mutations) {
   dirkernel_->transaction_mutex.AssertAcquired();
   DCHECK(!mutations.Get().empty());
 
   DirectoryChangeDelegate* const delegate = dirkernel_->delegate;
   if (writer_ == syncable::SYNCAPI) {
     delegate->HandleCalculateChangesChangeEventFromSyncApi(
         mutations.Get(), this);
   } else {
     delegate->HandleCalculateChangesChangeEventFromSyncer(
         mutations.Get(), this);
   }
 
   ModelTypeBitSet models_with_changes =
       delegate->HandleTransactionEndingChangeEvent(this);
 
   dirkernel_->observers->Notify(
       &TransactionObserver::OnTransactionMutate,
       from_here_, writer_, mutations, models_with_changes);
 
   return models_with_changes;
 }
 
 void WriteTransaction::NotifyTransactionComplete(
     ModelTypeBitSet models_with_changes) {
   dirkernel_->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
 WriteTransaction::~WriteTransaction() {
-  const SharedEntryKernelMutationMap& mutations = RecordMutations();
+  const ImmutableEntryKernelMutationMap& mutations = RecordMutations();
 
   if (OFF != kInvariantCheckLevel) {
     const bool full_scan = (FULL_DB_VERIFICATION == kInvariantCheckLevel);
     if (full_scan)
       directory()->CheckTreeInvariants(this, full_scan);
     else
       directory()->CheckTreeInvariants(this, mutations.Get());
   }
 
   UnlockAndNotify(mutations);
@@ skipping 656 matching lines @@
   CHECK(result);
   for (iterator i = GetParentChildIndexLowerBound(lock, parent_id),
            end = GetParentChildIndexUpperBound(lock, parent_id);
        i != end; ++i) {
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 }  // namespace syncable