[Sync] Simplify GetSessionName interface

chrome/browser/sync/internal_api/sync_manager.cc

 // Copyright (c) 2012 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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 #include "chrome/browser/sync/notifier/sync_notifier.h"
 #include "chrome/browser/sync/notifier/sync_notifier_observer.h"
 #include "chrome/browser/sync/protocol/encryption.pb.h"
 #include "chrome/browser/sync/protocol/proto_value_conversions.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/directory_change_delegate.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/model_type_payload_map.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/cryptographer.h"
-#include "chrome/browser/sync/util/get_session_name_task.h"
+#include "chrome/browser/sync/util/get_session_name.h"
 #include "chrome/browser/sync/util/time.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
-#include "content/public/browser/browser_thread.h"
 #include "net/base/network_change_notifier.h"
 
 using std::string;
 
 using base::TimeDelta;
 using browser_sync::AllStatus;
 using browser_sync::Cryptographer;
 using browser_sync::Encryptor;
 using browser_sync::JsArgList;
 using browser_sync::JsBackend;
@@ skipping 112 matching lines @@
 
   virtual ~SyncInternal() {
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             const WeakHandle<JsEventHandler>& event_handler,
             const std::string& sync_server_and_path,
             int port,
             bool use_ssl,
+            const scoped_refptr<base::TaskRunner>& blocking_task_runner,
             HttpPostProviderFactory* post_factory,
             ModelSafeWorkerRegistrar* model_safe_worker_registrar,
             browser_sync::ExtensionsActivityMonitor*
                 extensions_activity_monitor,
             ChangeDelegate* change_delegate,
             const std::string& user_agent,
             const SyncCredentials& credentials,
             sync_notifier::SyncNotifier* sync_notifier,
             const std::string& restored_key_for_bootstrapping,
             bool setup_for_test_mode,
@@ skipping 326 matching lines @@
   // HandleCalculateChangesChangeEventFromSyncApi(), which can be
   // called from any thread.  Valid only between between calls to
   // Init() and Shutdown().
   //
   // TODO(akalin): Ideally, we wouldn't need to store this; instead,
   // we'd have another worker class which implements
   // HandleCalculateChangesChangeEventFromSyncApi() and we'd pass it a
   // WeakHandle when we construct it.
   WeakHandle<SyncInternal> weak_handle_this_;
 
+  // |blocking_task_runner| is a TaskRunner to be used for tasks that
+  // may block on disk I/O.
+  scoped_refptr<base::TaskRunner> blocking_task_runner_;
+
   // We give a handle to share_ to clients of the API for use when constructing
   // any transaction type.
   UserShare share_;
 
   // This can be called from any thread, but only between calls to
   // OpenDirectory() and ShutdownOnSyncThread().
   browser_sync::WeakHandle<SyncManager::ChangeObserver> change_observer_;
 
   ObserverList<SyncManager::Observer> observers_;
 
@@ skipping 168 matching lines @@
 
 SyncManager::Status::~Status() {
 }
 
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
+    const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     HttpPostProviderFactory* post_factory,
     ModelSafeWorkerRegistrar* registrar,
     browser_sync::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const std::string& user_agent,
     const SyncCredentials& credentials,
     sync_notifier::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     bool setup_for_test_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory);
   DVLOG(1) << "SyncManager starting Init...";
   string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      event_handler,
                      server_string,
                      sync_server_port,
                      use_ssl,
+                     blocking_task_runner,
                      post_factory,
                      registrar,
                      extensions_activity_monitor,
                      change_delegate,
                      user_agent,
                      credentials,
                      sync_notifier,
                      restored_key_for_bootstrapping,
                      setup_for_test_mode,
                      encryptor,
@@ skipping 96 matching lines @@
   data_->scheduler()->Start(
       browser_sync::SyncScheduler::CONFIGURATION_MODE, callback);
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int port,
     bool use_ssl,
+    const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     HttpPostProviderFactory* post_factory,
     ModelSafeWorkerRegistrar* model_safe_worker_registrar,
     browser_sync::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const std::string& user_agent,
     const SyncCredentials& credentials,
     sync_notifier::SyncNotifier* sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     bool setup_for_test_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   CHECK(!initialized_);
 
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Starting SyncInternal initialization.";
 
   weak_handle_this_ = MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
 
+  blocking_task_runner_ = blocking_task_runner;
+
   registrar_ = model_safe_worker_registrar;
   change_delegate_ = change_delegate;
   setup_for_test_mode_ = setup_for_test_mode;
 
   sync_notifier_.reset(sync_notifier);
 
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
   AddObserver(&debug_info_event_listener_);
@@ skipping 82 matching lines @@
     trans.GetWrappedTrans()->OnUnrecoverableError(FROM_HERE,
         "Simulating unrecoverable error for testing purpose.");
   }
 
   return signed_in;
 }
 
 void SyncManager::SyncInternal::UpdateCryptographerAndNigori(
     const base::Callback<void(bool)>& done_callback) {
   DCHECK(initialized_);
-  scoped_refptr<browser_sync::GetSessionNameTask> task =
-      new browser_sync::GetSessionNameTask(base::Bind(
+  browser_sync::GetSessionName(
+      blocking_task_runner_,
+      base::Bind(
           &SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback,
           weak_ptr_factory_.GetWeakPtr(),
           done_callback));
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&browser_sync::GetSessionNameTask::GetSessionNameAsync,
-                 task.get()));
 }
 
 void SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback(
     const base::Callback<void(bool)>& done_callback,
     const std::string& session_name) {
   if (!directory()->initial_sync_ended_for_type(syncable::NIGORI)) {
     done_callback.Run(false);  // Should only happen during first time sync.
     return;
   }
 
@@ skipping 1468 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api