Get OAuth2TokenService working on Android.

chrome/browser/signin/oauth2_token_service.cc

 // Copyright 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/signin/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/sync/profile_sync_service_android.h"
+#endif
+
 namespace {
 
 // Maximum number of retries in fetching an OAuth2 access token.
 const int kMaxFetchRetryNum = 5;
 
 // Returns an exponential backoff in milliseconds including randomness less than
 // 1000 ms when retrying fetching an OAuth2 access token.
 int64 ComputeExponentialBackOffMilliseconds(int retry_num) {
   DCHECK(retry_num < kMaxFetchRetryNum);
   int64 exponential_backoff_in_seconds = 1 << retry_num;
@@ skipping 325 matching lines @@
     base::Time expiration_date) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (request)
     request->InformConsumer(error, access_token, expiration_date);
 }
 
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
+  return InvalidateTokenAndStartRequest(scopes, consumer, std::string());
+}
+
+scoped_ptr<OAuth2TokenService::Request>
+OAuth2TokenService::InvalidateTokenAndStartRequest(
+    const OAuth2TokenService::ScopeSet& scopes,
+    OAuth2TokenService::Consumer* consumer,
+    const std::string& invalid_token) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
 
+#if !defined(OS_ANDROID)
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service || !token_service->HasOAuthLoginToken()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &OAuth2TokenService::InformConsumer,
         request->AsWeakPtr(),
         GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP),
         std::string(),
         base::Time()));
     return request.PassAs<Request>();
   }
+#endif
+
+  if (!invalid_token.empty())
+    RemoveCacheEntry(scopes, invalid_token);
 
   const CacheEntry* cache_entry = GetCacheEntry(scopes);
   if (cache_entry && cache_entry->access_token.length()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &OAuth2TokenService::InformConsumer,
         request->AsWeakPtr(),
         GoogleServiceAuthError(GoogleServiceAuthError::NONE),
         cache_entry->access_token,
         cache_entry->expiration_date));
     return request.PassAs<Request>();
   }
 
+#if defined(OS_ANDROID)
+  DCHECK_EQ(scopes.size(), 1U);
+  std::vector<std::string> scope_list(scopes.begin(), scopes.end());
+  ProfileSyncServiceAndroid* sync_service =
+      ProfileSyncServiceAndroid::GetProfileSyncServiceAndroid();
+  sync_service->FetchOAuth2Token(
+      scope_list.front(),
+      invalid_token,
+      base::Bind(&OAuth2TokenService::InformConsumer,
+                 request->AsWeakPtr()));
+  return request.PassAs<Request>();
+#else
   std::string refresh_token = token_service->GetOAuth2LoginRefreshToken();
   if (!refresh_token.length()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &OAuth2TokenService::InformConsumer,
         request->AsWeakPtr(),
         GoogleServiceAuthError(
             GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS),
         std::string(),
         base::Time()));
     return request.PassAs<Request>();
   }
 
   // Makes sure there is a pending fetcher for |scopes| and |refresh_token|.
   // Adds |request| to the waiting request list of this fetcher so |request|
   // will be called back when this fetcher finishes fetching.
   FetchParameters fetch_parameters = std::make_pair(refresh_token, scopes);
   std::map<FetchParameters, Fetcher*>::iterator iter =
       pending_fetchers_.find(fetch_parameters);
   if (iter != pending_fetchers_.end()) {
     iter->second->AddWaitingRequest(request->AsWeakPtr());
     return request.PassAs<Request>();
   }
   pending_fetchers_[fetch_parameters] = Fetcher::CreateAndStart(
       profile_, getter_, refresh_token, scopes, request->AsWeakPtr());
   return request.PassAs<Request>();
+#endif  // defined(OS_ANDROID)
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Update the auth error state so auth errors are appropriately communicated
   // to the user.
   UpdateAuthError(fetcher->error());
 
   // Note |fetcher| is recorded in |pending_fetcher_| mapped to its refresh
@@ skipping 37 matching lines @@
   TokenCache::iterator token_iterator = token_cache_.find(scopes);
   if (token_iterator == token_cache_.end())
     return NULL;
   if (token_iterator->second.expiration_date <= base::Time::Now()) {
     token_cache_.erase(token_iterator);
     return NULL;
   }
   return &token_iterator->second;
 }
 
+bool OAuth2TokenService::RemoveCacheEntry(
+    const OAuth2TokenService::ScopeSet& scopes,
+    const std::string& token_to_remove) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  TokenCache::iterator token_iterator = token_cache_.find(scopes);
+  if (token_iterator == token_cache_.end() &&
+      token_iterator->second.access_token == token_to_remove) {
+    token_cache_.erase(token_iterator);
+    return true;
+  }
+  return false;
+}
+
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& refresh_token,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
+#if !defined(OS_ANDROID)
   // Only register OAuth2 access tokens for the refresh token held by
   // TokenService.
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service ||
       !token_service->HasOAuthLoginToken() ||
       token_service->GetOAuth2LoginRefreshToken().compare(refresh_token) != 0) {
     DLOG(INFO) <<
         "Received a token with a refresh token not maintained by TokenService.";
     return;
   }
+#endif
 
   CacheEntry& token = token_cache_[scopes];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
 void OAuth2TokenService::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TOKENS_CLEARED ||
@@ skipping 21 matching lines @@
   if (error.state() != last_auth_error_.state()) {
     last_auth_error_ = error;
     SigninManagerFactory::GetForProfile(profile_)->signin_global_error()->
         AuthStatusChanged();
   }
 }
 
 GoogleServiceAuthError OAuth2TokenService::GetAuthStatus() const {
   return last_auth_error_;
 }