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 59 matching lines @@
       support_host->ui_page() == ArcSupportHost::UIPage::NO_PAGE ||
       support_host->ui_page() == ArcSupportHost::UIPage::ERROR) {
     return;
   }
 
   UpdateOptInCancelUMA(OptInCancelReason::USER_CANCEL);
 }
 
 }  // namespace
 
+// This class is used to track statuses on OptIn flow. It is created in case ARC
+// is activated, and it needs to OptIn. Once started OptInFlowResult::STARTED is
+// recorded via UMA. If it finishes successfully OptInFlowResult::SUCCEEDED is
+// recorded. Optional OptInFlowResult::SUCCEEDED_AFTER_RETRY is recorded in this
+// case if an error occurred during OptIn flow, and user pressed Retry. In case
+// the user cancels OptIn flow before it was completed then
+// OptInFlowResult::CANCELED is recorded and if an error occurred optional
+// OptInFlowResult::CANCELED_AFTER_ERROR. If a shutdown happens during the OptIn
+// nothing is recorded, except initial OptInFlowResult::STARTED.
+// OptInFlowResult::STARTED = OptInFlowResult::SUCCEEDED +
+// OptInFlowResult::CANCELED + cases happened during the shutdown.
+class ArcSessionManager::ScopedOptInFlowTracker {
+ public:
+  ScopedOptInFlowTracker() {
+    UpdateOptInFlowResultUMA(OptInFlowResult::STARTED);
+  }
+
+  ~ScopedOptInFlowTracker() {
+    if (shutdown_)
+      return;
+
+    UpdateOptInFlowResultUMA(success_ ? OptInFlowResult::SUCCEEDED
+                                      : OptInFlowResult::CANCELED);
+    if (error_) {
+      UpdateOptInFlowResultUMA(success_
+                                   ? OptInFlowResult::SUCCEEDED_AFTER_RETRY
+                                   : OptInFlowResult::CANCELED_AFTER_ERROR);
+    }
+  }
+
+  // Tracks error occurred during the OptIn flow.
+  void TrackError() {
+    DCHECK(!success_ && !shutdown_);
+    error_ = true;
+  }
+
+  // Tracks that OptIn finished successfully.
+  void TrackSuccess() {
+    DCHECK(!success_ && !shutdown_);
+    success_ = true;
+  }
+
+  // Tracks that OptIn was not completed before shutdown.
+  void TrackShutdown() {
+    DCHECK(!success_ && !shutdown_);
+    shutdown_ = true;
+  }
+
+ private:
+  bool error_ = false;
+  bool success_ = false;
+  bool shutdown_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedOptInFlowTracker);
+};
+
 ArcSessionManager::ArcSessionManager(
     std::unique_ptr<ArcSessionRunner> arc_session_runner)
     : arc_session_runner_(std::move(arc_session_runner)),
       attempt_user_exit_callback_(base::Bind(chrome::AttemptUserExit)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!g_arc_session_manager);
   g_arc_session_manager = this;
   arc_session_runner_->AddObserver(this);
 }
@@ skipping 114 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;
+  if (scoped_opt_in_tracker_ && result != ProvisioningResult::SUCCESS)
+    scoped_opt_in_tracker_->TrackError();
 
   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();
 
+    if (scoped_opt_in_tracker_) {
+      scoped_opt_in_tracker_->TrackSuccess();
+      scoped_opt_in_tracker_.reset();
+    }
+
     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 136 matching lines @@
   enable_requested_ = false;
   ShutdownSession();
   if (support_host_) {
     support_host_->Close();
     support_host_->RemoveObserver(this);
     support_host_.reset();
   }
   context_.reset();
   profile_ = nullptr;
   SetState(State::NOT_INITIALIZED);
+  if (scoped_opt_in_tracker_) {
+    scoped_opt_in_tracker_->TrackShutdown();
+    scoped_opt_in_tracker_.reset();
+  }
 }
 
 void ArcSessionManager::ShutdownSession() {
   arc_sign_in_timer_.Stop();
   playstore_launcher_.reset();
   terms_of_service_negotiator_.reset();
   android_management_checker_.reset();
   arc_session_runner_->RequestStop();
   // TODO(hidehiko): The ARC instance's stopping is asynchronous, so it might
   // still be running when we return from this function. Do not set the
@@ skipping 132 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;
+  scoped_opt_in_tracker_.reset();
 
   // 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);
     return;
   }
 
   // TODO(hidehiko): DCHECK if |state_| is STOPPED, when the state machine
   // is fixed.
   SetState(State::NEGOTIATING_TERMS_OF_SERVICE);
 
+  if (!scoped_opt_in_tracker_ &&
+      !profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
+    scoped_opt_in_tracker_ = base::MakeUnique<ScopedOptInFlowTracker>();
+  }
+
   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 351 matching lines @@
 
 #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