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

chrome/browser/sync/sessions/sync_session.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/sessions/sync_session.h"
 
 #include <algorithm>
 
+#include "base/logging.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 
 namespace browser_sync {
 namespace sessions {
 
+namespace {
+
+std::set<ModelSafeGroup> ComputeEnabledGroups(
+    const ModelSafeRoutingInfo& routing_info,
+    const std::vector<ModelSafeWorker*>& workers) {
+  std::set<ModelSafeGroup> enabled_groups;
+  // Project the list of enabled types (i.e., types in the routing
+  // info) to a list of enabled groups.
+  for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin();
+       it != routing_info.end(); ++it) {
+    enabled_groups.insert(it->second);
+  }
+  // GROUP_PASSIVE is always enabled, since that's the group that
+  // top-level folders map to.
+  enabled_groups.insert(GROUP_PASSIVE);
+  if (DCHECK_IS_ON()) {
+    // We sometimes create dummy SyncSession objects (see
+    // SyncScheduler::InitialSnapshot) so don't check in that case.
+    if (!routing_info.empty() || !workers.empty()) {
+      std::set<ModelSafeGroup> groups_with_workers;
+      for (std::vector<ModelSafeWorker*>::const_iterator it = workers.begin();
+           it != workers.end(); ++it) {
+        groups_with_workers.insert((*it)->GetModelSafeGroup());
+      }
+      // All enabled groups should have a corresponding worker.
+      DCHECK(std::includes(
+          groups_with_workers.begin(), groups_with_workers.end(),
+          enabled_groups.begin(), enabled_groups.end()));
+    }
+  }
+  return enabled_groups;
+}
+
+}  // namesepace
+
 SyncSession::SyncSession(SyncSessionContext* context, Delegate* delegate,
     const SyncSourceInfo& source,
     const ModelSafeRoutingInfo& routing_info,
     const std::vector<ModelSafeWorker*>& workers)
     : context_(context),
       source_(source),
       write_transaction_(NULL),
       delegate_(delegate),
       workers_(workers),
-      routing_info_(routing_info) {
+      routing_info_(routing_info),
+      enabled_groups_(ComputeEnabledGroups(routing_info_, workers_)) {
   status_controller_.reset(new StatusController(routing_info_));
   std::sort(workers_.begin(), workers_.end());
 }
 
 SyncSession::~SyncSession() {}
 
 void SyncSession::Coalesce(const SyncSession& session) {
   if (context_ != session.context() || delegate_ != session.delegate_) {
     NOTREACHED();
     return;
@@ skipping 11 matching lines @@
   workers_.swap(temp);
 
   // We have to update the model safe routing info to the union. In case the
   // same key is present in both pick the one from session.
   for (ModelSafeRoutingInfo::const_iterator it =
        session.routing_info_.begin();
        it != session.routing_info_.end();
        ++it) {
     routing_info_[it->first] = it->second;
   }
+
+  // Now update enabled groups.
+  enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
 }
 
-void SyncSession::RebaseRoutingInfoWithLatest(SyncSession* session) {
+void SyncSession::RebaseRoutingInfoWithLatest(const SyncSession& session) {
   ModelSafeRoutingInfo temp_routing_info;
 
   // Take the intersecion and also set the routing info(it->second) from the
   // passed in session.
   for (ModelSafeRoutingInfo::const_iterator it =
-       session->routing_info_.begin(); it != session->routing_info_.end();
+       session.routing_info_.begin(); it != session.routing_info_.end();
        ++it) {
     if (routing_info_.find(it->first) != routing_info_.end()) {
       temp_routing_info[it->first] = it->second;
     }
   }
 
   // Now swap it.
   routing_info_.swap(temp_routing_info);
 
   // Now update the payload map.
-  PurgeStalePayload(&source_.types, session->routing_info_);
+  PurgeStalePayload(&source_.types, session.routing_info_);
 
   // Now update the workers.
   std::vector<ModelSafeWorker*> temp;
   std::set_intersection(workers_.begin(), workers_.end(),
-                 session->workers_.begin(), session->workers_.end(),
+                 session.workers_.begin(), session.workers_.end(),
                  std::back_inserter(temp));
   workers_.swap(temp);
+
+  // Now update enabled groups.
+  enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
 }
 
 void SyncSession::ResetTransientState() {
   status_controller_.reset(new StatusController(routing_info_));
 }
 
 SyncSessionSnapshot SyncSession::TakeSnapshot() const {
   syncable::ScopedDirLookup dir(context_->directory_manager(),
                                 context_->account_name());
   if (!dir.good())
@@ skipping 41 matching lines @@
 }
 
 bool SyncSession::HasMoreToSync() const {
   const StatusController* status = status_controller_.get();
   return ((status->commit_ids().size() < status->unsynced_handles().size()) &&
       status->syncer_status().num_successful_commits > 0) ||
       status->conflict_sets_built() ||
       status->conflicts_resolved();
       // Or, we have conflicting updates, but we're making progress on
       // resolving them...
+}
+
+const std::set<ModelSafeGroup>& SyncSession::GetEnabledGroups() const {
+  return enabled_groups_;
+}
+
+std::set<ModelSafeGroup> SyncSession::GetEnabledGroupsWithConflicts() const {
+  const std::set<ModelSafeGroup>& enabled_groups = GetEnabledGroups();
+  std::set<ModelSafeGroup> enabled_groups_with_conflicts;
+  for (std::set<ModelSafeGroup>::const_iterator it =
+           enabled_groups.begin(); it != enabled_groups.end(); ++it) {
+    const sessions::ConflictProgress* conflict_progress =
+        status_controller_->GetUnrestrictedConflictProgress(*it);
+    if (conflict_progress &&
+        (conflict_progress->ConflictingItemsBegin() !=
+         conflict_progress->ConflictingItemsEnd())) {
+      enabled_groups_with_conflicts.insert(*it);
+    }
   }
+  return enabled_groups_with_conflicts;
+}
+
+std::set<ModelSafeGroup>
+    SyncSession::GetEnabledGroupsWithVerifiedUpdates() const {
+  const std::set<ModelSafeGroup>& enabled_groups = GetEnabledGroups();
+  std::set<ModelSafeGroup> enabled_groups_with_verified_updates;
+  for (std::set<ModelSafeGroup>::const_iterator it =
+           enabled_groups.begin(); it != enabled_groups.end(); ++it) {
+    const UpdateProgress* update_progress =
+        status_controller_->GetUnrestrictedUpdateProgress(*it);
+    if (update_progress &&
+        (update_progress->VerifiedUpdatesBegin() !=
+         update_progress->VerifiedUpdatesEnd())) {
+      enabled_groups_with_verified_updates.insert(*it);
+    }
+  }
+
+  return enabled_groups_with_verified_updates;
+}
+
 
 }  // namespace sessions
 }  // namespace browser_sync