arc: Add a global 5 minute timeout for ARC opt-in

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"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
+#include "base/time/time.h"
 #include "chrome/browser/chromeos/arc/arc_android_management_checker.h"
 #include "chrome/browser/chromeos/arc/arc_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/arc_auth_context.h"
 #include "chrome/browser/chromeos/arc/arc_auth_notification.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
@@ skipping 32 matching lines @@
 // Skip creating UI in unit tests
 bool g_disable_ui_for_testing = false;
 
 // Use specified ash::ShelfDelegate for unit tests.
 ash::ShelfDelegate* g_shelf_delegate_for_testing = nullptr;
 
 // The Android management check is disabled by default, it's used only for
 // testing.
 bool g_enable_check_android_management_for_testing = false;
 
+// Maximum amount of time we'll wait for ARC to finish booting up. Once this
+// timeout expires, keep ARC running in case the user wants to file feedback,
+// but present the UI to try again.
+constexpr base::TimeDelta kArcSignInTimeout = base::TimeDelta::FromMinutes(5);
+
 const char kStateNotInitialized[] = "NOT_INITIALIZED";
 const char kStateStopped[] = "STOPPED";
 const char kStateFetchingCode[] = "FETCHING_CODE";
 const char kStateActive[] = "ACTIVE";
 
 bool IsAccountManaged(Profile* profile) {
   return policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile)
       ->IsManaged();
 }
 
@@ skipping 144 matching lines @@
   return true;
 }
 
 void ArcAuthService::OnInstanceReady() {
   arc_bridge_service()->auth()->instance()->Init(
       binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcAuthService::OnBridgeStopped(ArcBridgeService::StopReason reason) {
   // TODO(crbug.com/625923): Use |reason| to report more detailed errors.
-  if (waiting_for_reply_) {
-    // Using SERVICE_UNAVAILABLE instead of UNKNOWN_ERROR, since the latter
-    // causes this code to not try to stop ARC, so it would retry without the
-    // user noticing.
+  if (arc_sign_in_timer_.IsRunning()) {
     OnSignInFailedInternal(ProvisioningResult::ARC_STOPPED);
   }
 
   if (clear_required_) {
     // This should be always true, but just in case as this is looked at
     // inside RemoveArcData() at first.
     DCHECK(arc_bridge_service()->stopped());
     RemoveArcData();
   } else {
     // To support special "Stop and enable ARC" procedure for enterprise,
@@ skipping 64 matching lines @@
   initial_opt_in_ = false;
   auth_callback_ = callback;
   StartUI();
 }
 
 void ArcAuthService::OnSignInComplete() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
   DCHECK(!sign_in_time_.is_null());
 
-  waiting_for_reply_ = false;
+  arc_sign_in_timer_.Stop();
 
   if (!IsOptInVerificationDisabled() &&
       !profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
     playstore_launcher_.reset(
         new ArcAppLauncher(profile_, kPlayStoreAppId, true));
   }
 
   profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, true);
   CloseUI();
   UpdateProvisioningTiming(base::Time::Now() - sign_in_time_, true,
                            IsAccountManaged(profile_));
   UpdateProvisioningResultUMA(ProvisioningResult::SUCCESS);
 
   FOR_EACH_OBSERVER(Observer, observer_list_, OnInitialStart());
 }
 
 void ArcAuthService::OnSignInFailed(arc::mojom::ArcSignInFailureReason reason) {
   OnSignInFailedInternal(
       ConvertArcSignInFailureReasonToProvisioningResult(reason));
 }
 
 void ArcAuthService::OnSignInFailedInternal(ProvisioningResult result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
   DCHECK(!sign_in_time_.is_null());
 
-  waiting_for_reply_ = false;
+  arc_sign_in_timer_.Stop();
 
   UpdateProvisioningTiming(base::Time::Now() - sign_in_time_, false,
                            IsAccountManaged(profile_));
   UpdateOptInCancelUMA(OptInCancelReason::CLOUD_PROVISION_FLOW_FAIL);
   UpdateProvisioningResultUMA(result);
 
   int error_message_id;
   switch (result) {
     case ProvisioningResult::GMS_NETWORK_ERROR:
       error_message_id = IDS_ARC_SIGN_IN_NETWORK_ERROR;
@@ skipping 26 matching lines @@
     if (profile_->GetPrefs()->HasPrefPath(prefs::kArcSignedIn))
       profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
     ShutdownBridgeAndShowUI(UIPage::ERROR,
                             l10n_util::GetStringUTF16(error_message_id));
     return;
   }
 
   if (result == ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR ||
-      result == ProvisioningResult::UNKNOWN_ERROR)
+      // OVERALL_SIGN_IN_TIMEOUT might be an indication that ARC believes it is
+      // fully setup, but Chrome does not.
+      result == ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT ||
+      // Just to be safe, remove data if we don't know the cause.
+      result == ProvisioningResult::UNKNOWN_ERROR) {
     RemoveArcData();
+  }
 
   // We'll delay shutting down the bridge in this case to allow people to send
   // feedback.
   ShowUI(UIPage::ERROR_WITH_FEEDBACK,
          l10n_util::GetStringUTF16(error_message_id));
 }
 
 void ArcAuthService::GetIsAccountManaged(
     const GetIsAccountManagedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 183 matching lines @@
       CheckAndroidManagement(true);
     } else {
       StartArc();
     }
   }
 
   UpdateEnabledStateUMA(true);
 }
 
 void ArcAuthService::ShutdownBridge() {
+  arc_sign_in_timer_.Stop();
   playstore_launcher_.reset();
   auth_callback_.Reset();
   android_management_checker_.reset();
   auth_code_fetcher_.reset();
   arc_bridge_service()->Shutdown();
   if (state_ != State::NOT_INITIALIZED)
     SetState(State::STOPPED);
   FOR_EACH_OBSERVER(Observer, observer_list_, OnShutdownBridge());
 }
 
@@ skipping 59 matching lines @@
     return;
   }
 
   State state = state_;
   if (state != State::FETCHING_CODE) {
     ShutdownBridgeAndCloseUI();
     return;
   }
 
   sign_in_time_ = base::Time::Now();
+  VLOG(1) << "Starting ARC for first sign in.";
 
   SetUIPage(UIPage::START_PROGRESS, base::string16());
   ShutdownBridge();
   auth_code_ = auth_code;
-  waiting_for_reply_ = true;
+  arc_sign_in_timer_.Start(FROM_HERE, kArcSignInTimeout,
+                           base::Bind(&ArcAuthService::OnArcSignInTimeout,
+                                      weak_ptr_factory_.GetWeakPtr()));
   StartArc();
 }
 
+void ArcAuthService::OnArcSignInTimeout() {
+  LOG(ERROR) << "Timed out waiting for first sign in.";
+  OnSignInFailedInternal(ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT);
+}
+
 void ArcAuthService::StartLso() {
   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();
   }
@@ skipping 194 matching lines @@
       return os << kStateFetchingCode;
     case ArcAuthService::State::ACTIVE:
       return os << kStateActive;
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc