arc: Provide UMA for OptIn flow.

chrome/browser/chromeos/arc/arc_session_manager.cc

 // Copyright 2016 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_session_manager.h"
 
 #include <utility>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
@@ skipping 193 matching lines @@
     // We don't expect ProvisioningResult::SUCCESS is reported twice or reported
     // after an error.
     DCHECK_NE(result, ProvisioningResult::SUCCESS);
     // TODO(khmel): Consider changing LOG to NOTREACHED once we guaranty that
     // no double message can happen in production.
     LOG(WARNING) << "Provisioning result was already reported. Ignoring "
                  << "additional result " << static_cast<int>(result) << ".";
     return;
   }
   provisioning_reported_ = true;
+  optin_flow_error_detected_ |= (result != ProvisioningResult::SUCCESS);
 
   if (result == ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR) {
     if (IsArcKioskMode()) {
       VLOG(1) << "Robot account auth code fetching error";
       // Log out the user. All the cleanup will be done in Shutdown() method.
       // The callback is not called because auth code is empty.
       attempt_user_exit_callback_.Run();
       return;
     }
 
     // For backwards compatibility, use NETWORK_ERROR for
     // CHROME_SERVER_COMMUNICATION_ERROR case.
     UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
   } else if (!sign_in_start_time_.is_null()) {
     arc_sign_in_timer_.Stop();
 
     UpdateProvisioningTiming(base::Time::Now() - sign_in_start_time_,
                              result == ProvisioningResult::SUCCESS,
                              policy_util::IsAccountManaged(profile_));
     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();
 
+    StopOptInFlowTracking(true);
+
     if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn))
       return;
 
     profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, true);
 
     // Launch Play Store app, except for the following cases:
     // * When Opt-in verification is disabled (for tests);
     // * In ARC Kiosk mode, because the only one UI in kiosk mode must be the
     //   kiosk app and device is not needed for opt-in;
     // * When ARC is managed and all OptIn preferences are managed too, because
@@ skipping 288 matching lines @@
 
 void ArcSessionManager::RequestDisable() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   if (!enable_requested_) {
     VLOG(1) << "ARC is already disabled. Do nothing.";
     return;
   }
   enable_requested_ = false;
+  StopOptInFlowTracking(false);
 
   // Reset any pending request to re-enable ARC.
   reenable_arc_ = false;
   StopArc();
   VLOG(1) << "ARC opt-out. Removing user data.";
   RequestArcDataRemoval();
 }
 
 void ArcSessionManager::RequestArcDataRemoval() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 34 matching lines @@
 
   // TODO(hidehiko): Remove this condition, when the state machine is fixed.
   if (!arc_session_runner_->IsStopped()) {
     // If the user attempts to re-enable ARC while the ARC instance is still
     // running the user should not be able to continue until the ARC instance
     // has stopped.
     if (support_host_) {
       support_host_->ShowError(
           ArcSupportHost::Error::SIGN_IN_SERVICE_UNAVAILABLE_ERROR, false);
     }
+    UpdateOptInCancelUMA(OptInCancelReason::SESSION_BUSY);

[khmel, 2017/03/29 21:41:09]

We never recorded this issue. It would be nice to have this stats as well

     return;
   }
 
   // TODO(hidehiko): DCHECK if |state_| is STOPPED, when the state machine
   // is fixed.
   SetState(State::NEGOTIATING_TERMS_OF_SERVICE);
 
+  StartOptInFlowTracking();
+
   if (!IsArcTermsOfServiceNegotiationNeeded()) {
     // Moves to next state, Android management check, immediately, as if
     // Terms of Service negotiation is done successfully.
     StartAndroidManagementCheck();
     return;
   }
 
   if (IsOobeOptInActive()) {
     VLOG(1) << "Use OOBE negotiator.";
     terms_of_service_negotiator_ =
@@ skipping 327 matching lines @@
   arc_session_runner_ = std::move(arc_session_runner);
   arc_session_runner_->AddObserver(this);
 }
 
 void ArcSessionManager::SetAttemptUserExitCallbackForTesting(
     const base::Closure& callback) {
   DCHECK(!callback.is_null());
   attempt_user_exit_callback_ = callback;
 }
 
+void ArcSessionManager::StartOptInFlowTracking() {
+  // Test if we already started OptIn flow tracking.
+  if (optin_flow_tracked_)
+    return;
+
+  if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
+    VLOG(1) << "Skip tracking opt-in flow for already signed ARC";
+    return;
+  }
+
+  UpdateOptInFlowResultUMA(OptInFlowResult::STARTED);
+  optin_flow_tracked_ = true;
+  optin_flow_error_detected_ = false;
+}
+
+void ArcSessionManager::StopOptInFlowTracking(bool succeeded) {
+  if (!optin_flow_tracked_)
+    return;
+
+  UpdateOptInFlowResultUMA(succeeded ? OptInFlowResult::SUCCEEDED
+                                     : OptInFlowResult::CANCELED);
+  if (optin_flow_error_detected_) {
+    UpdateOptInFlowResultUMA(succeeded ? OptInFlowResult::SUCCEEDED_AFTER_RETRY
+                                       : OptInFlowResult::CANCELED_AFTER_ERROR);
+  }
+
+  optin_flow_tracked_ = false;
+}
+
 std::ostream& operator<<(std::ostream& os,
                          const ArcSessionManager::State& state) {
 #define MAP_STATE(name)                \
   case ArcSessionManager::State::name: \
     return os << #name
 
   switch (state) {
     MAP_STATE(NOT_INITIALIZED);
     MAP_STATE(STOPPED);
     MAP_STATE(NEGOTIATING_TERMS_OF_SERVICE);
     MAP_STATE(CHECKING_ANDROID_MANAGEMENT);
     MAP_STATE(REMOVING_DATA_DIR);
     MAP_STATE(ACTIVE);
   }
 
 #undef MAP_STATE
 
   // Some compilers report an error even if all values of an enum-class are
   // covered exhaustively in a switch statement.
   NOTREACHED() << "Invalid value " << static_cast<int>(state);
   return os;
 }
 
 }  // namespace arc