non-new-profile-management creates a "no-op" style account_reconcilor,

components/signin/core/browser/account_reconcilor.cc

 // 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/core/browser/account_reconcilor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/signin/core/browser/signin_oauth_helper.h"
+#include "components/signin/core/common/profile_management_switches.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/cookies/canonical_cookie.h"
 
 
 namespace {
 
@@ skipping 298 matching lines @@
   }
 }
 
 void AccountReconcilor::OnRefreshTokenAvailable(const std::string& account_id) {
   VLOG(1) << "AccountReconcilor::OnRefreshTokenAvailable: " << account_id;
   StartReconcile();
 }
 
 void AccountReconcilor::OnRefreshTokenRevoked(const std::string& account_id) {
   VLOG(1) << "AccountReconcilor::OnRefreshTokenRevoked: " << account_id;
-  StartRemoveAction(account_id);
+  PerformStartRemoveAction(account_id);
 }
 
 void AccountReconcilor::OnRefreshTokensLoaded() {}
 
 void AccountReconcilor::GoogleSigninSucceeded(const std::string& username,
                                               const std::string& password) {
   VLOG(1) << "AccountReconcilor::GoogleSigninSucceeded: signed in";
   RegisterForCookieChanges();
   RegisterWithTokenService();
 }
 
 void AccountReconcilor::GoogleSignedOut(const std::string& username) {
   VLOG(1) << "AccountReconcilor::GoogleSignedOut: signed out";
   gaia_fetcher_.reset();
   get_gaia_accounts_callbacks_.clear();
   AbortReconcile();
   UnregisterWithTokenService();
   UnregisterForCookieChanges();
   PerformLogoutAllAccountsAction();
 }
 
 void AccountReconcilor::PerformMergeAction(const std::string& account_id) {
+  if (!switches::IsNewProfileManagement())
+    return;
   VLOG(1) << "AccountReconcilor::PerformMergeAction: " << account_id;
   merge_session_helper_.LogIn(account_id);
 }
 
-void AccountReconcilor::StartRemoveAction(const std::string& account_id) {
-  VLOG(1) << "AccountReconcilor::StartRemoveAction: " << account_id;
-  GetAccountsFromCookie(base::Bind(&AccountReconcilor::FinishRemoveAction,
-                                   base::Unretained(this),
-                                   account_id));
+void AccountReconcilor::PerformStartRemoveAction(
+    const std::string& account_id) {
+  VLOG(1) << "AccountReconcilor::PerformStartRemoveAction: " << account_id;
+  GetAccountsFromCookie(base::Bind(
+      &AccountReconcilor::PerformFinishRemoveAction,
+      base::Unretained(this),
+      account_id));
 }
 
-void AccountReconcilor::FinishRemoveAction(
+void AccountReconcilor::PerformFinishRemoveAction(
     const std::string& account_id,
     const GoogleServiceAuthError& error,
     const std::vector<std::pair<std::string, bool> >& accounts) {
-  VLOG(1) << "AccountReconcilor::FinishRemoveAction:"
+  if (!switches::IsNewProfileManagement())
+    return;
+  VLOG(1) << "AccountReconcilor::PerformFinishRemoveAction:"
           << " account=" << account_id << " error=" << error.ToString();
   if (error.state() == GoogleServiceAuthError::NONE) {
     AbortReconcile();
     std::vector<std::string> accounts_only;
     for (std::vector<std::pair<std::string, bool> >::const_iterator i =
              accounts.begin();
          i != accounts.end();
          ++i) {
       accounts_only.push_back(i->first);
     }
     merge_session_helper_.LogOut(account_id, accounts_only);
   }
   // Wait for the next ReconcileAction if there is an error.
 }
 
 void AccountReconcilor::PerformAddToChromeAction(const std::string& account_id,
                                                  int session_index) {
+  if (!switches::IsNewProfileManagement())
+    return;
   VLOG(1) << "AccountReconcilor::PerformAddToChromeAction:"
           << " account=" << account_id << " session_index=" << session_index;
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   refresh_token_fetchers_.push_back(
       new RefreshTokenFetcher(this, account_id, session_index));
 #endif
 }
 
 void AccountReconcilor::PerformLogoutAllAccountsAction() {
+  if (!switches::IsNewProfileManagement())
+    return;
   VLOG(1) << "AccountReconcilor::PerformLogoutAllAccountsAction";
   merge_session_helper_.LogOutAllAccounts();
 }
 
 void AccountReconcilor::StartReconcile() {
   if (!IsProfileConnected() || is_reconcile_started_)
     return;
 
   is_reconcile_started_ = true;
 
@@ skipping 293 matching lines @@
   valid_chrome_accounts_.insert(account_id);
   FinishReconcile();
 }
 
 void AccountReconcilor::HandleFailedAccountIdCheck(
     const std::string& account_id) {
   invalid_chrome_accounts_.insert(account_id);
   FinishReconcile();
 }
 
+void AccountReconcilor::PerformAddAccountToTokenService(
+    const std::string& account_id,
+    const std::string& refresh_token) {
+  // The flow should never get to this method if new_profile_management is
+  // false, but better safe than sorry.
+  if (!switches::IsNewProfileManagement())
+    return;
+  token_service_->UpdateCredentials(account_id, refresh_token);
+}
+
 void AccountReconcilor::HandleRefreshTokenFetched(
     const std::string& account_id,
     const std::string& refresh_token) {
   if (!refresh_token.empty()) {
-    token_service_->UpdateCredentials(account_id, refresh_token);
+    PerformAddAccountToTokenService(account_id, refresh_token);
   }
-
   // Remove the account from the list that is being updated.
   for (std::vector<std::pair<std::string, int> >::iterator i =
            add_to_chrome_.begin();
        i != add_to_chrome_.end();
        ++i) {
     if (gaia::AreEmailsSame(account_id, i->first)) {
       add_to_chrome_.erase(i);
       break;
     }
   }
 
   CalculateIfReconcileIsDone();
 }