ChromeOS: Use OAuth2 refresh token to download GAIA info

chrome/browser/profiles/profile_downloader.cc

 // Copyright (c) 2011 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/profiles/profile_downloader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "skia/ext/image_operations.h"
 
 using content::BrowserThread;
 
 namespace {
 
-// Template for optional authorization header when using client login access
-// token.
-const char kClientAccessAuthorizationHeader[] =
-    "Authorization: GoogleLogin auth=%s";
-
 // Template for optional authorization header when using an OAuth access token.
-const char kOAuthAccessAuthorizationHeader[] =
-    "Authorization: Bearer %s";
+const char kAuthorizationHeader[] = "Authorization: Bearer %s";
 
 // URL requesting Picasa API for user info.
 const char kUserEntryURL[] =
     "http://picasaweb.google.com/data/entry/api/user/default?alt=json";
 
 // OAuth scope for the Picasa API.
 const char kPicasaScope[] = "http://picasaweb.google.com/data/";
 
 // Path in JSON dictionary to user's photo thumbnail URL.
 const char kPhotoThumbnailURLPath[] = "entry.gphoto$thumbnail.$t";
@@ skipping 138 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TokenService* service = delegate_->GetBrowserProfile()->GetTokenService();
   if (!service) {
     // This can happen in some test paths.
     LOG(WARNING) << "User has no token service";
     delegate_->OnDownloadComplete(this, false);
     return;
   }
 
-  if (delegate_->GetShouldUseOAuthRefreshToken() &&
-      service->HasOAuthLoginToken()) {
+  if (service->HasOAuthLoginToken()) {
     std::vector<std::string> scopes;
     scopes.push_back(kPicasaScope);
     oauth2_access_token_fetcher_.reset(new OAuth2AccessTokenFetcher(
         this, delegate_->GetBrowserProfile()->GetRequestContext()));
     oauth2_access_token_fetcher_->Start(
         GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
         GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
         service->GetOAuth2LoginRefreshToken(),
         scopes);
-  } else if (!delegate_->GetShouldUseOAuthRefreshToken() &&
-      service->HasTokenForService(GaiaConstants::kPicasaService)) {
-    auth_token_ =
-        service->GetTokenForService(GaiaConstants::kPicasaService);
-    StartFetchingImage();
   } else {

[Munjal (Google), 2011/11/30 19:29:29]

In else you don't want to just wait for token available or failed notification.
That will put you into an infinite wait for users who are already logged in
pre-M17 (at least in Chrome, not sure about ChromeOS).

If the oauth login token is not available there are two cases:
1. The user was already logged in.
2. The user has not logged in yet.

If it is okay for this code to wait for a long time until the user logs in
again, then I guess it is ok.

[sail, 2011/12/01 20:01:49]

Ahh, you're right. I'm not sure if this is a problem for ChromeOS but it's
definitely a problem for the browser code.

The old code actually had the same problem. It would wait forever for M16 users
who never got the picasa token. If you don't mind I'd like to fix this in a
separate change.

[Munjal (Google), 2011/12/01 23:25:58]

Sure, you can fix it in a separate CL.

     registrar_.Add(this,
                    chrome::NOTIFICATION_TOKEN_AVAILABLE,
                    content::Source<TokenService>(service));
     registrar_.Add(this,
                    chrome::NOTIFICATION_TOKEN_REQUEST_FAILED,
                    content::Source<TokenService>(service));
   }
 }
 
 string16 ProfileDownloader::GetProfileFullName() const {
   return profile_full_name_;
 }
 
 SkBitmap ProfileDownloader::GetProfilePicture() const {
   return profile_picture_;
 }
 
 void ProfileDownloader::StartFetchingImage() {
   VLOG(1) << "Fetching user entry with token: " << auth_token_;
   user_entry_fetcher_.reset(content::URLFetcher::Create(
       GURL(kUserEntryURL), content::URLFetcher::GET, this));
   user_entry_fetcher_->SetRequestContext(
       delegate_->GetBrowserProfile()->GetRequestContext());
   if (!auth_token_.empty()) {
     user_entry_fetcher_->SetExtraRequestHeaders(
-        base::StringPrintf(GetAuthorizationHeader(), auth_token_.c_str()));
+        base::StringPrintf(kAuthorizationHeader, auth_token_.c_str()));
   }
   user_entry_fetcher_->Start();
 }
 
-const char* ProfileDownloader::GetAuthorizationHeader() const {
-  return delegate_->GetShouldUseOAuthRefreshToken() ?
-      kOAuthAccessAuthorizationHeader : kClientAccessAuthorizationHeader;
-}
-
 ProfileDownloader::~ProfileDownloader() {}
 
 void ProfileDownloader::OnURLFetchComplete(const content::URLFetcher* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string data;
   source->GetResponseAsString(&data);
   if (source->GetResponseCode() != 200) {
     LOG(ERROR) << "Response code is " << source->GetResponseCode();
     LOG(ERROR) << "Url is " << source->GetURL().spec();
     LOG(ERROR) << "Data is " << data;
@@ skipping 11 matching lines @@
       delegate_->OnDownloadComplete(this, true);
       return;
     }
     VLOG(1) << "Fetching profile image from " << image_url;
     profile_image_fetcher_.reset(content::URLFetcher::Create(
         GURL(image_url), content::URLFetcher::GET, this));
     profile_image_fetcher_->SetRequestContext(
         delegate_->GetBrowserProfile()->GetRequestContext());
     if (!auth_token_.empty()) {
       profile_image_fetcher_->SetExtraRequestHeaders(
-          base::StringPrintf(GetAuthorizationHeader(), auth_token_.c_str()));
+          base::StringPrintf(kAuthorizationHeader, auth_token_.c_str()));
     }
     profile_image_fetcher_->Start();
   } else if (source == profile_image_fetcher_.get()) {
     VLOG(1) << "Decoding the image...";
     scoped_refptr<ImageDecoder> image_decoder = new ImageDecoder(
         this, data);
     image_decoder->Start();
   }
 }
 
@@ skipping 16 matching lines @@
 
 void ProfileDownloader::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TOKEN_AVAILABLE ||
          type == chrome::NOTIFICATION_TOKEN_REQUEST_FAILED);
 
   TokenService::TokenAvailableDetails* token_details =
       content::Details<TokenService::TokenAvailableDetails>(details).ptr();
-  std::string service = delegate_->GetShouldUseOAuthRefreshToken() ?
-      GaiaConstants::kGaiaOAuth2LoginRefreshToken :
-      GaiaConstants::kPicasaService;
 
   if (type == chrome::NOTIFICATION_TOKEN_AVAILABLE) {
-    if (token_details->service() == service) {
+    if (token_details->service() ==
+        GaiaConstants::kGaiaOAuth2LoginRefreshToken) {
       registrar_.RemoveAll();
       auth_token_ = token_details->token();
       StartFetchingImage();
     }
   } else {
-    if (token_details->service() == service) {
+    if (token_details->service() ==
+        GaiaConstants::kGaiaOAuth2LoginRefreshToken) {
       LOG(WARNING) << "ProfileDownloader: token request failed";
       delegate_->OnDownloadComplete(this, false);
     }
   }
 }
 
 void ProfileDownloader::OnGetTokenSuccess(const std::string& access_token) {
   auth_token_ = access_token;
   StartFetchingImage();
 }
 
 void ProfileDownloader::OnGetTokenFailure(const GoogleServiceAuthError& error) {
   LOG(WARNING) << "ProfileDownloader: token request using refresh token failed";
   delegate_->OnDownloadComplete(this, false);
 }