Remove initial_sync_ended bits

sync/syncable/directory.cc

 // Copyright (c) 2012 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 578 matching lines @@
           kernel_->metahandles_index->erase(it++);
           delete entry;
         } else {
           ++it;
         }
       }
 
       // Ensure meta tracking for these data types reflects the deleted state.
       for (ModelTypeSet::Iterator it = types.First();
            it.Good(); it.Inc()) {
-        set_initial_sync_ended_for_type_unsafe(it.Get(), false);
         kernel_->persisted_info.reset_download_progress(it.Get());
         kernel_->persisted_info.transaction_version[it.Get()] = 0;
       }
     }
   }
   return true;
 }
 
 void Directory::HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot) {
   ScopedKernelLock lock(this);
@@ skipping 50 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]++;
 }
 
-ModelTypeSet Directory::initial_sync_ended_types() const {
-  ScopedKernelLock lock(this);
-  return kernel_->persisted_info.initial_sync_ended;
+ModelTypeSet Directory::InitialSyncEndedTypes() {
+  syncable::ReadTransaction trans(FROM_HERE, this);
+  const ModelTypeSet all_types = ModelTypeSet::All();
+  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::initial_sync_ended_for_type(ModelType type) const {
-  ScopedKernelLock lock(this);
-  return kernel_->persisted_info.initial_sync_ended.Has(type);
+bool Directory::InitialSyncEndedForType(ModelType type) {
+  syncable::ReadTransaction trans(FROM_HERE, this);
+  return InitialSyncEndedForType(&trans, type);
+}
+
+bool Directory::InitialSyncEndedForType(
+    BaseTransaction* trans, ModelType type) {
+  // True iff the type's root node has been received and applied.
+  syncable::Entry entry(trans,
+                        syncable::GET_BY_SERVER_TAG,
+                        ModelTypeToRootTag(type));
+  return entry.good() && entry.Get(syncable::BASE_VERSION) != CHANGES_VERSION;
 }
 
 template <class T> void Directory::TestAndSet(
     T* kernel_data, const T* data_to_set) {
   if (*kernel_data != *data_to_set) {
     *kernel_data = *data_to_set;
     kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
   }
 }
 
-void Directory::set_initial_sync_ended_for_type(ModelType type, bool x) {
-  ScopedKernelLock lock(this);
-  set_initial_sync_ended_for_type_unsafe(type, x);
-}
-
-void Directory::set_initial_sync_ended_for_type_unsafe(ModelType type,
-                                                       bool x) {
-  if (kernel_->persisted_info.initial_sync_ended.Has(type) == x)
-    return;
-  if (x) {
-    kernel_->persisted_info.initial_sync_ended.Put(type);
-  } else {
-    kernel_->persisted_info.initial_sync_ended.Remove(type);
-  }
-  kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
-}
-
 void Directory::SetNotificationStateUnsafe(
     const std::string& notification_state) {
   if (notification_state == kernel_->persisted_info.notification_state)
     return;
   kernel_->persisted_info.notification_state = notification_state;
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 string Directory::store_birthday() const {
   ScopedKernelLock lock(this);
@@ skipping 552 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