[Sync] Make syncer commands avoid posting tasks on threads with no work to do

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 <algorithm>
 #include <cstring>
 #include <functional>
 #include <iomanip>
@@ skipping 240 matching lines @@
 
 EntryKernel::EntryKernel() : dirty_(false) {
   // Everything else should already be default-initialized.
   for (int i = INT64_FIELDS_BEGIN; i < INT64_FIELDS_END; ++i) {
     int64_fields[i] = 0;
   }
 }
 
 EntryKernel::~EntryKernel() {}
 
+syncable::ModelType EntryKernel::GetServerModelType() const {
+  ModelType specifics_type = GetModelTypeFromSpecifics(ref(SERVER_SPECIFICS));
+  if (specifics_type != UNSPECIFIED)
+    return specifics_type;
+  if (ref(ID).IsRoot())
+    return TOP_LEVEL_FOLDER;
+  // Loose check for server-created top-level folders that aren't
+  // bound to a particular model type.
+  if (!ref(UNIQUE_SERVER_TAG).empty() && ref(SERVER_IS_DIR))
+    return TOP_LEVEL_FOLDER;
+
+  return UNSPECIFIED;
+}
+
 bool EntryKernel::ContainsString(const std::string& lowercase_query) const {
   // TODO(lipalani) - figure out what to do if the node is encrypted.
   const sync_pb::EntitySpecifics& specifics = ref(SPECIFICS);
   std::string temp;
   // The protobuf serialized string contains the original strings. So
   // we will just serialize it and search it.
   specifics.SerializeToString(&temp);
 
   // Now convert to lower case.
   StringToLowerASCII(&temp);
@@ skipping 50 matching lines @@
 
 StringValue* IdToValue(const Id& id) {
   return id.ToValue();
 }
 
 }  // namespace
 
 DictionaryValue* EntryKernel::ToValue() const {
   DictionaryValue* kernel_info = new DictionaryValue();
   kernel_info->SetBoolean("isDirty", is_dirty());
+  kernel_info->Set("serverModelType", ModelTypeToValue(GetServerModelType()));
 
   // Int64 fields.
   SetFieldValues(*this, kernel_info,
                  &GetMetahandleFieldString, &Int64ToValue,
                  INT64_FIELDS_BEGIN, META_HANDLE);
   SetFieldValues(*this, kernel_info,
                  &GetBaseVersionString, &Int64ToValue,
                  META_HANDLE + 1, BASE_VERSION);
   SetFieldValues(*this, kernel_info,
                  &GetInt64FieldString, &Int64ToValue,
@@ skipping 85 matching lines @@
     const browser_sync::WeakHandle<TransactionObserver>&
         transaction_observer)
     : 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),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1),
       delegate(delegate),
       transaction_observer(transaction_observer) {
   DCHECK(delegate);
   DCHECK(transaction_observer.IsInitialized());
 }
 
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
 
 void Directory::Kernel::Release() {
   if (!base::subtle::NoBarrier_AtomicIncrement(&refcount, -1))
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
   CHECK_EQ(0, refcount);
   delete unsynced_metahandles;
-  delete unapplied_update_metahandles;
   delete dirty_metahandles;
   delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   STLDeleteElements(metahandles_index);
   delete metahandles_index;
 }
 
 Directory::Directory() : kernel_(NULL), store_(NULL) {
@@ skipping 16 matching lines @@
 }
 
 void Directory::InitializeIndices() {
   MetahandlesIndex::iterator it = kernel_->metahandles_index->begin();
   for (; it != kernel_->metahandles_index->end(); ++it) {
     EntryKernel* entry = *it;
     InitializeIndexEntry<ParentIdAndHandleIndexer>(entry,
         kernel_->parent_id_child_index);
     InitializeIndexEntry<IdIndexer>(entry, kernel_->ids_index);
     InitializeIndexEntry<ClientTagIndexer>(entry, kernel_->client_tag_index);
+    const int64 metahandle = entry->ref(META_HANDLE);
     if (entry->ref(IS_UNSYNCED))
-      kernel_->unsynced_metahandles->insert(entry->ref(META_HANDLE));
-    if (entry->ref(IS_UNAPPLIED_UPDATE))
-      kernel_->unapplied_update_metahandles->insert(entry->ref(META_HANDLE));
+      kernel_->unsynced_metahandles->insert(metahandle);
+    if (entry->ref(IS_UNAPPLIED_UPDATE)) {
+      const ModelType type = entry->GetServerModelType();
+      kernel_->unapplied_update_metahandles[type].insert(metahandle);
+    }
     DCHECK(!entry->is_dirty());
   }
 }
 
 DirectoryBackingStore* Directory::CreateBackingStore(
     const string& dir_name, const FilePath& backing_filepath) {
   return new DirectoryBackingStore(dir_name, backing_filepath);
 }
 
 DirOpenResult Directory::OpenImpl(
@@ skipping 182 matching lines @@
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->dirty_metahandles->clear();
 }
 
 bool Directory::SafeToPurgeFromMemory(const EntryKernel* const entry) const {
   bool safe = entry->ref(IS_DEL) && !entry->is_dirty() &&
       !entry->ref(SYNCING) && !entry->ref(IS_UNAPPLIED_UPDATE) &&
       !entry->ref(IS_UNSYNCED);
 
   if (safe) {
-    int64 handle = entry->ref(META_HANDLE);
+    const int64 handle = entry->ref(META_HANDLE);
+    const ModelType type = entry->GetServerModelType();
     CHECK_EQ(kernel_->dirty_metahandles->count(handle), 0U);
     // TODO(tim): Bug 49278.
     CHECK(!kernel_->unsynced_metahandles->count(handle));
-    CHECK(!kernel_->unapplied_update_metahandles->count(handle));
+    CHECK(!kernel_->unapplied_update_metahandles[type].count(handle));
   }
 
   return safe;
 }
 
 void Directory::TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot) {
   ReadTransaction trans(FROM_HERE, this);
   ScopedKernelLock lock(this);
   // Deep copy dirty entries from kernel_->metahandles_index into snapshot and
   // clear dirty flags.
@@ skipping 110 matching lines @@
           kernel_->metahandles_to_purge->insert(handle);
 
           size_t num_erased = 0;
           EntryKernel* entry = *it;
           num_erased = kernel_->ids_index->erase(entry);
           DCHECK_EQ(1u, num_erased);
           num_erased = kernel_->client_tag_index->erase(entry);
           DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
           num_erased = kernel_->unsynced_metahandles->erase(handle);
           DCHECK_EQ(entry->ref(IS_UNSYNCED), num_erased > 0);
-          num_erased = kernel_->unapplied_update_metahandles->erase(handle);
+          num_erased =
+              kernel_->unapplied_update_metahandles[server_type].erase(handle);
           DCHECK_EQ(entry->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
           num_erased = kernel_->parent_id_child_index->erase(entry);
           DCHECK_EQ(entry->ref(IS_DEL), !num_erased);
           kernel_->metahandles_index->erase(it++);
           delete entry;
         } else {
           ++it;
         }
       }
 
@@ skipping 149 matching lines @@
   ScopedKernelLock lock(this);
   copy(kernel_->unsynced_metahandles->begin(),
        kernel_->unsynced_metahandles->end(), back_inserter(*result));
 }
 
 int64 Directory::unsynced_entity_count() const {
   ScopedKernelLock lock(this);
   return kernel_->unsynced_metahandles->size();
 }
 
-void Directory::GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
+syncable::ModelTypeBitSet
+    Directory::GetServerTypesWithUnappliedUpdates(
+        BaseTransaction* trans) const {
+  syncable::ModelTypeBitSet server_types;
+  ScopedKernelLock lock(this);
+  for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
+    if (!kernel_->unapplied_update_metahandles[i].empty()) {
+      server_types.set(i);
+    }
+  }
+  return server_types;
+}
+
+void Directory::GetUnappliedUpdateMetaHandles(
+    BaseTransaction* trans,
+    syncable::ModelTypeBitSet server_types,
     UnappliedUpdateMetaHandles* result) {
   result->clear();
   ScopedKernelLock lock(this);
-  copy(kernel_->unapplied_update_metahandles->begin(),
-       kernel_->unapplied_update_metahandles->end(),
-       back_inserter(*result));
+  for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
+    const ModelType type = ModelTypeFromInt(i);
+    if (server_types.test(type)) {
+      std::copy(kernel_->unapplied_update_metahandles[type].begin(),
+                kernel_->unapplied_update_metahandles[type].end(),
+                back_inserter(*result));
+    }
+  }
 }
 
 
 class IdFilter {
  public:
   virtual ~IdFilter() { }
   virtual bool ShouldConsider(const Id& id) const = 0;
 };
 
 
@@ skipping 336 matching lines @@
 
 Id Entry::ComputePrevIdFromServerPosition(const Id& parent_id) const {
   return dir()->ComputePrevIdFromServerPosition(kernel_, parent_id);
 }
 
 DictionaryValue* Entry::ToValue() const {
   DictionaryValue* entry_info = new DictionaryValue();
   entry_info->SetBoolean("good", good());
   if (good()) {
     entry_info->Set("kernel", kernel_->ToValue());
-    entry_info->Set("serverModelType",
-                    ModelTypeToValue(GetServerModelTypeHelper()));
     entry_info->Set("modelType",
                     ModelTypeToValue(GetModelType()));
     entry_info->SetBoolean("existsOnClientBecauseNameIsNonEmpty",
                            ExistsOnClientBecauseNameIsNonEmpty());
     entry_info->SetBoolean("isRoot", IsRoot());
   }
   return entry_info;
 }
 
 const string& Entry::Get(StringField field) const {
   DCHECK(kernel_);
   return kernel_->ref(field);
 }
 
 syncable::ModelType Entry::GetServerModelType() const {
-  ModelType specifics_type = GetServerModelTypeHelper();
+  ModelType specifics_type = kernel_->GetServerModelType();
   if (specifics_type != UNSPECIFIED)
     return specifics_type;
 
   // Otherwise, we don't have a server type yet.  That should only happen
   // if the item is an uncommitted locally created item.
   // It's possible we'll need to relax these checks in the future; they're
   // just here for now as a safety measure.
   DCHECK(Get(IS_UNSYNCED));
   DCHECK_EQ(Get(SERVER_VERSION), 0);
   DCHECK(Get(SERVER_IS_DEL));
   // Note: can't enforce !Get(ID).ServerKnows() here because that could
   // actually happen if we hit AttemptReuniteLostCommitResponses.
   return UNSPECIFIED;
 }
 
-syncable::ModelType Entry::GetServerModelTypeHelper() const {
-  ModelType specifics_type = GetModelTypeFromSpecifics(Get(SERVER_SPECIFICS));
-  if (specifics_type != UNSPECIFIED)
-    return specifics_type;
-  if (IsRoot())
-    return TOP_LEVEL_FOLDER;
-  // Loose check for server-created top-level folders that aren't
-  // bound to a particular model type.
-  if (!Get(UNIQUE_SERVER_TAG).empty() && Get(SERVER_IS_DIR))
-    return TOP_LEVEL_FOLDER;
-
-  return UNSPECIFIED;
-}
-
 syncable::ModelType Entry::GetModelType() const {
   ModelType specifics_type = GetModelTypeFromSpecifics(Get(SPECIFICS));
   if (specifics_type != UNSPECIFIED)
     return specifics_type;
   if (IsRoot())
     return TOP_LEVEL_FOLDER;
   // Loose check for server-created top-level folders that aren't
   // bound to a particular model type.
   if (!Get(UNIQUE_SERVER_TAG).empty() && Get(IS_DIR))
     return TOP_LEVEL_FOLDER;
@@ skipping 166 matching lines @@
 bool MutableEntry::Put(StringField field, const string& value) {
   return PutImpl(field, value);
 }
 
 bool MutableEntry::Put(ProtoField field,
                        const sync_pb::EntitySpecifics& value) {
   DCHECK(kernel_);
   // TODO(ncarter): This is unfortunately heavyweight.  Can we do
   // better?
   if (kernel_->ref(field).SerializeAsString() != value.SerializeAsString()) {
+    const bool update_unapplied_updates_index =
+        (field == SERVER_SPECIFICS) && kernel_->ref(IS_UNAPPLIED_UPDATE);
+    if (update_unapplied_updates_index) {
+      // Remove ourselves from unapplied_update_metahandles with our
+      // old server type.
+      const syncable::ModelType old_server_type =
+          kernel_->GetServerModelType();
+      const int64 metahandle = kernel_->ref(META_HANDLE);
+      size_t erase_count =
+          dir()->kernel_->unapplied_update_metahandles[old_server_type]
+          .erase(metahandle);
+      DCHECK_EQ(erase_count, 1u);
+    }
+
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
+
+    if (update_unapplied_updates_index) {
+      // Add ourselves back into unapplied_update_metahandles with our
+      // new server type.
+      const syncable::ModelType new_server_type =
+          kernel_->GetServerModelType();
+      const int64 metahandle = kernel_->ref(META_HANDLE);
+      dir()->kernel_->unapplied_update_metahandles[new_server_type]
+          .insert(metahandle);
+    }
   }
   return true;
 }
 
 bool MutableEntry::Put(BitField field, bool value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     kernel_->put(field, value);
     kernel_->mark_dirty(GetDirtyIndexHelper());
   }
@@ skipping 42 matching lines @@
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
 bool MutableEntry::Put(IndexedBitField field, bool value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     MetahandleSet* index;
-    if (IS_UNSYNCED == field)
+    if (IS_UNSYNCED == field) {
       index = dir()->kernel_->unsynced_metahandles;
-    else
-      index = dir()->kernel_->unapplied_update_metahandles;
+    } else {
+      // Use kernel_->GetServerModelType() instead of
+      // GetServerModelType() as we may trigger some DCHECKs in the
+      // latter.
+      index =
+          &dir()->kernel_->unapplied_update_metahandles[
+              kernel_->GetServerModelType()];
+    }
 
     ScopedKernelLock lock(dir());
     if (value)
       CHECK(index->insert(kernel_->ref(META_HANDLE)).second);
     else
       CHECK_EQ(1U, index->erase(kernel_->ref(META_HANDLE)));
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
@@ skipping 376 matching lines @@
     if (entry->ref(NEXT_ID).IsRoot() ||
         entry->ref(NEXT_ID) != entry->ref(PREV_ID)) {
       return entry;
     }
   }
   // There were no children in the linked list.
   return NULL;
 }
 
 }  // namespace syncable