[Sync] Add context proto and directory support

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 <iterator>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
@@ skipping 774 matching lines @@
 int64 Directory::GetTransactionVersion(ModelType type) const {
   kernel_->transaction_mutex.AssertAcquired();
   return kernel_->persisted_info.transaction_version[type];
 }
 
 void Directory::IncrementTransactionVersion(ModelType type) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->persisted_info.transaction_version[type]++;
 }
 
+void Directory::GetDataTypeContext(ModelType type,
+                                   sync_pb::DataTypeContext* context) const {
+  kernel_->transaction_mutex.AssertAcquired();

[maniscalco, 2014/04/03 16:59:37]

I noticed that in some methods we acquire a lock (ScopedKernelLock(this);), but
in others (like here), we simply assert we've acquired the transaction_mutex. 
Can you help me understand when we do one vs. the other?

[Nicolas Zea, 2014/04/03 21:01:11]

It has to do with whether it's expected that a transaction is being held at the
time the change is made. Previously, when I was doing things through a
ProcessSyncChanges call, that would hold true. Now though I realize this is
incorrect. I've updated it to acquire the lock (here and below)

+  context->CopyFrom(kernel_->persisted_info.datatype_context[type]);
+}
+
+void Directory::SetDataTypeContext(
+    ModelType type,
+    const sync_pb::DataTypeContext& context) {
+  kernel_->transaction_mutex.AssertAcquired();

[rlarocque, 2014/04/03 17:36:55]

What's up with this pattern?  I thought the traditional approach was to require
a pointer to the current transaction.  That way you would be able to verify if
it was a read or write transaction.

(Not that it really matters, since we're not using a real read-write mutex, but
still it seems like a good idea to maintain the abstraction.)

[Nicolas Zea, 2014/04/03 21:01:11]

This is actually wrong, see above comment. I've updated to acquire the lock
there.

+  kernel_->persisted_info.datatype_context[type].CopyFrom(context);
+}
+
 ModelTypeSet Directory::InitialSyncEndedTypes() {
   syncable::ReadTransaction trans(FROM_HERE, this);
   ModelTypeSet protocol_types = ProtocolTypes();
   ModelTypeSet initial_sync_ended_types;
   for (ModelTypeSet::Iterator i = protocol_types.First(); i.Good(); i.Inc()) {
     if (InitialSyncEndedForType(&trans, i.Get())) {
       initial_sync_ended_types.Put(i.Get());
     }
   }
   return initial_sync_ended_types;
@@ skipping 493 matching lines @@
 
   for (OrderedChildSet::const_iterator i = children->begin();
        i != children->end(); ++i) {
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 }  // namespace syncable
 }  // namespace syncer