Reverting 267374 on 36 branch.

google_apis/gaia/gaia_oauth_client.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 "google_apis/gaia/gaia_oauth_client.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
@@ skipping 38 matching lines @@
                     const std::string& refresh_token,
                     const std::vector<std::string>& scopes,
                     int max_retries,
                     GaiaOAuthClient::Delegate* delegate);
   void GetUserEmail(const std::string& oauth_access_token,
                     int max_retries,
                     Delegate* delegate);
   void GetUserId(const std::string& oauth_access_token,
                  int max_retries,
                  Delegate* delegate);
-  void GetUserInfo(const std::string& oauth_access_token,
-                   int max_retries,
-                   Delegate* delegate);
   void GetTokenInfo(const std::string& oauth_access_token,
                     int max_retries,
                     Delegate* delegate);
 
   // net::URLFetcherDelegate implementation.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
 
   enum RequestType {
     NO_PENDING_REQUEST,
     TOKENS_FROM_AUTH_CODE,
     REFRESH_TOKEN,
     TOKEN_INFO,
     USER_EMAIL,
     USER_ID,
-    USER_INFO,
   };
 
   virtual ~Core() {}
 
-  void PeopleGet(const std::string& oauth_access_token,
-                 int max_retries,
-                 Delegate* delegate);
+  void GetUserInfo(const std::string& oauth_access_token,
+                   int max_retries,
+                   Delegate* delegate);
   void MakeGaiaRequest(const GURL& url,
                        const std::string& post_body,
                        int max_retries,
                        GaiaOAuthClient::Delegate* delegate);
   void HandleResponse(const net::URLFetcher* source,
                       bool* should_retry_request);
 
   int num_retries_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   GaiaOAuthClient::Delegate* delegate_;
@@ skipping 45 matching lines @@
   MakeGaiaRequest(GURL(GaiaUrls::GetInstance()->oauth2_token_url()),
                   post_body, max_retries, delegate);
 }
 
 void GaiaOAuthClient::Core::GetUserEmail(const std::string& oauth_access_token,
                                          int max_retries,
                                          Delegate* delegate) {
   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
   DCHECK(!request_.get());
   request_type_ = USER_EMAIL;
-  PeopleGet(oauth_access_token, max_retries, delegate);
+  GetUserInfo(oauth_access_token, max_retries, delegate);
 }
 
 void GaiaOAuthClient::Core::GetUserId(const std::string& oauth_access_token,
                                       int max_retries,
                                       Delegate* delegate) {
   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
   DCHECK(!request_.get());
   request_type_ = USER_ID;
-  PeopleGet(oauth_access_token, max_retries, delegate);
+  GetUserInfo(oauth_access_token, max_retries, delegate);
 }
 
 void GaiaOAuthClient::Core::GetUserInfo(const std::string& oauth_access_token,
                                         int max_retries,
                                         Delegate* delegate) {
-  DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
-  DCHECK(!request_.get());
-  request_type_ = USER_INFO;
-  PeopleGet(oauth_access_token, max_retries, delegate);
-}
-
-void GaiaOAuthClient::Core::PeopleGet(const std::string& oauth_access_token,
-                                      int max_retries,
-                                      Delegate* delegate) {
   delegate_ = delegate;
   num_retries_ = 0;
   request_.reset(net::URLFetcher::Create(
-      kUrlFetcherId, GURL(GaiaUrls::GetInstance()->people_get_url()),
+      kUrlFetcherId, GURL(GaiaUrls::GetInstance()->oauth_user_info_url()),
       net::URLFetcher::GET, this));
   request_->SetRequestContext(request_context_getter_.get());
   request_->AddExtraRequestHeader("Authorization: OAuth " + oauth_access_token);
   request_->SetMaxRetriesOn5xx(max_retries);
   request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                          net::LOAD_DO_NOT_SAVE_COOKIES);
 
   // Fetchers are sometimes cancelled because a network change was detected,
   // especially at startup and after sign-in on ChromeOS. Retrying once should
   // be enough in those cases; let the fetcher retry up to 3 times just in case.
@@ skipping 98 matching lines @@
       *should_retry_request = true;
     }
     return;
   }
 
   RequestType type = request_type_;
   request_type_ = NO_PENDING_REQUEST;
 
   switch (type) {
     case USER_EMAIL: {
-      // Use first email of type "account" as the user's email.
-      const base::ListValue* emails_list;
-      bool email_found = false;
-      if (response_dict->GetList("emails", &emails_list)) {
-        for (size_t i = 0; i < emails_list->GetSize(); ++i) {
-          const base::DictionaryValue* email_dict;
-          if (emails_list->GetDictionary(i, &email_dict)) {
-            std::string email;
-            std::string type;
-            if (email_dict->GetString("type", &type) &&
-                type == "account" &&
-                email_dict->GetString("value", &email)) {
-              delegate_->OnGetUserEmailResponse(email);
-              email_found = true;
-              break;
-            }
-          }
-        }
-      }
-      if (!email_found)
-        delegate_->OnNetworkError(net::URLFetcher::RESPONSE_CODE_INVALID);
+      std::string email;
+      response_dict->GetString("email", &email);
+      delegate_->OnGetUserEmailResponse(email);
       break;
     }
 
     case USER_ID: {
       std::string id;
       response_dict->GetString("id", &id);
       delegate_->OnGetUserIdResponse(id);
       break;
     }
 
-    case USER_INFO: {
-      delegate_->OnGetUserInfoResponse(response_dict.Pass());
-      break;
-    }
-
     case TOKEN_INFO: {
       delegate_->OnGetTokenInfoResponse(response_dict.Pass());
       break;
     }
 
     case TOKENS_FROM_AUTH_CODE:
     case REFRESH_TOKEN: {
       std::string access_token;
       std::string refresh_token;
       int expires_in_seconds = 0;
@@ skipping 57 matching lines @@
                                   Delegate* delegate) {
   return core_->GetUserEmail(access_token, max_retries, delegate);
 }
 
 void GaiaOAuthClient::GetUserId(const std::string& access_token,
                                 int max_retries,
                                 Delegate* delegate) {
   return core_->GetUserId(access_token, max_retries, delegate);
 }
 
-void GaiaOAuthClient::GetUserInfo(const std::string& access_token,
-                                  int max_retries,
-                                  Delegate* delegate) {
-  return core_->GetUserInfo(access_token, max_retries, delegate);
-}
-
 void GaiaOAuthClient::GetTokenInfo(const std::string& access_token,
                                    int max_retries,
                                    Delegate* delegate) {
   return core_->GetTokenInfo(access_token, max_retries, delegate);
 }
 
 }  // namespace gaia