If user profile doesn't contain language setting, default to his Google account settings.

chrome/browser/profiles/profile_downloader.cc

 // Copyright (c) 2013 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"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_downloader_delegate.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "skia/ext/image_operations.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Template for optional authorization header when using an OAuth access token.
 const char kAuthorizationHeader[] =
     "Authorization: Bearer %s";
 
 // URL requesting user info.
 const char kUserEntryURL[] =
     "https://www.googleapis.com/oauth2/v1/userinfo?alt=json";
 
 // OAuth scope for the user info API.
 const char kAPIScope[] = "https://www.googleapis.com/auth/userinfo.profile";
 
 // Path in JSON dictionary to user's photo thumbnail URL.
 const char kPhotoThumbnailURLPath[] = "picture";
 
+// Path in JSON dictionary to user's preferred locale.
+const char kLocalePath[] = "locale";
+
 const char kNickNamePath[] = "name";
 
 // Path format for specifying thumbnail's size.
 const char kThumbnailSizeFormat[] = "s%d-c";
 // Default thumbnail size.
 const int kDefaultThumbnailSize = 64;
 
 // Separator of URL path components.
 const char kURLPathSeparator = '/';
 
@@ skipping 55 matching lines @@
     return new_url->is_valid();
   }
 
   // We can't set the image size, just use the default size.
   *new_url = old_url;
   return true;
 }
 
 }  // namespace
 
-// static
-bool ProfileDownloader::GetProfileNameAndImageURL(const std::string& data,
-                                                  string16* nick_name,
-                                                  std::string* url,
-                                                  int image_size) {
+// Parses the entry response and gets the name and profile image URL.
+// |data| should be the JSON formatted data return by the response.
+// Returns false to indicate a parsing error.
+bool ProfileDownloader::ParseProfileJSON(const std::string& data,
+                                         string16* nick_name,
+                                         std::string* url,
+                                         int image_size,
+                                         std::string* profile_locale) {
   DCHECK(nick_name);
   DCHECK(url);
   *nick_name = string16();
   *url = std::string();
+  *profile_locale = std::string();
 
   int error_code = -1;
   std::string error_message;
   scoped_ptr<base::Value> root_value(base::JSONReader::ReadAndReturnError(
       data, base::JSON_PARSE_RFC, &error_code, &error_message));
   if (!root_value) {
     LOG(ERROR) << "Error while parsing user entry response: "
                << error_message;
     return false;
   }
   if (!root_value->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "JSON root is not a dictionary: "
                << root_value->GetType();
     return false;
   }
   base::DictionaryValue* root_dictionary =
       static_cast<base::DictionaryValue*>(root_value.get());
 
+  root_dictionary->GetString(kLocalePath, profile_locale);
   root_dictionary->GetString(kNickNamePath, nick_name);
 
   std::string url_string;
   if (root_dictionary->GetString(kPhotoThumbnailURLPath, &url_string)) {
     GURL new_url;
     if (!GetImageURLWithSize(GURL(url_string), image_size, &new_url)) {
       LOG(ERROR) << "GetImageURLWithSize failed for url: " << url_string;
       return false;
     }
     *url = new_url.spec();
@@ skipping 53 matching lines @@
     StartFetchingOAuth2AccessToken();
   } else {
     service->AddObserver(this);
   }
 }
 
 string16 ProfileDownloader::GetProfileFullName() const {
   return profile_full_name_;
 }
 
+std::string ProfileDownloader::GetProfileLocale() const {
+  return profile_locale_;
+}
+
 SkBitmap ProfileDownloader::GetProfilePicture() const {
   return profile_picture_;
 }
 
 ProfileDownloader::PictureStatus ProfileDownloader::GetProfilePictureStatus()
     const {
   return picture_status_;
 }
 
 std::string ProfileDownloader::GetProfilePictureURL() const {
@@ skipping 39 matching lines @@
     DVLOG(1) << "  Response code: " << source->GetResponseCode();
     DVLOG(1) << "  Url: " << source->GetURL().spec();
     delegate_->OnProfileDownloadFailure(this, network_error ?
         ProfileDownloaderDelegate::NETWORK_ERROR :
         ProfileDownloaderDelegate::SERVICE_ERROR);
     return;
   }
 
   if (source == user_entry_fetcher_.get()) {
     std::string image_url;
-    if (!GetProfileNameAndImageURL(data, &profile_full_name_, &image_url,
-        delegate_->GetDesiredImageSideLength())) {
+    if (!ParseProfileJSON(data,
+                          &profile_full_name_,
+                          &image_url,
+                          delegate_->GetDesiredImageSideLength(),
+                          &profile_locale_)) {
       delegate_->OnProfileDownloadFailure(
           this, ProfileDownloaderDelegate::SERVICE_ERROR);
       return;
     }
     if (!delegate_->NeedsProfilePicture()) {
       VLOG(1) << "Skipping profile picture download";
       delegate_->OnProfileDownloadSuccess(this);
       return;
     }
     if (IsDefaultProfileImageURL(image_url)) {
@@ skipping 73 matching lines @@
 // Callback for OAuth2TokenService::Request on failure.
 void ProfileDownloader::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(request, oauth2_access_token_request_.get());
   oauth2_access_token_request_.reset();
   LOG(WARNING) << "ProfileDownloader: token request using refresh token failed";
   delegate_->OnProfileDownloadFailure(
       this, ProfileDownloaderDelegate::TOKEN_ERROR);
 }