[signin] Support for CrOS and OAuth2AccessTokenConsumer services.

chrome/browser/google_apis/auth_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/google_apis/auth_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/google_apis/auth_service_observer.h"
 #include "chrome/browser/google_apis/base_operations.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/about_signin_internals.h"
+#include "chrome/browser/signin/about_signin_internals_factory.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #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 "content/public/browser/notification_types.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
@@ skipping 19 matching lines @@
 }  // namespace
 
 // OAuth2 authorization token retrieval operation.
 class AuthOperation : public OperationRegistry::Operation,
                       public OAuth2AccessTokenConsumer {
  public:
   AuthOperation(OperationRegistry* registry,
                 net::URLRequestContextGetter* url_request_context_getter,
                 const AuthStatusCallback& callback,
                 const std::vector<std::string>& scopes,
-                const std::string& refresh_token);
+                const std::string& refresh_token,
+                Profile* profile);
   virtual ~AuthOperation();
   void Start();
 
   // Overridden from OAuth2AccessTokenConsumer:
   virtual void OnGetTokenSuccess(const std::string& access_token,
                                  const base::Time& expiration_time) OVERRIDE;
   virtual void OnGetTokenFailure(const GoogleServiceAuthError& error) OVERRIDE;
 
   // Overridden from OperationRegistry::Operation
   virtual void DoCancel() OVERRIDE;
 
  private:
   net::URLRequestContextGetter* url_request_context_getter_;
   std::string refresh_token_;
   AuthStatusCallback callback_;
   std::vector<std::string> scopes_;
   scoped_ptr<OAuth2AccessTokenFetcher> oauth2_access_token_fetcher_;
 
+  // TODO(vishwath): Once we move to OAuth2TokenService, this class no longer
+  // needs profile_.
+  // A weak pointer to the profile associated with this service, if any.
+  Profile* profile_;
+
   DISALLOW_COPY_AND_ASSIGN(AuthOperation);
 };
 
 AuthOperation::AuthOperation(
     OperationRegistry* registry,
     net::URLRequestContextGetter* url_request_context_getter,
     const AuthStatusCallback& callback,
     const std::vector<std::string>& scopes,
-    const std::string& refresh_token)
+    const std::string& refresh_token,
+    Profile* profile)
     : OperationRegistry::Operation(registry),
       url_request_context_getter_(url_request_context_getter),
       refresh_token_(refresh_token),
       callback_(callback),
-      scopes_(scopes) {
+      scopes_(scopes),
+      profile_(profile) {
   DCHECK(!callback_.is_null());
 }
 
 AuthOperation::~AuthOperation() {}
 
 void AuthOperation::Start() {
   DCHECK(!refresh_token_.empty());
   oauth2_access_token_fetcher_.reset(new OAuth2AccessTokenFetcher(
       this, url_request_context_getter_));
   NotifyStart();
@@ skipping 12 matching lines @@
 // Callback for OAuth2AccessTokenFetcher on success. |access_token| is the token
 // used to start fetching user data.
 void AuthOperation::OnGetTokenSuccess(const std::string& access_token,
                                       const base::Time& expiration_time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                             kSuccessRatioHistogramSuccess,
                             kSuccessRatioHistogramMaxValue);
 
+  // TODO(vishwath): This can be removed once this class is migrated to use
+  // OAuth2TokenService.
+  AboutSigninInternalsFactory::GetForProfile(profile_)->
+      NotifyTokenReceivedSuccess(signin_internals_util::kAuthOperationToken,
+                                 access_token,
+                                 true);
+
   callback_.Run(HTTP_SUCCESS, access_token);
   NotifyFinish(OPERATION_COMPLETED);
 }
 
 // Callback for OAuth2AccessTokenFetcher on failure.
 void AuthOperation::OnGetTokenFailure(const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LOG(WARNING) << "AuthOperation: token request using refresh token failed: "
                << error.ToString();
 
+    // TODO(vishwath): This needs to be converted to use OAuth2TokenService.
+  AboutSigninInternalsFactory::GetForProfile(profile_)->
+      NotifyTokenReceivedFailure(signin_internals_util::kAuthOperationToken,
+                                 error.ToString());
+
   // There are many ways to fail, but if the failure is due to connection,
   // it's likely that the device is off-line. We treat the error differently
   // so that the file manager works while off-line.
   if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED) {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramNoConnection,
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(GDATA_NO_CONNECTION, std::string());
   } else {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
@@ skipping 46 matching lines @@
     relay_proxy->PostTask(FROM_HERE,
          base::Bind(callback, HTTP_SUCCESS, access_token_));
   } else if (HasRefreshToken()) {
     // We have refresh token, let's get an access token.
     (new AuthOperation(registry,
                        url_request_context_getter_,
                        base::Bind(&AuthService::OnAuthCompleted,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback),
                        scopes_,
-                       refresh_token_))->Start();
+                       refresh_token_,
+                       profile_))->Start();
   } else {
     relay_proxy->PostTask(FROM_HERE,
         base::Bind(callback, GDATA_NOT_READY, std::string()));
   }
 }
 
 bool AuthService::HasAccessToken() const {
   return !access_token_.empty();
 }
 
@@ skipping 63 matching lines @@
 #endif  // OS_CHROMEOS
 
   // Authentication cannot be done with the incognito mode profile.
   if (profile->IsOffTheRecord())
     return false;
 
   return true;
 }
 
 }  // namespace google_apis