Use OAuth2 token for sync

chrome/browser/sync/test_profile_sync_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
+#include "chrome/browser/signin/profile_oauth2_token_service.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/sync/glue/data_type_manager_impl.h"
 #include "chrome/browser/sync/invalidations/invalidator_storage.h"
 #include "chrome/browser/sync/profile_sync_components_factory_mock.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/test/base/profile_mock.h"
 #include "sync/internal_api/public/test/test_internal_components_factory.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 class Profile;
 class Task;
 class TestProfileSyncService;
 
 ACTION(ReturnNewDataTypeManager) {
   return new browser_sync::DataTypeManagerImpl(arg0, arg1, arg2, arg3, arg4);
 }
 
 namespace browser_sync {
 
+// MessageLoopRunner::Run() may be called multiple times recursively. Only first

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

Hmm.. this kind of thing (nested Run() calls -- see comment in message_loop.h @
Run() declaration) is strongly discouraged.  As is writing your own ML wrapper
vs using a RunLoop or existing tool.

I'm not sure yet why this is necessary, but it seems to take us farther away
from where we'd like to be with these tests, using a more standard approach.

+// call will execute MessageLoop::current()->Run().
+class MessageLoopRunner {
+ public:
+  MessageLoopRunner();
+  ~MessageLoopRunner();
+
+  void Run();
+  void Quit();
+
+ private:
+  bool running_;
+};
+
 class SyncBackendHostForProfileSyncTest : public SyncBackendHost {
  public:
   // |synchronous_init| causes initialization to block until the syncapi has
   //     completed setting itself up and called us back.
   // TOOD(akalin): Remove |synchronous_init| (http://crbug.com/140354).
   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);
   virtual ~SyncBackendHostForProfileSyncTest();
 
   MOCK_METHOD1(RequestNudge, void(const tracked_objects::Location&));
 
   virtual void UpdateCredentials(
       const syncer::SyncCredentials& credentials) OVERRIDE;
 
   virtual void RequestConfigureSyncer(
       syncer::ConfigureReason reason,
       syncer::ModelTypeSet types_to_config,
@@ skipping 37 matching lines @@
   // new credentials. Holds the results of
   // HandleSyncManagerInitializationOnFrontendLoop, and if
   // |fail_initial_download_| was true, finishes the initialization process
   // once we receive new credentials.
   base::Closure initial_download_closure_;
   bool fail_initial_download_;
 
   bool set_initial_sync_ended_on_init_;
   bool synchronous_init_;
   syncer::StorageOption storage_option_;
+  MessageLoopRunner* message_loop_runner_;
 };
 
 }  // namespace browser_sync
 
 class TestProfileSyncService : public ProfileSyncService {
  public:
   // TODO(tim): Remove |synchronous_backend_initialization|, and add ability to
   // inject TokenService alongside SigninManager.
   TestProfileSyncService(
       ProfileSyncComponentsFactory* factory,
       Profile* profile,
       SigninManagerBase* signin,
       ProfileSyncService::StartBehavior behavior,
       bool synchronous_backend_initialization);
 
   virtual ~TestProfileSyncService();
 
+  virtual void RequestAccessToken(
+      bool invalidate_previous_token,
+      bool invoke_callback) OVERRIDE;
+  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+      const GoogleServiceAuthError& error) OVERRIDE;
+
   virtual void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
       bool success) OVERRIDE;
 
   virtual void OnConfigureDone(
       const browser_sync::DataTypeManager::ConfigureResult& result) OVERRIDE;
 
   // We implement our own version to avoid some DCHECKs.
@@ skipping 38 matching lines @@
 
   // Set to true when a mock data type manager is being used and the configure
   // step is performed synchronously.
   bool synchronous_sync_configuration_;
 
   base::Closure callback_;
   bool set_initial_sync_ended_on_init_;
 
   bool fail_initial_download_;
   syncer::StorageOption storage_option_;
+  browser_sync::MessageLoopRunner message_loop_runner_;
+};
+
+
+class FakeOAuth2TokenService : public ProfileOAuth2TokenService {
+ public:
+  explicit FakeOAuth2TokenService(net::URLRequestContextGetter* getter)
+      : ProfileOAuth2TokenService(getter) {}
+
+  virtual scoped_ptr<OAuth2TokenService::Request> StartRequest(
+      const OAuth2TokenService::ScopeSet& scopes,
+      OAuth2TokenService::Consumer* consumer);
+
+  static ProfileKeyedService* BuildTokenService(
+      content::BrowserContext* context);
 };
 
 #endif  // CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_