Merge provisioning success/error handling.

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 269 matching lines @@
 
 void ArcAuthService::OnInstanceReady() {
   auto* instance = arc_bridge_service()->auth()->GetInstanceForMethod("Init");
   DCHECK(instance);
   instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcAuthService::OnBridgeStopped(ArcBridgeService::StopReason reason) {
   // TODO(crbug.com/625923): Use |reason| to report more detailed errors.
   if (arc_sign_in_timer_.IsRunning()) {
-    OnSignInFailedInternal(ProvisioningResult::ARC_STOPPED);
+    OnProvisioningFinished(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,
     // here call OnArcDataRemoved(true) as if the data removal is successfully
@@ skipping 135 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(state_ == State::ACTIVE);
   DCHECK(IsAuthCodeRequest());
   DCHECK(!IsArcKioskMode());
   context_->PrepareContext();
 }
 
 void ArcAuthService::OnSignInComplete() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
-
-  if (!sign_in_time_.is_null()) {
-    arc_sign_in_timer_.Stop();
-    UpdateProvisioningTiming(base::Time::Now() - sign_in_time_, true,
-                             policy_util::IsAccountManaged(profile_));
-    UpdateProvisioningResultUMA(ProvisioningResult::SUCCESS,
-                                policy_util::IsAccountManaged(profile_));
-  }
-
-  if (support_host_)
-    support_host_->Close();
-
-  if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn))
-    return;
-
-  profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, true);
-  if (!IsOptInVerificationDisabled()) {
-    playstore_launcher_.reset(
-        new ArcAppLauncher(profile_, kPlayStoreAppId, true));
-  }
-
-  for (auto& observer : observer_list_)
-    observer.OnInitialStart();
+  OnProvisioningFinished(ProvisioningResult::SUCCESS);
 }
 
 void ArcAuthService::OnSignInFailed(mojom::ArcSignInFailureReason reason) {
-  OnSignInFailedInternal(
+  OnProvisioningFinished(
       ConvertArcSignInFailureReasonToProvisioningResult(reason));
 }
 
-void ArcAuthService::OnSignInFailedInternal(ProvisioningResult result) {
+void ArcAuthService::OnProvisioningFinished(ProvisioningResult result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
 
-  if (!sign_in_time_.is_null()) {
+  if (result == ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR) {
+    // For backwards compatibility, use NETWORK_ERROR for
+    // CHROME_SERVER_COMMUNICATION_ERROR case.
+    UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
+  } else if (!sign_in_time_.is_null()) {
     arc_sign_in_timer_.Stop();
 
-    UpdateProvisioningTiming(base::Time::Now() - sign_in_time_, false,
+    UpdateProvisioningTiming(base::Time::Now() - sign_in_time_,
+                             result == ProvisioningResult::SUCCESS,
                              policy_util::IsAccountManaged(profile_));
-    UpdateOptInCancelUMA(OptInCancelReason::CLOUD_PROVISION_FLOW_FAIL);
     UpdateProvisioningResultUMA(result,
                                 policy_util::IsAccountManaged(profile_));
+    if (result != ProvisioningResult::SUCCESS)
+      UpdateOptInCancelUMA(OptInCancelReason::CLOUD_PROVISION_FLOW_FAIL);
+  }
+
+  if (result == ProvisioningResult::SUCCESS) {
+    if (support_host_)
+      support_host_->Close();
+
+    if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn))
+      return;
+
+    profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, true);
+    if (!IsOptInVerificationDisabled()) {
+      playstore_launcher_.reset(
+          new ArcAppLauncher(profile_, kPlayStoreAppId, true));
+    }
+
+    for (auto& observer : observer_list_)
+      observer.OnInitialStart();
+    return;
   }
 
   ArcSupportHost::Error error;
   switch (result) {
     case ProvisioningResult::GMS_NETWORK_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_NETWORK_ERROR;
       break;
     case ProvisioningResult::GMS_SERVICE_UNAVAILABLE:
     case ProvisioningResult::GMS_SIGN_IN_FAILED:
     case ProvisioningResult::GMS_SIGN_IN_TIMEOUT:
     case ProvisioningResult::GMS_SIGN_IN_INTERNAL_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_SERVICE_UNAVAILABLE_ERROR;
       break;
     case ProvisioningResult::GMS_BAD_AUTHENTICATION:
       error = ArcSupportHost::Error::SIGN_IN_BAD_AUTHENTICATION_ERROR;
       break;
     case ProvisioningResult::DEVICE_CHECK_IN_FAILED:
     case ProvisioningResult::DEVICE_CHECK_IN_TIMEOUT:
     case ProvisioningResult::DEVICE_CHECK_IN_INTERNAL_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_GMS_NOT_AVAILABLE_ERROR;
       break;
     case ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED:
     case ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT:
     case ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_CLOUD_PROVISION_FLOW_FAIL_ERROR;
       break;
+    case ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR:
+      error = ArcSupportHost::Error::SERVER_COMMUNICATION_ERROR;
+      break;
     default:
       error = ArcSupportHost::Error::SIGN_IN_UNKNOWN_ERROR;
       break;
   }
 
-  if (result == ProvisioningResult::ARC_STOPPED) {
+  if (result == ProvisioningResult::ARC_STOPPED ||
+      result == ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR) {
     if (profile_->GetPrefs()->HasPrefPath(prefs::kArcSignedIn))
       profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
     ShutdownBridge();
     if (support_host_)
       support_host_->ShowError(error, false);
     return;
   }
 
   if (result == ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT ||
@@ skipping 260 matching lines @@
   DCHECK(!auth_code.empty());
 
   account_info_notifier_->Notify(!IsOptInVerificationDisabled(), auth_code,
                                  GetAccountType(),
                                  policy_util::IsAccountManaged(profile_));
   account_info_notifier_.reset();
 }
 
 void ArcAuthService::OnArcSignInTimeout() {
   LOG(ERROR) << "Timed out waiting for first sign in.";
-  OnSignInFailedInternal(ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT);
+  OnProvisioningFinished(ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT);
 }
 
 void ArcAuthService::CancelAuthCode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (state_ == State::NOT_INITIALIZED) {
     NOTREACHED();
     return;
   }
 
@@ skipping 75 matching lines @@
     }
     return;
   }
 
   SetState(State::SHOWING_TERMS_OF_SERVICE);
   if (support_host_)
     support_host_->ShowTermsOfService();
 }
 
 void ArcAuthService::OnPrepareContextFailed() {
-  ShutdownBridge();
-  if (support_host_) {
-    support_host_->ShowError(ArcSupportHost::Error::SERVER_COMMUNICATION_ERROR,
-                             false);
-  }
-  UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  OnProvisioningFinished(ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
 }
 
 void ArcAuthService::OnAuthCodeSuccess(const std::string& auth_code) {
   OnAuthCodeObtained(auth_code);
 }
 
 void ArcAuthService::OnAuthCodeFailed() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  ShutdownBridge();
-  if (support_host_) {
-    support_host_->ShowError(ArcSupportHost::Error::SERVER_COMMUNICATION_ERROR,
-                             false);
-  }
-  UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
+  OnProvisioningFinished(ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
 }
 
 void ArcAuthService::StartArcAndroidManagementCheck() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(arc_bridge_service()->stopped());
   DCHECK(state_ == State::SHOWING_TERMS_OF_SERVICE ||
          state_ == State::CHECKING_ANDROID_MANAGEMENT);
   SetState(State::CHECKING_ANDROID_MANAGEMENT);
 
   android_management_checker_.reset(new ArcAndroidManagementChecker(
@@ skipping 176 matching lines @@
       return os << "ACTIVE";
   }
 
   // Some compiler reports an error even if all values of an enum-class are
   // covered indivisually in a switch statement.
   NOTREACHED();
   return os;
 }
 
 }  // namespace arc