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

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
+#include <cstddef>
 #include <iosfwd>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 538 matching lines @@
 typedef std::set<EntryKernel, EntryKernelLessByMetaHandle> EntryKernelSet;
 
 struct EntryKernelMutation {
   EntryKernel original, mutated;
 };
 typedef std::map<int64, EntryKernelMutation> EntryKernelMutationMap;
 
 typedef browser_sync::Immutable<EntryKernelMutationMap>
     ImmutableEntryKernelMutationMap;
 
+// A WriteTransaction has a writer tag describing which body of code is doing
+// the write. This is defined up here since WriteTransactionInfo also contains
+// one.
+enum WriterTag {
+  INVALID,
+  SYNCER,
+  AUTHWATCHER,
+  UNITTEST,
+  VACUUM_AFTER_SAVE,
+  PURGE_ENTRIES,
+  SYNCAPI
+};
+
+// Make sure to update this if you update WriterTag.
+std::string WriterTagToString(WriterTag writer_tag);
+
+struct WriteTransactionInfo {
+  WriteTransactionInfo(int64 id,
+                       tracked_objects::Location location,
+                       WriterTag writer,
+                       ImmutableEntryKernelMutationMap mutations);
+  WriteTransactionInfo();
+  ~WriteTransactionInfo();
+
+  // Caller owns the return value.
+  base::DictionaryValue* ToValue(size_t max_mutations_size) const;
+
+  int64 id;
+  // TODO(akalin): Use Location when it becomes assignable.
+  std::string location_string;
+  WriterTag writer;
+  ImmutableEntryKernelMutationMap mutations;
+};
+
+typedef
+    browser_sync::Immutable<WriteTransactionInfo>
+    ImmutableWriteTransactionInfo;
+
+// Caller owns the return value.
+base::DictionaryValue* EntryKernelMutationToValue(
+    const EntryKernelMutation& mutation);
+
 // Caller owns the return value.
 base::ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations);
 
 // How syncable indices & Indexers work.
 //
 // The syncable Directory maintains several indices on the Entries it tracks.
 // The indices follow a common pattern:
 //   (a) The index allows efficient lookup of an Entry* with particular
 //       field values.  This is done by use of a std::set<> and a custom
@@ skipping 54 matching lines @@
   static bool ShouldInclude(const EntryKernel* a);
 };
 
 // Given an Indexer providing the semantics of an index, defines the
 // set type used to actually contain the index.
 template <typename Indexer>
 struct Index {
   typedef std::set<EntryKernel*, typename Indexer::Comparator> Set;
 };
 
-// a WriteTransaction has a writer tag describing which body of code is doing
-// the write. This is defined up here since DirectoryChangeEvent also contains
-// one.
-enum WriterTag {
-  INVALID,
-  SYNCER,
-  AUTHWATCHER,
-  UNITTEST,
-  VACUUM_AFTER_SAVE,
-  PURGE_ENTRIES,
-  SYNCAPI
-};
-
-// Make sure to update this if you update WriterTag.
-std::string WriterTagToString(WriterTag writer_tag);
-
 // The name Directory in this case means the entire directory
 // structure within a single user account.
 //
 // Sqlite is a little goofy, in that each thread must access a database
 // via its own handle.  So, a Directory object should only be accessed
 // from a single thread.  Use DirectoryManager's Open() method to
 // always get a directory that has been properly initialized on the
 // current thread.
 //
 // The db is protected against concurrent modification by a reader/
@@ skipping 323 matching lines @@
     void AddRef();  // For convenience.
     void Release();
 
     FilePath const db_path;
     // TODO(timsteele): audit use of the member and remove if possible
     volatile base::subtle::AtomicWord refcount;
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     base::Lock transaction_mutex;
 
+    // Protected by transaction_mutex.  Used by WriteTransactions.
+    int64 next_write_transaction_id;
+
     // The name of this directory.
     std::string const name;
 
     // Protects all members below.
     // The mutex effectively protects all the indices, but not the
     // entries themselves.  So once a pointer to an entry is pulled
     // from the index, the mutex can be unlocked and entry read or written.
     //
     // Never hold the mutex and do anything with the database or any
     // other buffered IO.  Violating this rule will result in deadlock.
@@ skipping 23 matching lines @@
 
     // These 3 members are backed in the share_info table, and
     // their state is marked by the flag above.
 
     // A structure containing the Directory state that is written back into the
     // database on SaveChanges.
     PersistedKernelInfo persisted_info;
 
     // A unique identifier for this account's cache db, used to generate
     // unique server IDs. No need to lock, only written at init time.
-    std::string cache_guid;
+    const std::string cache_guid;
 
     // It doesn't make sense for two threads to run SaveChanges at the same
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64 next_metahandle;
 
     // Keep a history of recently flushed metahandles for debugging
     // purposes.  Protected by the save_changes_mutex.
@@ skipping 134 matching lines @@
 
 // This is not a reset.  It just sets the numeric fields which are not
 // initialized by the constructor to zero.
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_