[Sync] Add support for proxy types

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 "base/debug/trace_event.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 64 matching lines @@
     const std::string& name,
     DirectoryChangeDelegate* delegate,
     const WeakHandle<TransactionObserver>& transaction_observer) {
   DCHECK(!kernel_);
   kernel_ = new Kernel(name, KernelLoadInfo(), delegate, transaction_observer);
 }
 
 Directory::PersistedKernelInfo::PersistedKernelInfo()
     : next_id(0) {
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    reset_download_progress(ModelTypeFromInt(i));
+    ModelType type = ModelTypeFromInt(i);
+    if (VirtualTypes().Has(type))
+      continue;
+    reset_download_progress(type);
     transaction_version[i] = 0;
   }
 }
 
 Directory::PersistedKernelInfo::~PersistedKernelInfo() {}
 
 void Directory::PersistedKernelInfo::reset_download_progress(
     ModelType model_type) {
   download_progress[model_type].set_data_type_id(
       GetSpecificsFieldNumberFromModelType(model_type));
@@ skipping 461 matching lines @@
     }
     if (trans.unrecoverable_error_set())
       return false;
   }
   return true;
 }
 
 bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet types,
                                        ModelTypeSet types_to_journal) {
   DCHECK(types.HasAll(types_to_journal));
+  types.RemoveAll(VirtualTypes());
 
   if (types.Empty())
     return true;
 
   {
     WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
 
     EntryKernelSet entries_to_journal;
     STLElementDeleter<EntryKernelSet> journal_deleter(&entries_to_journal);
 
@@ skipping 120 matching lines @@
   return kernel_->persisted_info.transaction_version[type];
 }
 
 void Directory::IncrementTransactionVersion(ModelType type) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->persisted_info.transaction_version[type]++;
 }
 
 ModelTypeSet Directory::InitialSyncEndedTypes() {
   syncable::ReadTransaction trans(FROM_HERE, this);
-  const ModelTypeSet all_types = ModelTypeSet::All();
+  ModelTypeSet all_types = ModelTypeSet::All();
+  all_types.RemoveAll(VirtualTypes());
   ModelTypeSet initial_sync_ended_types;
   for (ModelTypeSet::Iterator i = all_types.First(); i.Good(); i.Inc()) {
     if (InitialSyncEndedForType(&trans, i.Get())) {
       initial_sync_ended_types.Put(i.Get());
     }
   }
   return initial_sync_ended_types;
 }
 
 bool Directory::InitialSyncEndedForType(ModelType type) {
@@ skipping 583 matching lines @@
   // There were no children in the linked list.
   return NULL;
 }
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 }  // namespace syncable
 }  // namespace syncer