[Merge-M55] arc: Restore broken auth code request on demand.

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 "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
@@ skipping 286 matching lines @@
 void ArcAuthService::GetAuthCodeDeprecated(
     const GetAuthCodeDeprecatedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!IsOptInVerificationDisabled());
   callback.Run(GetAndResetAuthCode());
 }
 
 void ArcAuthService::GetAuthCode(const GetAuthCodeCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // GetAuthCodeAndAccountType operation must not be in progress.
-  DCHECK(!auth_account_callback_.is_null());
+  DCHECK(auth_account_callback_.is_null());
 
   const std::string auth_code = GetAndResetAuthCode();
   const bool verification_disabled = IsOptInVerificationDisabled();
   if (!auth_code.empty() || verification_disabled) {
     callback.Run(auth_code, !verification_disabled);
     return;
   }
 
-  initial_opt_in_ = false;
   auth_callback_ = callback;
-  StartUI();
+  PrepareContextForAuthCodeRequest();
 }
 
 void ArcAuthService::GetAuthCodeAndAccountType(
     const GetAuthCodeAndAccountTypeCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // GetAuthCode operation must not be in progress.
-  DCHECK(!auth_callback_.is_null());
+  DCHECK(auth_callback_.is_null());
 
   const std::string auth_code = GetAndResetAuthCode();
   const bool verification_disabled = IsOptInVerificationDisabled();
   if (!auth_code.empty() || verification_disabled) {
     callback.Run(auth_code, !verification_disabled,
                  mojom::ChromeAccountType::USER_ACCOUNT);
     return;
   }
 
+  auth_account_callback_ = callback;
+  PrepareContextForAuthCodeRequest();
+}
+
+bool ArcAuthService::IsAuthCodeRequest() const {
+  return !auth_callback_.is_null() || !auth_account_callback_.is_null();
+}
+
+void ArcAuthService::PrepareContextForAuthCodeRequest() {
+  // Requesting auth code on demand happens in following cases:
+  // 1. To handle account password revoke.
+  // 2. In case Arc is activated in OOBE flow.
+  // 3. For any other state on Android side that leads device appears in
+  // non-signed state.
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(IsAuthCodeRequest());
+  DCHECK_EQ(state_, State::ACTIVE);
   initial_opt_in_ = false;
-  auth_account_callback_ = callback;
-  StartUI();
+  context_->PrepareContext();
 }
 
 void ArcAuthService::OnSignInComplete() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
   DCHECK(!sign_in_time_.is_null());
 
   arc_sign_in_timer_.Stop();
 
   if (!IsOptInVerificationDisabled() &&
@@ skipping 339 matching lines @@
 void ArcAuthService::StartArc() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   arc_bridge_service()->HandleStartup();
   SetState(State::ACTIVE);
 }
 
 void ArcAuthService::SetAuthCodeAndStartArc(const std::string& auth_code) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!auth_code.empty());
 
-  if (!auth_callback_.is_null() || !auth_account_callback_.is_null()) {
+  if (IsAuthCodeRequest()) {
     DCHECK_EQ(state_, State::FETCHING_CODE);
     SetState(State::ACTIVE);
     if (!auth_callback_.is_null()) {
       auth_callback_.Run(auth_code, !IsOptInVerificationDisabled());
       auth_callback_.Reset();
       return;
     } else {
       auth_account_callback_.Run(auth_code, !IsOptInVerificationDisabled(),
                                  mojom::ChromeAccountType::USER_ACCOUNT);
       auth_account_callback_.Reset();
@@ skipping 27 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Update UMA only if error (with or without feedback) is currently shown.
   if (ui_page_ == UIPage::ERROR) {
     UpdateOptInActionUMA(OptInActionType::RETRY);
   } else if (ui_page_ == UIPage::ERROR_WITH_FEEDBACK) {
     UpdateOptInActionUMA(OptInActionType::RETRY);
     ShutdownBridge();
   }
 
+  // TODO(khmel): Use PrepareContextForAuthCodeRequest for this case.
   initial_opt_in_ = false;
   StartUI();
 }
 
 void ArcAuthService::CancelAuthCode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (state_ == State::NOT_INITIALIZED) {
     NOTREACHED();
     return;
@@ skipping 95 matching lines @@
   DCHECK_EQ(state_, State::FETCHING_CODE);
   ShutdownBridgeAndShowUI(
       UIPage::ERROR,
       l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
   UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
 }
 
 void ArcAuthService::CheckAndroidManagement(bool background_mode) {
   // Do not send requests for Chrome OS managed users.
   if (IsAccountManaged(profile_)) {
-    StartArcIfSignedIn();
+    OnAndroidManagementPassed();
     return;
   }
 
   // Do not send requests for well-known consumer domains.
   if (policy::BrowserPolicyConnector::IsNonEnterpriseUser(
           profile_->GetProfileUserName())) {
-    StartArcIfSignedIn();
+    OnAndroidManagementPassed();
     return;
   }
 
   android_management_checker_.reset(
       new ArcAndroidManagementChecker(this, context_->token_service(),
                                       context_->account_id(), background_mode));
   if (background_mode)
-    StartArcIfSignedIn();
+    OnAndroidManagementPassed();
 }
 
 void ArcAuthService::OnAndroidManagementChecked(
     policy::AndroidManagementClient::Result result) {
   switch (result) {
     case policy::AndroidManagementClient::Result::RESULT_UNMANAGED:
-      StartArcIfSignedIn();
+      OnAndroidManagementPassed();
       break;
     case policy::AndroidManagementClient::Result::RESULT_MANAGED:
       if (android_management_checker_->background_mode()) {
         DisableArc();
         return;
       }
       ShutdownBridgeAndShowUI(
           UIPage::ERROR,
           l10n_util::GetStringUTF16(IDS_ARC_ANDROID_MANAGEMENT_REQUIRED_ERROR));
       UpdateOptInCancelUMA(OptInCancelReason::ANDROID_MANAGEMENT_REQUIRED);
       break;
     case policy::AndroidManagementClient::Result::RESULT_ERROR:
       ShutdownBridgeAndShowUI(
           UIPage::ERROR,
           l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
       UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
       break;
     default:
       NOTREACHED();
   }
 }
 
-void ArcAuthService::StartArcIfSignedIn() {
+void ArcAuthService::FetchAuthCode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (state_ == State::ACTIVE)
+
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  std::string auth_endpoint;
+  if (command_line->HasSwitch(chromeos::switches::kArcUseAuthEndpoint)) {
+    auth_endpoint = command_line->GetSwitchValueASCII(
+        chromeos::switches::kArcUseAuthEndpoint);
+  }
+
+  if (!auth_endpoint.empty()) {
+    auth_code_fetcher_.reset(new ArcAuthCodeFetcher(
+        this, context_->GetURLRequestContext(), profile_, auth_endpoint));
+  } else {
+    ShowUI(UIPage::LSO_PROGRESS, base::string16());
+  }
+}
+
+void ArcAuthService::OnAndroidManagementPassed() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (state_ == State::ACTIVE) {
+    if (IsAuthCodeRequest())
+      FetchAuthCode();
     return;
+  }
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn) ||
       IsOptInVerificationDisabled()) {
     StartArc();
   } else {
-    const base::CommandLine* command_line =
-        base::CommandLine::ForCurrentProcess();
-    std::string auth_endpoint;
-    if (command_line->HasSwitch(chromeos::switches::kArcUseAuthEndpoint)) {
-      auth_endpoint = command_line->GetSwitchValueASCII(
-          chromeos::switches::kArcUseAuthEndpoint);
-    }
-
-    if (!auth_endpoint.empty()) {
-      auth_code_fetcher_.reset(new ArcAuthCodeFetcher(
-          this, context_->GetURLRequestContext(), profile_, auth_endpoint));
-    } else {
-      ShowUI(UIPage::LSO_PROGRESS, base::string16());
-    }
+    FetchAuthCode();
   }
 }
 
 std::ostream& operator<<(std::ostream& os, const ArcAuthService::State& state) {
   switch (state) {
     case ArcAuthService::State::NOT_INITIALIZED:
       return os << kStateNotInitialized;
     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