Rename ProfileKeyedAPI to BrowserContextKeyedAPI and GetProfile to Get.

chrome/browser/extensions/api/identity/identity_api.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/extensions/api/identity/identity_api.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 144 matching lines @@
 void IdentityGetAuthTokenFunction::CompleteFunctionWithError(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
   Release();  // Balanced in RunImpl.
 }
 
 void IdentityGetAuthTokenFunction::StartSigninFlow() {
   // All cached tokens are invalid because the user is not signed in.
   IdentityAPI* id_api =
-      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
-          GetProfile());
+      extensions::IdentityAPI::GetFactoryInstance()->Get(GetProfile());
   id_api->EraseAllCachedTokens();
   // Display a login prompt. If the subsequent mint fails, don't display the
   // login prompt again.
   should_prompt_for_signin_ = false;
   ShowLoginPopup();
 }
 
 void IdentityGetAuthTokenFunction::StartMintTokenFlow(
     IdentityMintRequestQueue::MintType type) {
   mint_token_flow_type_ = type;
 
   // Flows are serialized to prevent excessive traffic to GAIA, and
   // to consolidate UI pop-ups.
   IdentityAPI* id_api =
-      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
-          GetProfile());
+      extensions::IdentityAPI::GetFactoryInstance()->Get(GetProfile());
 
   if (!should_prompt_for_scopes_) {
     // Caller requested no interaction.
 
     if (type == IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE) {
       // GAIA told us to do a consent UI.
       CompleteFunctionWithError(identity_constants::kNoGrant);
       return;
     }
     if (!id_api->mint_queue()->empty(
             IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE, *token_key_)) {
       // Another call is going through a consent UI.
       CompleteFunctionWithError(identity_constants::kNoGrant);
       return;
     }
   }
   id_api->mint_queue()->RequestStart(type, *token_key_, this);
 }
 
 void IdentityGetAuthTokenFunction::CompleteMintTokenFlow() {
   IdentityMintRequestQueue::MintType type = mint_token_flow_type_;
 
   const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(GetExtension());
   std::set<std::string> scopes(oauth2_info.scopes.begin(),
                                oauth2_info.scopes.end());
 
   extensions::IdentityAPI::GetFactoryInstance()
-      ->GetForProfile(GetProfile())
+      ->Get(GetProfile())
       ->mint_queue()
       ->RequestComplete(type, *token_key_, this);
 }
 
 void IdentityGetAuthTokenFunction::StartMintToken(
     IdentityMintRequestQueue::MintType type) {
   const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(GetExtension());
-  IdentityAPI* id_api =
-      IdentityAPI::GetFactoryInstance()->GetForProfile(GetProfile());
+  IdentityAPI* id_api = IdentityAPI::GetFactoryInstance()->Get(GetProfile());
   IdentityTokenCacheValue cache_entry = id_api->GetCachedToken(*token_key_);
   IdentityTokenCacheValue::CacheValueStatus cache_status =
       cache_entry.status();
 
   if (type == IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE) {
     switch (cache_status) {
       case IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND:
 #if defined(OS_CHROMEOS)
         // Always force minting token for ChromeOS kiosk app.
         if (chromeos::UserManager::Get()->IsLoggedInAsKioskApp()) {
@@ skipping 41 matching lines @@
     } else {
       ShowOAuthApprovalDialog(issue_advice_);
     }
   }
 }
 
 void IdentityGetAuthTokenFunction::OnMintTokenSuccess(
     const std::string& access_token, int time_to_live) {
   IdentityTokenCacheValue token(access_token,
                                 base::TimeDelta::FromSeconds(time_to_live));
-  IdentityAPI::GetFactoryInstance()
-      ->GetForProfile(GetProfile())
-      ->SetCachedToken(*token_key_, token);
+  IdentityAPI::GetFactoryInstance()->Get(GetProfile())->SetCachedToken(
+      *token_key_, token);
 
   CompleteMintTokenFlow();
   CompleteFunctionWithResult(access_token);
 }
 
 void IdentityGetAuthTokenFunction::OnMintTokenFailure(
     const GoogleServiceAuthError& error) {
   CompleteMintTokenFlow();
 
   switch (error.state()) {
     case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS:
     case GoogleServiceAuthError::ACCOUNT_DELETED:
     case GoogleServiceAuthError::ACCOUNT_DISABLED:
       extensions::IdentityAPI::GetFactoryInstance()
-          ->GetForProfile(GetProfile())
+          ->Get(GetProfile())
           ->ReportAuthError(error);
       if (should_prompt_for_signin_) {
         // Display a login prompt and try again (once).
         StartSigninFlow();
         return;
       }
       break;
     default:
       // Return error to caller.
       break;
   }
 
   CompleteFunctionWithError(
       std::string(identity_constants::kAuthFailure) + error.ToString());
 }
 
 void IdentityGetAuthTokenFunction::OnIssueAdviceSuccess(
     const IssueAdviceInfo& issue_advice) {
-  IdentityAPI::GetFactoryInstance()
-      ->GetForProfile(GetProfile())
-      ->SetCachedToken(*token_key_,
-                       IdentityTokenCacheValue(issue_advice));
+  IdentityAPI::GetFactoryInstance()->Get(GetProfile())->SetCachedToken(
+      *token_key_, IdentityTokenCacheValue(issue_advice));
   CompleteMintTokenFlow();
 
   should_prompt_for_signin_ = false;
   // Existing grant was revoked and we used NO_FORCE, so we got info back
   // instead. Start a consent UI if we can.
   issue_advice_ = issue_advice;
   StartMintTokenFlow(IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE);
 }
 
 void IdentityGetAuthTokenFunction::SigninSuccess() {
@@ skipping 43 matching lines @@
 }
 
 void IdentityGetAuthTokenFunction::OnGaiaFlowCompleted(
     const std::string& access_token,
     const std::string& expiration) {
 
   int time_to_live;
   if (!expiration.empty() && base::StringToInt(expiration, &time_to_live)) {
     IdentityTokenCacheValue token_value(
         access_token, base::TimeDelta::FromSeconds(time_to_live));
-    IdentityAPI::GetFactoryInstance()
-        ->GetForProfile(GetProfile())
-        ->SetCachedToken(*token_key_, token_value);
+    IdentityAPI::GetFactoryInstance()->Get(GetProfile())->SetCachedToken(
+        *token_key_, token_value);
   }
 
   CompleteMintTokenFlow();
   CompleteFunctionWithResult(access_token);
 }
 
 void IdentityGetAuthTokenFunction::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
@@ skipping 127 matching lines @@
 
 bool IdentityRemoveCachedAuthTokenFunction::RunImpl() {
   if (GetProfile()->IsOffTheRecord()) {
     error_ = identity_constants::kOffTheRecord;
     return false;
   }
 
   scoped_ptr<identity::RemoveCachedAuthToken::Params> params(
       identity::RemoveCachedAuthToken::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  IdentityAPI::GetFactoryInstance()
-      ->GetForProfile(GetProfile())
-      ->EraseCachedToken(GetExtension()->id(), params->details.token);
+  IdentityAPI::GetFactoryInstance()->Get(GetProfile())->EraseCachedToken(
+      GetExtension()->id(), params->details.token);
   return true;
 }
 
 IdentityLaunchWebAuthFlowFunction::IdentityLaunchWebAuthFlowFunction() {}
 
 IdentityLaunchWebAuthFlowFunction::~IdentityLaunchWebAuthFlowFunction() {
   if (auth_flow_)
     auth_flow_.release()->DetachDelegateAndDelete();
 }
 
@@ skipping 174 matching lines @@
 
 GoogleServiceAuthError IdentityAPI::GetAuthStatusForTest() const {
   return account_tracker_.GetAuthStatus();
 }
 
 void IdentityAPI::Shutdown() {
   account_tracker_.RemoveObserver(this);
   account_tracker_.Shutdown();
 }
 
-static base::LazyInstance<ProfileKeyedAPIFactory<IdentityAPI> >
+static base::LazyInstance<BrowserContextKeyedAPIFactory<IdentityAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
-ProfileKeyedAPIFactory<IdentityAPI>* IdentityAPI::GetFactoryInstance() {
+BrowserContextKeyedAPIFactory<IdentityAPI>* IdentityAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void IdentityAPI::OnAccountAdded(const AccountIds& ids) {}
 
 void IdentityAPI::OnAccountRemoved(const AccountIds& ids) {}
 
 void IdentityAPI::OnAccountSignInChanged(const AccountIds& ids,
                                          bool is_signed_in) {
   api::identity::AccountInfo account_info;
   account_info.id = ids.gaia;
 
   scoped_ptr<base::ListValue> args =
       api::identity::OnSignInChanged::Create(account_info, is_signed_in);
   scoped_ptr<Event> event(new Event(api::identity::OnSignInChanged::kEventName,
                                     args.Pass(),
                                     browser_context_));
 
   ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
       event.Pass());
 }
 
 template <>
-void ProfileKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
+void BrowserContextKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
 
 }  // namespace extensions