Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 2).

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 47 matching lines @@
 const char kPageLoadFailure[] = "Authorization page could not be loaded.";
 
 const int kCachedIssueAdviceTTLSeconds = 1;
 }  // namespace identity_constants
 
 namespace {
 
 static const char kChromiumDomainRedirectUrlPattern[] =
     "https://%s.chromiumapp.org/";
 
-std::string GetPrimaryAccountId(Profile* profile) {
+std::string GetPrimaryAccountId(content::BrowserContext* context) {
   SigninManagerBase* signin_manager =
-      SigninManagerFactory::GetForProfile(profile);
+      SigninManagerFactory::GetForProfile(Profile::FromBrowserContext(context));
   return signin_manager->GetAuthenticatedAccountId();
 }
 
 }  // namespace
 
 namespace identity = api::identity;
 
 IdentityGetAuthTokenFunction::IdentityGetAuthTokenFunction()
     : OAuth2TokenService::Consumer("extensions_identity_api"),
       should_prompt_for_scopes_(false),
@@ skipping 589 matching lines @@
 
 bool IdentityTokenCacheValue::is_expired() const {
   return status_ == CACHE_STATUS_NOTFOUND ||
       expiration_time_ < base::Time::Now();
 }
 
 const base::Time& IdentityTokenCacheValue::expiration_time() const {
   return expiration_time_;
 }
 
-IdentityAPI::IdentityAPI(Profile* profile)
-    : profile_(profile),
-      account_tracker_(profile) {
+IdentityAPI::IdentityAPI(content::BrowserContext* context)
+    : browser_context_(context),
+      account_tracker_(Profile::FromBrowserContext(context)) {
   account_tracker_.AddObserver(this);
 }
 
 IdentityAPI::~IdentityAPI() {}
 
 IdentityMintRequestQueue* IdentityAPI::mint_queue() {
     return &mint_queue_;
 }
 
 void IdentityAPI::SetCachedToken(const ExtensionTokenKey& key,
@@ skipping 25 matching lines @@
 const IdentityTokenCacheValue& IdentityAPI::GetCachedToken(
     const ExtensionTokenKey& key) {
   return token_cache_[key];
 }
 
 const IdentityAPI::CachedTokens& IdentityAPI::GetAllCachedTokens() {
   return token_cache_;
 }
 
 void IdentityAPI::ReportAuthError(const GoogleServiceAuthError& error) {
-  account_tracker_.ReportAuthError(GetPrimaryAccountId(profile_), error);
+  account_tracker_.ReportAuthError(GetPrimaryAccountId(browser_context_),
+                                   error);
 }
 
 void IdentityAPI::Shutdown() {
   account_tracker_.RemoveObserver(this);
   account_tracker_.Shutdown();
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<IdentityAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<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(), profile_));
+  scoped_ptr<Event> event(new Event(api::identity::OnSignInChanged::kEventName,
+                                    args.Pass(),
+                                    browser_context_));
 
-  ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
+  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
+      event.Pass());
 }
 
 template <>
 void ProfileKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
 
 }  // namespace extensions