[Sync] Add support for enabling session sync remotely.

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/task.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/about_flags.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/autofill_model_associator.h"
 #include "chrome/browser/sync/glue/autofill_profile_model_associator.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/database_model_worker.h"
 #include "chrome/browser/sync/glue/history_model_worker.h"
 #include "chrome/browser/sync/glue/http_bridge.h"
 #include "chrome/browser/sync/glue/password_model_worker.h"
+#include "chrome/browser/sync/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/internal_api/base_transaction.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/js/js_arg_list.h"
 #include "chrome/browser/sync/js/js_event_details.h"
 #include "chrome/browser/sync/js/js_event_handler.h"
 #include "chrome/browser/sync/notifier/sync_notifier.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 // TODO(tim): Remove this! We should have a syncapi pass-thru instead.
 #include "chrome/browser/sync/syncable/directory_manager.h"  // Cryptographer.
@@ skipping 49 matching lines @@
       last_auth_error_(AuthError::None()) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(registrar_.workers.empty());
 }
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
+    ProfileSyncFactory* factory,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     const syncable::ModelTypeSet& initial_types,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder) {
   if (!sync_thread_.Start())
     return;
 
   frontend_ = frontend;
+  profile_sync_factory_ = factory;
   DCHECK(frontend);
 
   registrar_.workers[GROUP_DB] = new DatabaseModelWorker();
   registrar_.workers[GROUP_UI] = new UIModelWorker();
   registrar_.workers[GROUP_PASSIVE] = new ModelSafeWorker();
   HistoryService* history_service = profile_->GetHistoryService(
       Profile::IMPLICIT_ACCESS);
   if (history_service) {
     registrar_.workers[GROUP_HISTORY] = new HistoryModelWorker(history_service);
   } else {
@@ skipping 739 matching lines @@
 }
 
 void SyncBackendHost::Core::HandleSyncCycleCompletedOnFrontendLoop(
     SyncSessionSnapshot* snapshot) {
   if (!host_ || !host_->frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   host_->last_snapshot_.reset(snapshot);
 
-  const syncable::ModelTypeSet& to_migrate =
+  syncable::ModelTypeSet to_migrate =
       snapshot->syncer_status.types_needing_local_migration;
-  if (!to_migrate.empty())
+  if (sync_manager()->ShouldEnableSessions() && host_->initialized()) {
+    // Have to grab these before we register the sessions DTC.
+    syncable::ModelTypeSet enabled_types;
+    host_->frontend_->GetPreferredDataTypes(&enabled_types);
+    syncable::ModelTypeSet registered_types;
+    host_->frontend_->GetRegisteredDataTypes(&registered_types);
+
+    // Received notice to enable tab (sessions) sync. Check if sessions are
+    // registered, and if not register a new datatype controller.
+    if (registered_types.count(syncable::SESSIONS) == 0) {

[tim (not reviewing), 2011/08/22 15:42:08]

Something about this is circuitous.  First, 'Get'ing things from the
SyncFrontend observer is strange.  Especially since you add a pointer to the
factory here but still need to have a Register callback. Seems like
toe-stepping...  I also think we should avoid having so much sessions-specific
(or any type specific) code here.  All of this if (ShouldEnableSessions) logic
doesn't belong in SyncBackendHost.  Can we send a notification out instead?

[Nicolas Zea, 2011/08/22 22:50:15]

Done.

+      ProfileSyncService* service = profile_->GetProfileSyncService();
+      ProfileSyncFactory* factory = host_->profile_sync_factory_;
+      host_->frontend_->RegisterDataTypeController(
+          new SessionDataTypeController(factory, profile_, service));
+
+      // Check if the user has "Keep Everything Synced" enabled. If so, we want
+      // to turn on sessions if it's not already on. Otherwise we leave it off.
+      // Note: if sessions are already registered, we don't turn it on. This
+      // covers the case where we're already in the process of reconfiguring
+      // to turn sessions on.
+      if (profile_->GetPrefs()->GetBoolean(prefs::kKeepEverythingSynced) &&
+          enabled_types.count(syncable::SESSIONS) == 0){
+        // Enable the about:flags switch for sessions so we don't have to always
+        // perform this reconfiguration. Once we set this, sessions will remain
+        // registered, so we will no longer go down this code path.
+        about_flags::SetExperimentEnabled(g_browser_process->local_state(),
+                                          "sync-sessions",
+                                          true);
+        profile_->GetPrefs()->SetBoolean(prefs::kSyncSessions, true);
+        to_migrate.insert(syncable::SESSIONS);
+      }
+    }
+  }
+
+  // We can only start migration if we have finished initialization. Any
+  // datatypes that need migration currently will still require it after we
+  // finish initializing.
+  if (!to_migrate.empty() && host_->initialized())
     host_->frontend_->OnMigrationNeededForTypes(to_migrate);
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (host_->pending_download_state_.get()) {
     scoped_ptr<PendingConfigureDataTypesState> state(
         host_->pending_download_state_.release());
     DCHECK(
         std::includes(state->types_to_add.begin(), state->types_to_add.end(),
@@ skipping 183 matching lines @@
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace browser_sync