[Sync] Add support for enabling session sync remotely.

chrome/browser/sync/glue/data_type_manager_impl.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/glue/data_type_manager_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
     return (*order_)[lhs->type()] < (*order_)[rhs->type()];
   }
 
  private:
   std::map<syncable::ModelType, int>* order_;
 };
 
 }  // namespace
 
 DataTypeManagerImpl::DataTypeManagerImpl(SyncBackendHost* backend,
-    const DataTypeController::TypeMap& controllers)
+    DataTypeController::TypeMap* controllers)
     : backend_(backend),
       controllers_(controllers),
       state_(DataTypeManager::STOPPED),
       needs_reconfigure_(false),
       last_configure_reason_(sync_api::CONFIGURE_REASON_UNKNOWN),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(backend_);
   // Ensure all data type controllers are stopped.
-  for (DataTypeController::TypeMap::const_iterator it = controllers_.begin();
-       it != controllers_.end(); ++it) {
+  for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
+       it != controllers_->end(); ++it) {
     DCHECK_EQ(DataTypeController::NOT_RUNNING, (*it).second->state());
   }
 
   // Build a ModelType -> order map for sorting.
   for (int i = 0; i < static_cast<int>(arraysize(kStartOrder)); i++)
     start_order_[kStartOrder[i]] = i;
 }
 
 DataTypeManagerImpl::~DataTypeManagerImpl() {}
 
 bool DataTypeManagerImpl::GetControllersNeedingStart(
     std::vector<DataTypeController*>* needs_start) {
   // Add any data type controllers into the needs_start_ list that are
   // currently NOT_RUNNING or STOPPING.
   bool found_any = false;
   for (TypeSet::const_iterator it = last_requested_types_.begin();
        it != last_requested_types_.end(); ++it) {
-    DataTypeController::TypeMap::const_iterator dtc = controllers_.find(*it);
-    if (dtc != controllers_.end() &&
+    DataTypeController::TypeMap::const_iterator dtc = controllers_->find(*it);
+    if (dtc != controllers_->end() &&
         (dtc->second->state() == DataTypeController::NOT_RUNNING ||
          dtc->second->state() == DataTypeController::STOPPING)) {
       found_any = true;
       if (needs_start)
         needs_start->push_back(dtc->second.get());
     }
   }
   return found_any;
 }
 
@@ skipping 49 matching lines @@
   needs_start_.clear();
   GetControllersNeedingStart(&needs_start_);
   // Sort these according to kStartOrder.
   std::sort(needs_start_.begin(),
             needs_start_.end(),
             SortComparator(&start_order_));
 
   // Add any data type controllers into that needs_stop_ list that are
   // currently MODEL_STARTING, ASSOCIATING, or RUNNING.
   needs_stop_.clear();
-  for (DataTypeController::TypeMap::const_iterator it = controllers_.begin();
-       it != controllers_.end(); ++it) {
+  for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
+       it != controllers_->end(); ++it) {
     DataTypeController* dtc = (*it).second;
     if (desired_types.count(dtc->type()) == 0 && (
             dtc->state() == DataTypeController::MODEL_STARTING ||
             dtc->state() == DataTypeController::ASSOCIATING ||
             dtc->state() == DataTypeController::RUNNING)) {
       needs_stop_.push_back(dtc);
       VLOG(1) << "Will stop " << dtc->name();
     }
   }
   // Sort these according to kStartOrder.
@@ skipping 29 matching lines @@
   needs_stop_.clear();
 
   // Tell the backend about the new set of data types we wish to sync.
   // The task will be invoked when updates are downloaded.
   state_ = DOWNLOAD_PENDING;
   // Hopefully http://crbug.com/79970 will make this less verbose.
   syncable::ModelTypeSet all_types;
   const syncable::ModelTypeSet& types_to_add = last_requested_types_;
   syncable::ModelTypeSet types_to_remove;
   for (DataTypeController::TypeMap::const_iterator it =
-           controllers_.begin(); it != controllers_.end(); ++it) {
+           controllers_->begin(); it != controllers_->end(); ++it) {
     all_types.insert(it->first);
   }
   // Check that types_to_add \subseteq all_types.
   DCHECK(std::includes(all_types.begin(), all_types.end(),
                        types_to_add.begin(), types_to_add.end()));
   // Set types_to_remove to all_types \setminus types_to_add.
   ignore_result(
       std::set_difference(
           all_types.begin(), all_types.end(),
           types_to_add.begin(), types_to_add.end(),
@@ skipping 171 matching lines @@
     return;
   }
 
   FinishStop();
 }
 
 void DataTypeManagerImpl::FinishStop() {
   DCHECK(state_== CONFIGURING || state_ == STOPPING || state_ == BLOCKED ||
          state_ == DOWNLOAD_PENDING);
   // Simply call the Stop() method on all running data types.
-  for (DataTypeController::TypeMap::const_iterator it = controllers_.begin();
-       it != controllers_.end(); ++it) {
+  for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
+       it != controllers_->end(); ++it) {
     DataTypeController* dtc = (*it).second;
     if (dtc->state() != DataTypeController::NOT_RUNNING &&
         dtc->state() != DataTypeController::STOPPING) {
       dtc->Stop();
       VLOG(1) << "Stopped " << dtc->name();
     }
   }
   state_ = STOPPED;
 }
 
@@ skipping 49 matching lines @@
     default:
       NOTREACHED();
       break;
   }
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
       Source<DataTypeManager>(this),
       Details<const ConfigureResult>(&result));
 }
 
-const DataTypeController::TypeMap& DataTypeManagerImpl::controllers() {
-  return controllers_;
-}
-
 DataTypeManager::State DataTypeManagerImpl::state() {
   return state_;
 }
 
 void DataTypeManagerImpl::SetBlockedAndNotify() {
   state_ = BLOCKED;
   AddToConfigureTime();
   VLOG(1) << "Accumulated spent configuring: "
           << configure_time_delta_.InSecondsF() << "s";
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_SYNC_CONFIGURE_BLOCKED,
       Source<DataTypeManager>(this),
       NotificationService::NoDetails());
 }
 
 void DataTypeManagerImpl::AddToConfigureTime() {
   DCHECK(!last_restart_time_.is_null());
   configure_time_delta_ += (base::Time::Now() - last_restart_time_);
 }
 
 }  // namespace browser_sync