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

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>
@@ skipping 353 matching lines @@
   inline std::string& mutable_ref(StringField field) {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline sync_pb::EntitySpecifics& mutable_ref(ProtoField field) {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
   inline Id& mutable_ref(IdField field) {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
 
+  syncable::ModelType GetServerModelType() const;
+
   // Does a case in-sensitive search for a given string, which must be
   // lower case.
   bool ContainsString(const std::string& lowercase_query) const;
 
   // Dumps all kernel info into a DictionaryValue and returns it.
   // Transfers ownership of the DictionaryValue to the caller.
   base::DictionaryValue* ToValue() const;
 
  private:
   // Tracks whether this entry needs to be saved to the database.
@@ skipping 96 matching lines @@
   inline explicit Entry(BaseTransaction* trans)
       : basetrans_(trans),
         kernel_(NULL) { }
 
  protected:
   BaseTransaction* const basetrans_;
 
   EntryKernel* kernel_;
 
  private:
-  // Like GetServerModelType() but without the DCHECKs.
-  ModelType GetServerModelTypeHelper() const;
-
   DISALLOW_COPY_AND_ASSIGN(Entry);
 };
 
 // A mutable meta entry.  Changes get committed to the database when the
 // WriteTransaction is destroyed.
 class MutableEntry : public Entry {
   friend class WriteTransaction;
   friend class Directory;
   void Init(WriteTransaction* trans, const Id& parent_id,
       const std::string& name);
@@ skipping 459 matching lines @@
   // Returns the number of entities with the unsynced bit set.
   int64 unsynced_entity_count() const;
 
   // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
   // before any new entries have been created. The intention is that the
   // syncer should call it from its PerformSyncQueries member.
   typedef std::vector<int64> UnsyncedMetaHandles;
   void GetUnsyncedMetaHandles(BaseTransaction* trans,
                               UnsyncedMetaHandles* result);
 
-  // Get all the metahandles for unapplied updates
+  // Returns all server types with unapplied updates.  A subset of
+  // those types can then be passed into
+  // GetUnappliedUpdateMetaHandles() below.
+  syncable::ModelTypeBitSet GetServerTypesWithUnappliedUpdates(
+      BaseTransaction* trans) const;
+
+  // Get all the metahandles for unapplied updates for a given set of
+  // server types.
   typedef std::vector<int64> UnappliedUpdateMetaHandles;
   void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
+                                     syncable::ModelTypeBitSet server_types,
                                      UnappliedUpdateMetaHandles* result);
 
   // Checks tree metadata consistency.
   // If full_scan is false, the function will avoid pulling any entries from the
   // db and scan entries currently in ram.
   // If full_scan is true, all entries will be pulled from the database.
   // No return value, CHECKs will be triggered if we're given bad
   // information.
   void CheckTreeInvariants(syncable::BaseTransaction* trans,
                            bool full_scan);
@@ skipping 111 matching lines @@
     MetahandlesIndex* metahandles_index;
     // Entries indexed by id
     IdsIndex* ids_index;
     ParentIdChildIndex* parent_id_child_index;
     ClientTagIndex* client_tag_index;
     // So we don't have to create an EntryKernel every time we want to
     // look something up in an index.  Needle in haystack metaphor.
     EntryKernel needle;
 
     // 3 in-memory indices on bits used extremely frequently by the syncer.
-    MetahandleSet* const unapplied_update_metahandles;
+    // |unapplied_update_metahandles| is keyed by the server model type.
+    MetahandleSet unapplied_update_metahandles[MODEL_TYPE_COUNT];
     MetahandleSet* const unsynced_metahandles;
     // Contains metahandles that are most likely dirty (though not
     // necessarily).  Dirtyness is confirmed in TakeSnapshotForSaveChanges().
     MetahandleSet* const dirty_metahandles;
 
     // When a purge takes place, we remove items from all our indices and stash
     // them in here so that SaveChanges can persist their permanent deletion.
     MetahandleSet* const metahandles_to_purge;
 
     KernelShareInfoStatus info_status;
@@ skipping 156 matching lines @@
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_