[Merge M58] 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 48 matching lines @@
 // 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);
 
 }  // 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 171 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
@@ skipping 158 matching lines @@
   }
 
   // If it is marked that the Terms of service is accepted already,
   // just skip the negotiation with user, and start Android management
   // check directly.
   // This happens, e.g., when;
   // 1) User accepted the Terms of service on OOBE flow.
   // 2) User accepted the Terms of service on Opt-in flow, but logged out
   //   before ARC sign in procedure was done. Then, logs in again.
   if (prefs->GetBoolean(prefs::kArcTermsAccepted)) {
+    if (!scoped_opt_in_tracker_ &&
+        !profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
+      scoped_opt_in_tracker_ = base::MakeUnique<ScopedOptInFlowTracker>();
+    }
+
     // Don't show UI for this progress if it was not shown.
     if (support_host_ &&
         support_host_->ui_page() != ArcSupportHost::UIPage::NO_PAGE) {
       support_host_->ShowArcLoading();
     }
     StartArcAndroidManagementCheck();
     return;
   }
 
   StartTermsOfServiceNegotiation();
 }
 
 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.
   VLOG(1) << "ARC opt-out. Removing user data.";
   reenable_arc_ = false;
   StopArc();
   RemoveArcData();
 }
 
 void ArcSessionManager::StartTermsOfServiceNegotiation() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!terms_of_service_negotiator_);
 
   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;
   }
 
   SetState(State::SHOWING_TERMS_OF_SERVICE);
+
+  if (!scoped_opt_in_tracker_ &&
+      !profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
+    scoped_opt_in_tracker_ = base::MakeUnique<ScopedOptInFlowTracker>();
+  }
+
   if (IsOobeOptInActive()) {
     VLOG(1) << "Use OOBE negotiator.";
     terms_of_service_negotiator_ =
         base::MakeUnique<ArcTermsOfServiceOobeNegotiator>();
   } else if (support_host_) {
     VLOG(1) << "Use default negotiator.";
     terms_of_service_negotiator_ =
         base::MakeUnique<ArcTermsOfServiceDefaultNegotiator>(
             profile_->GetPrefs(), support_host_.get());
   }
@@ skipping 214 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