[Sync] Move change-related methods out of SyncManager::Observer

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 51 matching lines @@
 };
 
 static const InvariantCheckLevel kInvariantCheckLevel = VERIFY_IN_MEMORY;
 
 // Max number of milliseconds to spend checking syncable entry invariants
 static const int kInvariantCheckMaxMs = 50;
 }  // namespace
 
 using std::string;
 
-
 namespace syncable {
 
 #define ENUM_CASE(x) case x: return #x; break
 
 std::string WriterTagToString(WriterTag writer_tag) {
   switch (writer_tag) {
     ENUM_CASE(INVALID);
     ENUM_CASE(SYNCER);
     ENUM_CASE(AUTHWATCHER);
     ENUM_CASE(UNITTEST);
     ENUM_CASE(VACUUM_AFTER_SAVE);
     ENUM_CASE(PURGE_ENTRIES);
     ENUM_CASE(SYNCAPI);
   };
   NOTREACHED();
   return "";
 }
 
 #undef ENUM_CASE
 
-namespace {
+WriteTransactionInfo::WriteTransactionInfo(
+    int64 id,
+    tracked_objects::Location location,
+    WriterTag writer,
+    ImmutableEntryKernelMutationMap mutations)
+    : id(id),
+      location_string(location.ToString()),
+      writer(writer),
+      mutations(mutations) {}
+
+WriteTransactionInfo::WriteTransactionInfo()
+    : id(-1), writer(INVALID) {}
+
+WriteTransactionInfo::~WriteTransactionInfo() {}
+
+base::DictionaryValue* WriteTransactionInfo::ToValue(
+    size_t max_mutations_size) const {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("id", base::Int64ToString(id));
+  dict->SetString("location", location_string);
+  dict->SetString("writer", WriterTagToString(writer));
+  Value* mutations_value = NULL;
+  const size_t mutations_size = mutations.Get().size();
+  if (mutations_size <= max_mutations_size) {
+    mutations_value = EntryKernelMutationMapToValue(mutations.Get());
+  } else {
+    mutations_value =
+        Value::CreateStringValue(
+            base::Uint64ToString(static_cast<uint64>(mutations_size)) +
+            " mutations");
+  }
+  dict->Set("mutations", mutations_value);
+  return dict;
+}
 
 DictionaryValue* EntryKernelMutationToValue(
     const EntryKernelMutation& mutation) {
   DictionaryValue* dict = new DictionaryValue();
   dict->Set("original", mutation.original.ToValue());
   dict->Set("mutated", mutation.mutated.ToValue());
   return dict;
 }
 
-}  // namespace
-
 ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations) {
   ListValue* list = new ListValue();
   for (EntryKernelMutationMap::const_iterator it = mutations.begin();
        it != mutations.end(); ++it) {
     list->Append(EntryKernelMutationToValue(it->second));
   }
   return list;
 }
 
@@ skipping 253 matching lines @@
 }
 
 Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {}
 
 Directory::Kernel::Kernel(const FilePath& db_path,
                           const string& name,
                           const KernelLoadInfo& info,
                           DirectoryChangeDelegate* delegate)
     : db_path(db_path),
       refcount(1),
+      next_write_transaction_id(0),
       name(name),
       metahandles_index(new Directory::MetahandlesIndex),
       ids_index(new Directory::IdsIndex),
       parent_id_child_index(new Directory::ParentIdChildIndex),
       client_tag_index(new Directory::ClientTagIndex),
       unapplied_update_metahandles(new MetahandleSet),
       unsynced_metahandles(new MetahandleSet),
       dirty_metahandles(new MetahandleSet),
       metahandles_to_purge(new MetahandleSet),
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
@@ skipping 857 matching lines @@
   if (has_mutations) {
     NotifyTransactionComplete(models_with_changes);
   }
 }
 
 ModelTypeBitSet WriteTransaction::NotifyTransactionChangingAndEnding(
     const ImmutableEntryKernelMutationMap& mutations) {
   dirkernel_->transaction_mutex.AssertAcquired();
   DCHECK(!mutations.Get().empty());
 
+  WriteTransactionInfo write_transaction_info(
+      dirkernel_->next_write_transaction_id, from_here_, writer_, mutations);
+  ++dirkernel_->next_write_transaction_id;
+
+  ImmutableWriteTransactionInfo immutable_write_transaction_info(
+      &write_transaction_info);
   DirectoryChangeDelegate* const delegate = dirkernel_->delegate;
   if (writer_ == syncable::SYNCAPI) {
     delegate->HandleCalculateChangesChangeEventFromSyncApi(
-        mutations.Get(), this);
+        immutable_write_transaction_info, this);
   } else {
     delegate->HandleCalculateChangesChangeEventFromSyncer(
-        mutations.Get(), this);
+        immutable_write_transaction_info, this);
   }
 
   ModelTypeBitSet models_with_changes =
-      delegate->HandleTransactionEndingChangeEvent(this);
+      delegate->HandleTransactionEndingChangeEvent(
+          immutable_write_transaction_info, this);
 
   dirkernel_->observers->Notify(
-      &TransactionObserver::OnTransactionMutate,
-      from_here_, writer_, mutations, models_with_changes);
+      &TransactionObserver::OnTransactionWrite,
+      immutable_write_transaction_info, models_with_changes);
 
   return models_with_changes;
 }
 
 void WriteTransaction::NotifyTransactionComplete(
     ModelTypeBitSet models_with_changes) {
   dirkernel_->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
@@ skipping 668 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