Add SyncAuthProvider interface and implementation

chrome/browser/sync/profile_sync_auth_provider.cc

+// Copyright 2014 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/profile_sync_auth_provider.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "components/signin/core/browser/profile_oauth2_token_service.h"
+#include "google_apis/gaia/gaia_constants.h"
+
+// This is thin proxy class for forwarding calls between sync and UI threads.
+// The main purpose is to hide the fact that ProfileSyncAuthProvider and
+// SyncThreadProxy have independent lifetimes. If ProfileSyncAuthProvider is
+// destroyed first calls to RequestAccessToken will never complete. This is fine
+// since sync thread is not blocked and is in the process of shutdown anyway.
+class ProfileSyncAuthProvider::SyncThreadProxy
+    : public syncer::SyncAuthProvider,
+      public base::NonThreadSafe {
+ public:
+  SyncThreadProxy(
+      base::WeakPtr<ProfileSyncAuthProvider> provider_impl,
+      scoped_refptr<base::SingleThreadTaskRunner> provider_task_runner);
+
+  // syncer::SyncAuthProvider implementation.
+  virtual void RequestAccessToken(
+      const RequestTokenCallback& callback) OVERRIDE;
+  virtual void InvalidateAccessToken(const std::string& token) OVERRIDE;
+
+ private:
+  base::WeakPtr<ProfileSyncAuthProvider> provider_impl_;
+  scoped_refptr<base::SingleThreadTaskRunner> provider_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyncThreadProxy);
+};
+
+ProfileSyncAuthProvider::SyncThreadProxy::SyncThreadProxy(
+    base::WeakPtr<ProfileSyncAuthProvider> provider_impl,
+    scoped_refptr<base::SingleThreadTaskRunner> provider_task_runner)
+    : provider_impl_(provider_impl),
+      provider_task_runner_(provider_task_runner) {
+  // SyncThreadProxy is created on UI thread but used on sync thread.
+  // Detach NonThreadSafe from UI thread so that it can reattach to sync thread
+  // on first invocation.
+  DetachFromThread();
+}
+
+void ProfileSyncAuthProvider::SyncThreadProxy::RequestAccessToken(
+    const RequestTokenCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  provider_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&ProfileSyncAuthProvider::RequestAccessToken,
+                 provider_impl_,
+                 callback,
+                 base::MessageLoopProxy::current()));
+}
+
+void ProfileSyncAuthProvider::SyncThreadProxy::InvalidateAccessToken(
+    const std::string& token) {
+  DCHECK(CalledOnValidThread());
+  provider_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&ProfileSyncAuthProvider::InvalidateAccessToken,
+                 provider_impl_,
+                 token));
+}
+
+ProfileSyncAuthProvider::ProfileSyncAuthProvider(
+    ProfileOAuth2TokenService* token_service,
+    const std::string& account_id,
+    const std::string& scope)
+    : OAuth2TokenService::Consumer("sync_auth_provider"),
+      token_service_(token_service),
+      account_id_(account_id),
+      weak_factory_(this) {
+  oauth2_scope_.insert(scope);
+}
+
+ProfileSyncAuthProvider::~ProfileSyncAuthProvider() {
+  DCHECK(CalledOnValidThread());
+}
+
+void ProfileSyncAuthProvider::RequestAccessToken(
+    const syncer::SyncAuthProvider::RequestTokenCallback& callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(CalledOnValidThread());
+  if (access_token_request_ != NULL) {
+    // If there is already pending request report it as cancelled.
+    GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
+    RespondToTokenRequest(error, std::string());
+  }
+  request_token_callback_ = callback;
+  callback_task_runner_ = task_runner;
+  access_token_request_ =
+      token_service_->StartRequest(account_id_, oauth2_scope_, this);
+}
+
+void ProfileSyncAuthProvider::OnGetTokenSuccess(
+    const OAuth2TokenService::Request* request,
+    const std::string& access_token,
+    const base::Time& expiration_time) {
+  DCHECK_EQ(access_token_request_, request);
+  RespondToTokenRequest(GoogleServiceAuthError::AuthErrorNone(), access_token);
+}
+
+void ProfileSyncAuthProvider::OnGetTokenFailure(
+    const OAuth2TokenService::Request* request,
+    const GoogleServiceAuthError& error) {
+  DCHECK_EQ(access_token_request_, request);
+  RespondToTokenRequest(error, std::string());
+}
+
+void ProfileSyncAuthProvider::RespondToTokenRequest(
+    const GoogleServiceAuthError& error,
+    const std::string& token) {
+  DCHECK(CalledOnValidThread());
+  callback_task_runner_->PostTask(
+      FROM_HERE, base::Bind(request_token_callback_, error, token));
+  access_token_request_.reset();
+  request_token_callback_.Reset();
+  callback_task_runner_ = NULL;
+}
+
+void ProfileSyncAuthProvider::InvalidateAccessToken(const std::string& token) {
+  DCHECK(CalledOnValidThread());
+  token_service_->InvalidateToken(account_id_, oauth2_scope_, token);
+}
+
+scoped_ptr<syncer::SyncAuthProvider>
+ProfileSyncAuthProvider::CreateProviderForSyncThread() {
+  DCHECK(CalledOnValidThread());
+  scoped_ptr<syncer::SyncAuthProvider> auth_provider(new SyncThreadProxy(
+      weak_factory_.GetWeakPtr(), base::MessageLoopProxy::current()));
+  return auth_provider.Pass();
+}