chrome/browser/chromeos/settings/device_oauth2_token_service.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/prefs/pref_registry_simple.h"
  15 #include "base/time/time.h"
  16 #include "chrome/common/pref_names.h"
  17 #include "google_apis/gaia/google_service_auth_error.h"
  18
  19 namespace chromeos {
  20
  21 struct DeviceOAuth2TokenService::PendingRequest {
  22   PendingRequest(const base::WeakPtr<RequestImpl>& request,
  23                  const std::string& client_id,
  24                  const std::string& client_secret,
  25                  const ScopeSet& scopes)
  26       : request(request),
  27         client_id(client_id),
  28         client_secret(client_secret),
  29         scopes(scopes) {}
  30
  31   const base::WeakPtr<RequestImpl> request;
  32   const std::string client_id;
  33   const std::string client_secret;
  34   const ScopeSet scopes;
  35 };
  36
  37 void DeviceOAuth2TokenService::OnValidationCompleted(
  38     GoogleServiceAuthError::State error) {
  39   if (error == GoogleServiceAuthError::NONE)
  40     FlushPendingRequests(true, GoogleServiceAuthError::NONE);
  41   else
  42     FlushPendingRequests(false, error);
  43 }
  44
  45 DeviceOAuth2TokenService::DeviceOAuth2TokenService(
  46     DeviceOAuth2TokenServiceDelegate* delegate)
  47     : OAuth2TokenService(delegate),
  48       delegate_(static_cast<DeviceOAuth2TokenServiceDelegate*>(delegate)) {
  49   delegate_->SetValidationStatusDelegate(this);
  50 }
  51
  52 DeviceOAuth2TokenService::~DeviceOAuth2TokenService() {
  53   delegate_->SetValidationStatusDelegate(nullptr);
  54   FlushPendingRequests(false, GoogleServiceAuthError::REQUEST_CANCELED);
  55 }
  56
  57 // static
  58 void DeviceOAuth2TokenService::RegisterPrefs(PrefRegistrySimple* registry) {
  59   registry->RegisterStringPref(prefs::kDeviceRobotAnyApiRefreshToken,
  60                                std::string());
  61 }
  62
  63 void DeviceOAuth2TokenService::SetAndSaveRefreshToken(
  64     const std::string& refresh_token,
  65     const StatusCallback& result_callback) {
  66   delegate_->SetAndSaveRefreshToken(refresh_token, result_callback);
  67 }
  68
  69 std::string DeviceOAuth2TokenService::GetRobotAccountId() const {
  70   return delegate_->GetRobotAccountId();
  71 }
  72
  73 void DeviceOAuth2TokenService::FetchOAuth2Token(
  74     RequestImpl* request,
  75     const std::string& account_id,
  76     net::URLRequestContextGetter* getter,
  77     const std::string& client_id,
  78     const std::string& client_secret,
  79     const ScopeSet& scopes) {
  80   switch (delegate_->state_) {
  81     case DeviceOAuth2TokenServiceDelegate::STATE_VALIDATION_PENDING:
  82       // If this is the first request for a token, start validation.
  83       delegate_->StartValidation();
  84       // fall through.
  85     case DeviceOAuth2TokenServiceDelegate::STATE_LOADING:
  86     case DeviceOAuth2TokenServiceDelegate::STATE_VALIDATION_STARTED:
  87       // Add a pending request that will be satisfied once validation completes.
  88       pending_requests_.push_back(new PendingRequest(
  89           request->AsWeakPtr(), client_id, client_secret, scopes));
  90       delegate_->RequestValidation();
  91       return;
  92     case DeviceOAuth2TokenServiceDelegate::STATE_NO_TOKEN:
  93       FailRequest(request, GoogleServiceAuthError::USER_NOT_SIGNED_UP);
  94       return;
  95     case DeviceOAuth2TokenServiceDelegate::STATE_TOKEN_INVALID:
  96       FailRequest(request, GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
  97       return;
  98     case DeviceOAuth2TokenServiceDelegate::STATE_TOKEN_VALID:
  99       // Pass through to OAuth2TokenService to satisfy the request.
 100       OAuth2TokenService::FetchOAuth2Token(
 101           request, account_id, getter, client_id, client_secret, scopes);
 102       return;
 103   }
 104
 105   NOTREACHED() << "Unexpected state " << delegate_->state_;
 106 }
 107
 108 void DeviceOAuth2TokenService::FlushPendingRequests(
 109     bool token_is_valid,
 110     GoogleServiceAuthError::State error) {
 111   std::vector<PendingRequest*> requests;
 112   requests.swap(pending_requests_);
 113   for (std::vector<PendingRequest*>::iterator request(requests.begin());
 114        request != requests.end();
 115        ++request) {
 116     scoped_ptr<PendingRequest> scoped_request(*request);
 117     if (!scoped_request->request)
 118       continue;
 119
 120     if (token_is_valid) {
 121       OAuth2TokenService::FetchOAuth2Token(
 122           scoped_request->request.get(),
 123           scoped_request->request->GetAccountId(),
 124           delegate_->GetRequestContext(), scoped_request->client_id,
 125           scoped_request->client_secret, scoped_request->scopes);
 126     } else {
 127       FailRequest(scoped_request->request.get(), error);
 128     }
 129   }
 130 }
 131
 132 void DeviceOAuth2TokenService::FailRequest(
 133     RequestImpl* request,
 134     GoogleServiceAuthError::State error) {
 135   GoogleServiceAuthError auth_error(error);
 136   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
 137       &RequestImpl::InformConsumer,
 138       request->AsWeakPtr(),
 139       auth_error,
 140       std::string(),
 141       base::Time()));
 142 }
 143
 144 }  // namespace chromeos