arc: Use v2/auth LSO page.

chrome/browser/chromeos/arc/arc_auth_service.cc

 // Copyright 2015 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/chromeos/arc/arc_auth_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
@@ skipping 112 matching lines @@
 
   const std::string auth_code = GetAndResetAuthCode();
   const bool verification_disabled = IsOptInVerificationDisabled();
   if (!auth_code.empty() || verification_disabled) {
     callback.Run(mojo::String(auth_code), !verification_disabled);
     return;
   }
 
   initial_opt_in_ = false;
   auth_callback_ = callback;
-  SetState(State::FETCHING_CODE);
-  FetchAuthCode();
+  StartUI();
 }
 
 void ArcAuthService::OnSignInComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, State::ACTIVE);
 
   profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, true);
   CloseUI();
 }
 
@@ skipping 142 matching lines @@
 
   DCHECK(!initial_opt_in_);
   context_prepared_ = true;
   ShowUI(UIPage::LSO_PROGRESS, base::string16());
 }
 
 void ArcAuthService::OnMergeSessionFailure(
     const GoogleServiceAuthError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(2) << "Failed to merge gaia session " << error.ToString() << ".";
-  OnAuthCodeFailed();
+  OnPrepareContextFailed();
 }
 
 void ArcAuthService::OnUbertokenSuccess(const std::string& token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   merger_fetcher_.reset(
       new GaiaAuthFetcher(this, GaiaConstants::kChromeOSSource,
                           storage_partition_->GetURLRequestContext()));
   merger_fetcher_->StartMergeSession(token, std::string());
 }
 
 void ArcAuthService::OnUbertokenFailure(const GoogleServiceAuthError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(2) << "Failed to get ubertoken " << error.ToString() << ".";
-  OnAuthCodeFailed();
+  OnPrepareContextFailed();
 }
 
 void ArcAuthService::OnSyncedPrefChanged(const std::string& path,
                                          bool from_sync) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update UMA only for local changes
   if (!from_sync) {
     UpdateOptInActionUMA(profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled)
                              ? OptInActionType::OPTED_IN
                              : OptInActionType::OPTED_OUT);
   }
 
   OnOptInPreferenceChanged();
 }
 
 void ArcAuthService::OnOptInPreferenceChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(profile_);
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled)) {
     if (state_ != State::ACTIVE) {
       CloseUI();
       auth_code_.clear();
 
       if (!profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
         // Need pre-fetch auth code and show OptIn UI if needed.
         initial_opt_in_ = true;
-        SetState(State::FETCHING_CODE);
-        FetchAuthCode();
+        StartUI();
       } else {
         // Ready to start Arc.
         StartArc();
       }
 
       UpdateEnabledStateUMA(true);
     }
   } else {
     if (state_ != State::STOPPED)
       UpdateEnabledStateUMA(false);
     ShutdownBridgeAndCloseUI();
   }
 }
 
 void ArcAuthService::ShutdownBridge() {
   auth_callback_.reset();
-  auth_fetcher_.reset();
   ubertoken_fethcher_.reset();
   merger_fetcher_.reset();
   ArcBridgeService::Get()->Shutdown();
   SetState(State::STOPPED);
 }
 
 void ArcAuthService::ShutdownBridgeAndCloseUI() {
   ShutdownBridge();
   CloseUI();
 }
@@ skipping 48 matching lines @@
     ShutdownBridgeAndCloseUI();
     return;
   }
 
   SetUIPage(UIPage::START_PROGRESS, base::string16());
   ShutdownBridge();
   auth_code_ = auth_code;
   StartArc();
 }
 
-void ArcAuthService::CheckAuthCode() {
+void ArcAuthService::StartLSO() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update UMA only if error is currently shown.
   if (ui_page_ == UIPage::ERROR)
     UpdateOptInActionUMA(OptInActionType::RETRY);
 
   initial_opt_in_ = false;
-  SetState(State::FETCHING_CODE);
-  FetchAuthCode();
-}
-
-void ArcAuthService::FetchAuthCode() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (state_ != State::FETCHING_CODE)
-    return;
-
-  auth_fetcher_.reset(
-      new ArcAuthFetcher(storage_partition_->GetURLRequestContext(), this));
+  StartUI();
 }
 
 void ArcAuthService::CancelAuthCode() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != State::FETCHING_CODE)
     return;
 
   // Update UMA with user cancel only if error is not currently shown.
   if (ui_page_ != UIPage::ERROR && ui_page_ != UIPage::NO_PAGE)
     UpdateOptInCancelUMA(OptInCancelReason::USER_CANCEL);
 
   DisableArc();
 }
 
 void ArcAuthService::EnableArc() {
   DCHECK(thread_checker_.CalledOnValidThread());
   profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
 }
 
 void ArcAuthService::DisableArc() {
   DCHECK(thread_checker_.CalledOnValidThread());
   profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
 }
 
-void ArcAuthService::OnAuthCodeFetched(const std::string& auth_code) {
-  DCHECK_EQ(state_, State::FETCHING_CODE);
-  SetAuthCodeAndStartArc(auth_code);
-}
-
 void ArcAuthService::PrepareContext() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Get auth token to continue.
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile_);
   CHECK(token_service && signin_manager);
   const std::string& account_id = signin_manager->GetAuthenticatedAccountId();
   ubertoken_fethcher_.reset(
       new UbertokenFetcher(token_service, this, GaiaConstants::kChromeOSSource,
                            storage_partition_->GetURLRequestContext()));
   ubertoken_fethcher_->StartFetchingToken(account_id);
 }
 
-void ArcAuthService::OnAuthCodeNeedUI() {
+void ArcAuthService::StartUI() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  SetState(State::FETCHING_CODE);
+
   if (initial_opt_in_) {
     initial_opt_in_ = false;
     ShowUI(UIPage::START, base::string16());
   } else if (context_prepared_) {
     ShowUI(UIPage::LSO_PROGRESS, base::string16());
   } else {
     PrepareContext();
   }
 }
 
-void ArcAuthService::OnAuthCodeFailed() {
+void ArcAuthService::OnPrepareContextFailed() {
   DCHECK_EQ(state_, State::FETCHING_CODE);
 
-  if (initial_opt_in_) {
-    // Don't show error as first page.
-    initial_opt_in_ = false;
-    ShutdownBridgeAndShowUI(UIPage::START, base::string16());
-  } else {
-    ShutdownBridgeAndShowUI(
-        UIPage::ERROR,
-        l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
-    UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
-  }
+  ShutdownBridgeAndShowUI(
+      UIPage::ERROR,
+      l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
+  UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
 }
 
 std::ostream& operator<<(std::ostream& os, const ArcAuthService::State& state) {
   switch (state) {
     case ArcAuthService::State::STOPPED:
       return os << kStateStopped;
     case ArcAuthService::State::FETCHING_CODE:
       return os << kStateFetchingCode;
     case ArcAuthService::State::ACTIVE:
       return os << kStateActive;
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc