Make the SigninErrorController a PKS.

components/signin/ios/browser/profile_oauth2_token_service_ios.mm

 // Copyright 2014 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 "components/signin/ios/browser/profile_oauth2_token_service_ios.h"
 
 #include <Foundation/Foundation.h>
 
 #include <set>
 #include <string>
@@ skipping 112 matching lines @@
         base::Time::FromDoubleT([expiration timeIntervalSince1970]);
     FireOnGetTokenSuccess(base::SysNSStringToUTF8(token), expiration_date);
   } else {
     FireOnGetTokenFailure(auth_error);
   }
 }
 
 }  // namespace
 
 ProfileOAuth2TokenServiceIOS::AccountInfo::AccountInfo(
-    ProfileOAuth2TokenService* token_service,
+    SigninErrorController* signin_error_controller,
     const std::string& account_id)
-    : token_service_(token_service),
+    : signin_error_controller_(signin_error_controller),
       account_id_(account_id),
       last_auth_error_(GoogleServiceAuthError::NONE) {
-  DCHECK(token_service_);
+  DCHECK(signin_error_controller_);
   DCHECK(!account_id_.empty());
-  token_service_->signin_error_controller()->AddProvider(this);
+  signin_error_controller_->AddProvider(this);
 }
 
 ProfileOAuth2TokenServiceIOS::AccountInfo::~AccountInfo() {
-  token_service_->signin_error_controller()->RemoveProvider(this);
+  signin_error_controller_->RemoveProvider(this);
 }
 
 void ProfileOAuth2TokenServiceIOS::AccountInfo::SetLastAuthError(
     const GoogleServiceAuthError& error) {
   if (error.state() != last_auth_error_.state()) {
     last_auth_error_ = error;
-    token_service_->signin_error_controller()->AuthStatusChanged();
+    signin_error_controller_->AuthStatusChanged();
   }
 }
 
 std::string ProfileOAuth2TokenServiceIOS::AccountInfo::GetAccountId() const {
   return account_id_;
 }
 
 std::string ProfileOAuth2TokenServiceIOS::AccountInfo::GetUsername() const {
   // TODO(rogerta): when |account_id| becomes the obfuscated gaia id, this
   // will need to be changed.
   return account_id_;
 }
 
 GoogleServiceAuthError
 ProfileOAuth2TokenServiceIOS::AccountInfo::GetAuthStatus() const {
   return last_auth_error_;
 }
 
 ProfileOAuth2TokenServiceIOS::ProfileOAuth2TokenServiceIOS()
     : ProfileOAuth2TokenService() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 ProfileOAuth2TokenServiceIOS::~ProfileOAuth2TokenServiceIOS() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-void ProfileOAuth2TokenServiceIOS::Initialize(SigninClient* client) {
+void ProfileOAuth2TokenServiceIOS::Initialize(
+    SigninClient* client, SigninErrorController* signin_error_controller) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  ProfileOAuth2TokenService::Initialize(client);
+  ProfileOAuth2TokenService::Initialize(client, signin_error_controller);
 }
 
 void ProfileOAuth2TokenServiceIOS::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CancelAllRequests();
   accounts_.clear();
   ProfileOAuth2TokenService::Shutdown();
 }
 
 ios::ProfileOAuth2TokenServiceIOSProvider*
@@ skipping 133 matching lines @@
                              GoogleServiceAuthError::NONE) {
     // No need to update the account if it is already a known account and if
     // there is no auth error.
     return;
   }
 
   if (account_present) {
     CancelRequestsForAccount(account_id);
     ClearCacheForAccount(account_id);
   } else {
-    accounts_[account_id].reset(new AccountInfo(this, account_id));
+    accounts_[account_id].reset(
+        new AccountInfo(signin_error_controller(), account_id));
   }
   UpdateAuthError(account_id, GoogleServiceAuthError::AuthErrorNone());
   FireRefreshTokenAvailable(account_id);
 }
 
 void ProfileOAuth2TokenServiceIOS::RemoveAccount(
     const std::string& account_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!account_id.empty());
 
   if (accounts_.count(account_id) > 0) {
     CancelRequestsForAccount(account_id);
     ClearCacheForAccount(account_id);
     accounts_.erase(account_id);
     FireRefreshTokenRevoked(account_id);
   }
 }