Use OAuth2 token for sync

chrome/browser/sync/test_profile_sync_service.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/test_profile_sync_service.h"
 
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
@@ skipping 15 matching lines @@
 using syncer::sessions::SyncSourceInfo;
 using syncer::UserShare;
 using syncer::syncable::Directory;
 using syncer::DEVICE_INFO;
 using syncer::EXPERIMENTS;
 using syncer::NIGORI;
 using syncer::PRIORITY_PREFERENCES;
 
 namespace browser_sync {
 
+MessageLoopRunner::MessageLoopRunner()
+: running_(false) {
+}
+
+MessageLoopRunner::~MessageLoopRunner() {
+  DCHECK(!running_);
+}
+
+void MessageLoopRunner::Run() {
+  if (running_)
+    return;
+  running_ = true;
+  MessageLoop::current()->Run();
+  running_ = false;
+}
+
+void MessageLoopRunner::Quit() {
+  if (running_)
+    MessageLoop::current()->Quit();
+}
+
 SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
     Profile* profile,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::WeakPtr<InvalidatorStorage>& invalidator_storage,
     syncer::TestIdFactory& id_factory,
     base::Closure& callback,
     bool set_initial_sync_ended_on_init,
     bool synchronous_init,
     bool fail_initial_download,
-    syncer::StorageOption storage_option)
+    syncer::StorageOption storage_option,
+    MessageLoopRunner* message_loop_runner)
     : browser_sync::SyncBackendHost(
         profile->GetDebugName(), profile, sync_prefs, invalidator_storage),
       weak_ptr_factory_(this),
       id_factory_(id_factory),
       callback_(callback),
       fail_initial_download_(fail_initial_download),
       set_initial_sync_ended_on_init_(set_initial_sync_ended_on_init),
       synchronous_init_(synchronous_init),
-      storage_option_(storage_option) {}
+      storage_option_(storage_option),
+      message_loop_runner_(message_loop_runner) {}
 
 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
 
 namespace {
 
 scoped_ptr<syncer::HttpPostProviderFactory> MakeTestHttpBridgeFactory() {
   return scoped_ptr<syncer::HttpPostProviderFactory>(
       new browser_sync::TestHttpBridgeFactory());
 }
 
@@ skipping 16 matching lines @@
       test_options.internal_components_factory->GetSwitches();
   delete test_options.internal_components_factory;
 
   test_options.internal_components_factory =
       new TestInternalComponentsFactory(factory_switches, storage);
 
   SyncBackendHost::InitCore(test_options);
   if (synchronous_init_) {
     // The SyncBackend posts a task to the current loop when
     // initialization completes.
-    MessageLoop::current()->Run();
+    message_loop_runner_->Run();
   }
 }
 
 void SyncBackendHostForProfileSyncTest::UpdateCredentials(
       const syncer::SyncCredentials& credentials) {
   // If we had failed the initial download, complete initialization now.
   if (!initial_download_closure_.is_null()) {
     initial_download_closure_.Run();
     initial_download_closure_.Reset();
   }
@@ skipping 55 matching lines @@
     restored_types = syncer::ModelTypeSet::All();
   }
 
   initial_download_closure_ = base::Bind(
       &SyncBackendHostForProfileSyncTest::ContinueInitialization,
       weak_ptr_factory_.GetWeakPtr(),
       js_backend,
       debug_info_listener,
       restored_types);
   if (fail_initial_download_) {
+//    HandleInitializationCompletedOnFrontendLoop(false);

[tim (not reviewing), 2013/05/23 19:03:42]

Tidy up.

[pavely, 2013/05/30 07:42:12]

Done.

     frontend()->OnSyncConfigureRetry();
     if (synchronous_init_)
-      MessageLoop::current()->Quit();
+      message_loop_runner_->Quit();
   } else {
     initial_download_closure_.Run();
     initial_download_closure_.Reset();
   }
 }
 
 void SyncBackendHostForProfileSyncTest::EmitOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   frontend()->OnInvalidatorStateChange(state);
 }
@@ skipping 32 matching lines @@
     bool synchronous_backend_initialization)
         : ProfileSyncService(factory,
                              profile,
                              signin,
                              behavior),
     synchronous_backend_initialization_(
         synchronous_backend_initialization),
     synchronous_sync_configuration_(false),
     set_initial_sync_ended_on_init_(true),
     fail_initial_download_(false),
-    storage_option_(syncer::STORAGE_IN_MEMORY) {
+    storage_option_(syncer::STORAGE_IN_MEMORY),
+    message_loop_runner_() {

[tim (not reviewing), 2013/05/23 19:03:42]

Remove unnecessary initializer.

[pavely, 2013/05/30 07:42:12]

Done.

   SetSyncSetupCompleted();
 }
 
 TestProfileSyncService::~TestProfileSyncService() {
 }
 
 // static
 ProfileKeyedService* TestProfileSyncService::BuildAutoStartAsyncInit(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   SigninManagerBase* signin =
       SigninManagerFactory::GetForProfile(profile);
   ProfileSyncComponentsFactoryMock* factory =
       new ProfileSyncComponentsFactoryMock();
   return new TestProfileSyncService(
       factory, profile, signin, ProfileSyncService::AUTO_START, false);
 }
 
 ProfileSyncComponentsFactoryMock*
 TestProfileSyncService::components_factory_mock() {
   // We always create a mock factory, see Build* routines.
   return static_cast<ProfileSyncComponentsFactoryMock*>(factory());
 }
 
+void TestProfileSyncService::RequestAccessToken(
+    bool invalidate_previous_token,
+    bool invoke_callback) {
+  ProfileSyncService::RequestAccessToken(invalidate_previous_token,
+    invoke_callback);

[tim (not reviewing), 2013/05/23 19:03:42]

nit - indent is off (4 spaces).

[pavely, 2013/05/30 07:42:12]

Done.

+  if (synchronous_backend_initialization_ && invoke_callback) {
+    message_loop_runner_.Run();
+  }
+}
+
+void TestProfileSyncService::OnGetTokenFailure(
+    const OAuth2TokenService::Request* request,
+    const GoogleServiceAuthError& error) {
+  ProfileSyncService::OnGetTokenFailure(request, error);
+  if (synchronous_backend_initialization_) {
+    message_loop_runner_.Quit();
+  }
+}
+
+
 void TestProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     bool success) {
   ProfileSyncService::OnBackendInitialized(backend,
                                            debug_info_listener,
                                            success);
 
   // TODO(akalin): Figure out a better way to do this.
   if (synchronous_backend_initialization_) {
-    MessageLoop::current()->Quit();
+    message_loop_runner_.Quit();

[tim (not reviewing), 2013/05/23 19:03:42]

:/  This seems to make it worse than before, it's even more subtle.

   }
 }
 
 void TestProfileSyncService::OnConfigureDone(
     const browser_sync::DataTypeManager::ConfigureResult& result) {
   ProfileSyncService::OnConfigureDone(result);
   if (!synchronous_sync_configuration_)
     MessageLoop::current()->Quit();
 }
 
@@ skipping 18 matching lines @@
 void TestProfileSyncService::CreateBackend() {
   backend_.reset(new browser_sync::SyncBackendHostForProfileSyncTest(
       profile(),
       sync_prefs_.AsWeakPtr(),
       invalidator_storage_.AsWeakPtr(),
       id_factory_,
       callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
-      storage_option_));
+      storage_option_,
+      &message_loop_runner_));
 }
+
+scoped_ptr<OAuth2TokenService::Request> FakeOAuth2TokenService::StartRequest(
+    const OAuth2TokenService::ScopeSet& scopes,
+    OAuth2TokenService::Consumer* consumer) {
+  // Ensure token in question is cached and never expires. Request will succeed
+  // without network IO.
+  RegisterCacheEntry(GetRefreshToken(), scopes, "access_token",
+    base::Time::Max());

[tim (not reviewing), 2013/05/23 19:03:42]

indent is off.

[pavely, 2013/05/30 07:42:12]

Done.

+  return ProfileOAuth2TokenService::StartRequest(scopes, consumer);
+}
+
+ProfileKeyedService* FakeOAuth2TokenService::BuildTokenService(
+    content::BrowserContext* context) {
+  Profile* profile = static_cast<Profile*>(context);
+
+  FakeOAuth2TokenService* service =
+    new FakeOAuth2TokenService(profile->GetRequestContext());
+  service->Initialize(profile);
+  return service;
+}