Make sure GetAuthenticatedAccountId() returns a canonicalized id.

chrome/browser/signin/android_profile_oauth2_token_service.cc

 // Copyright 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/signin/android_profile_oauth2_token_service.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_android.h"
 #include "content/public/browser/browser_thread.h"
+#include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
 #include "jni/OAuth2TokenService_jni.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 
 namespace {
@@ skipping 138 matching lines @@
 
   if (!is_testing_profile_) {
     Java_OAuth2TokenService_validateAccounts(
         AttachCurrentThread(), java_ref_.obj(),
         base::android::GetApplicationContext(), JNI_TRUE);
   }
 }
 
 bool AndroidProfileOAuth2TokenService::RefreshTokenIsAvailable(
     const std::string& account_id) const {
+  ValidateAccountId(account_id);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_account_id =
       ConvertUTF8ToJavaString(env, account_id);
   jboolean refresh_token_is_available =
       Java_OAuth2TokenService_hasOAuth2RefreshToken(
           env, base::android::GetApplicationContext(),
           j_account_id.obj());
   return refresh_token_is_available == JNI_TRUE;
 }
 
@@ skipping 26 matching lines @@
                                                      j_accounts.obj(),
                                                      &accounts);
   return accounts;
 }
 
 OAuth2AccessTokenFetcher*
 AndroidProfileOAuth2TokenService::CreateAccessTokenFetcher(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     OAuth2AccessTokenConsumer* consumer) {
-  DCHECK(!account_id.empty());
+  ValidateAccountId(account_id);
   return new AndroidAccessTokenFetcher(consumer, account_id);
 }
 
 void AndroidProfileOAuth2TokenService::InvalidateOAuth2Token(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
+  ValidateAccountId(account_id);
   OAuth2TokenService::InvalidateOAuth2Token(account_id,
                                             client_id,
                                             scopes,
                                             access_token);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_access_token =
       ConvertUTF8ToJavaString(env, access_token);
   Java_OAuth2TokenService_invalidateOAuth2AuthToken(
       env, base::android::GetApplicationContext(),
       j_access_token.obj());
 }
 
 void AndroidProfileOAuth2TokenService::ValidateAccounts(
     JNIEnv* env,
     jobject obj,
     jstring j_current_acc,
     jboolean j_force_notifications) {
   VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts from java";
   std::string signed_in_account = ConvertJavaStringToUTF8(env, j_current_acc);
+  if (!signed_in_account.empty())
+    signed_in_account = gaia::CanonicalizeEmail(signed_in_account);
   ValidateAccounts(signed_in_account, j_force_notifications != JNI_FALSE);
 }
 
 void AndroidProfileOAuth2TokenService::ValidateAccounts(
     const std::string& signed_in_account,
     bool force_notifications) {
   std::vector<std::string> prev_ids = GetAccounts();
   std::vector<std::string> curr_ids = GetSystemAccounts();
   std::vector<std::string> refreshed_ids;
   std::vector<std::string> revoked_ids;
 
+  // Canonicalize system accounts.  |prev_ids| is already done.
+  for (size_t i = 0; i < curr_ids.size(); ++i)
+    curr_ids[i] = gaia::CanonicalizeEmail(curr_ids[i]);
+  for (size_t i = 0; i < prev_ids.size(); ++i)
+    ValidateAccountId(prev_ids[i]);
+
   VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
           << " sigined_in_account=" << signed_in_account
           << " prev_ids=" << prev_ids.size()
           << " curr_ids=" << curr_ids.size()
           << " force=" << (force_notifications ? "true" : "false");
 
   if (!ValidateAccounts(signed_in_account, prev_ids, curr_ids, refreshed_ids,
                         revoked_ids, force_notifications)) {
     curr_ids.clear();
   }
@@ skipping 183 matching lines @@
   GoogleServiceAuthError err(result ?
                              GoogleServiceAuthError::NONE :
                              GoogleServiceAuthError::CONNECTION_FAILED);
   heap_callback->Run(err, token, base::Time());
 }
 
 // static
 bool AndroidProfileOAuth2TokenService::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }