Delay loading the NTP after sign in until MergeSession has been performed in

chrome/browser/signin/signin_tracker.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/signin/signin_tracker.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/account_reconcilor_factory.h"
+#include "chrome/browser/signin/google_auto_login_helper.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
+#include "chrome/common/profile_management_switches.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_constants.h"
 
 SigninTracker::SigninTracker(Profile* profile, Observer* observer)
     : profile_(profile), observer_(observer) {
   DCHECK(profile_);
   Initialize();
 }
 
 SigninTracker::~SigninTracker() {
   ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)->
       RemoveObserver(this);
+
+  if (merge_session_helper_)
+    merge_session_helper_->RemoveObserver(this);
+
+  if (switches::IsEnableInlineSignin() && switches::IsNewProfileManagement()) {
+      AccountReconcilorFactory::GetForProfile(profile_)->
+          RemoveMergeSessionObserver(this);
+  }
 }
 
 void SigninTracker::Initialize() {
   DCHECK(observer_);
 
   // Register for notifications from the SigninManager.
   registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED,
                  content::Source<Profile>(profile_));
 
   OAuth2TokenService* token_service =
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   token_service->AddObserver(this);
 }
 
 void SigninTracker::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED, type);
 
   // We should not get more than one of these notifications.
   const GoogleServiceAuthError& error =
       *(content::Details<const GoogleServiceAuthError>(details).ptr());
   observer_->SigninFailed(error);
 }
 
 void SigninTracker::OnRefreshTokenAvailable(const std::string& account_id) {
   // TODO: when OAuth2TokenService handles multi-login, this should check
   // that |account_id| is the primary account before signalling success.
+  if (switches::IsEnableInlineSignin()) {
+    if (switches::IsNewProfileManagement()) {
+      AccountReconcilorFactory::GetForProfile(profile_)->
+          AddMergeSessionObserver(this);
+    } else {
+      merge_session_helper_.reset(new GoogleAutoLoginHelper(profile_, this));

[guohui, 2013/12/20 16:11:09]

It looks wierd to me to create a GoogleAutoLoginHelper and to start merge
session in SigninTracker. My understanding of SigninTracker is that it is an
observer helper for signin, any class that is interested in monitoring signin
events could create their own instance of SigninTracker and get notification
when certain signin events are triggered, however SIgninTracker itself should
not make any change to the signin state. Otherwise multiple SIgninTracker may
intervene with each other, resulting in multiple instances of
GogleAutoLoginHelper, which is exactly what this CL aims to fix.

I think it is better to ensure there is always at most one instance of
GoogleAutoLoginHelper. A few random ideas:

1. make GoogleAutoLoginHelper a PSK, in both mirror and non-mirror world
SIgninTrackers listens directly to GoogleAutoLoginHelper. May be an overkill.
2. attach GoogleAutoLoginHelper to an existing PSK. You already attach
GoogleAutoLoginHelper to AccountReconciler in the mirror world, maybe you can do
the same for non-mirror and attach GoogleAutoLoginHelper to another PKS, such as
SigninManager or PO2TS.
3. enables part of the functionality, such as MergeSession, of AccountReconciler
in non-mirror world. Not sure if this is possible at all, just list it here for
completeness.

[Roger Tawa OOO till Jul 10th, 2013/12/20 20:02:01]

Agreed, does not make sense to do this in the tracker.  A new PKS is overkill,
so implemented suggestion 2.

+      merge_session_helper_->LogIn(account_id);
+    }
+  }
+
   observer_->SigninSuccess();
 }
 
 void SigninTracker::OnRefreshTokenRevoked(const std::string& account_id) {
   NOTREACHED();
 }
+
+void SigninTracker::MergeSessionCompleted(
+    const std::string& account_id,
+    const GoogleServiceAuthError& error) {
+  observer_->MergeSessionComplete(error);
+}