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 67 matching lines @@
   // first place, but SyncBackendHost will have created one by now so we must
   // free it. Grab the switches to pass on first.
   InternalComponentsFactory::Switches factory_switches =
       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_) {
+  if (synchronous_init_ && !base::MessageLoop::current()->is_running()) {
     // The SyncBackend posts a task to the current loop when
     // initialization completes.
     base::MessageLoop::current()->Run();
   }
 }
 
 void SyncBackendHostForProfileSyncTest::UpdateCredentials(
       const syncer::SyncCredentials& credentials) {
   // If we had failed the initial download, complete initialization now.
   if (!initial_download_closure_.is_null()) {
@@ skipping 141 matching lines @@
   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() {
+  ProfileSyncService::RequestAccessToken();
+  if (synchronous_backend_initialization_) {
+    base::MessageLoop::current()->Run();
+  }
+}
+
+void TestProfileSyncService::OnGetTokenFailure(
+    const OAuth2TokenService::Request* request,
+    const GoogleServiceAuthError& error) {
+  ProfileSyncService::OnGetTokenFailure(request, error);
+  if (synchronous_backend_initialization_) {
+    base::MessageLoop::current()->Quit();

[Andrew T Wilson (Slow), 2013/06/04 14:37:32]

Should we also add an OnGetTokenSuccess() loop that quits the loop? I'm fuzzy on
why we need one here but not in that case.

Also, I'm OK with this, but I thought the preferred way to do this is to use a
RunLoop and to invoke RunLoop::Quit() instead of talking to the messageloop
directly (this is to more gracefully handle nested runloops without exiting the
nested loop prematurely).

[pavely, 2013/06/04 20:11:13]

In success case TryStart will be called and will result in backend
initialization and that other MessageLoop::Run call in
SyncBackendHostForProfileSyncTest::InitCore.

I actually spent quite some time trying to make it work with RunLoop, running in
different kinds of issues. I think the right approach is different.
TestProfileSyncService shouldn't invoke MessageLoop at all. Instead test should
create RunLoop on the stack, get QuitClosure from it and pass it into
TestProfileSyncService. Then TestProfileSyncService should just invoke that
Closure when it feels it is done and it's time for test to do something.
I want to implement this change but in separate CL.

+  }
+}
+
+
 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.
@@ skipping 32 matching lines @@
       profile(),
       sync_prefs_.AsWeakPtr(),
       invalidator_storage_.AsWeakPtr(),
       id_factory_,
       callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
       storage_option_));
 }
+
+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());
+  return ProfileOAuth2TokenService::StartRequest(scopes, consumer);
+}
+
+BrowserContextKeyedService* FakeOAuth2TokenService::BuildTokenService(
+    content::BrowserContext* context) {
+  Profile* profile = static_cast<Profile*>(context);
+
+  FakeOAuth2TokenService* service =
+      new FakeOAuth2TokenService(context->GetRequestContext());
+  service->Initialize(profile);
+  return service;
+}