cros: Add UMA metrics in migration UI to get more information from migration failures.

chrome/browser/ui/webui/chromeos/login/encryption_migration_screen_handler.cc

 // Copyright 2017 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/ui/webui/chromeos/login/encryption_migration_screen_handler.h"
 
 #include <cmath>
 #include <string>
 #include <utility>
 
 #include "ash/system/devicetype_utils.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/arc/arc_migration_constants.h"
 #include "chrome/browser/chromeos/login/ui/login_feedback.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/dbus/cryptohome_client.h"
@@ skipping 10 matching lines @@
 
 constexpr char kJsScreenPath[] = "login.EncryptionMigrationScreen";
 
 // Path to the mount point to check the available space.
 constexpr char kCheckStoragePath[] = "/home";
 
 // JS API callbacks names.
 constexpr char kJsApiStartMigration[] = "startMigration";
 constexpr char kJsApiSkipMigration[] = "skipMigration";
 constexpr char kJsApiRequestRestart[] = "requestRestart";
+constexpr char kJsApiRequestRestartOnFailure[] = "requestRestartOnFailure";
 constexpr char kJsApiOpenFeedbackDialog[] = "openFeedbackDialog";
 
 // UMA names.
 constexpr char kUmaNameFirstScreen[] = "Cryptohome.MigrationUI.FirstScreen";
 constexpr char kUmaNameUserChoice[] = "Cryptohome.MigrationUI.UserChoice";
+constexpr char kUmaNameMigrationResult[] =
+    "Cryptohome.MigrationUI.MigrationResult";
+constexpr char kUmaNameRemoveCryptohomeResult[] =
+    "Cryptohome.MigrationUI.RemoveCryptohomeResult";
 constexpr char kUmaNameConsumedBatteryPercent[] =
     "Cryptohome.MigrationUI.ConsumedBatteryPercent";
+constexpr char kUmaNameVisibleScreen[] = "Cryptohome.MigrationUI.VisibleScreen";
 
-// This enum must match the numbering for Cryptohome.MigrationUI.FirstScreen in
-// histograms.xml. Do not reorder or remove items, only add new items before
-// FIRST_SCREEN_MAX.
+// This enum must match the numbering for MigrationUIFirstScreen in
+// histograms/enums.xml. Do not reorder or remove items, only add new items
+// before FIRST_SCREEN_COUNT.
 enum class FirstScreen {
   FIRST_SCREEN_READY = 0,
   FIRST_SCREEN_RESUME = 1,
   FIRST_SCREEN_LOW_STORAGE = 2,
   FIRST_SCREEN_COUNT
 };
 
-// This enum must match the numbering for Cryptohome.MigrationUI.UserChoice in
-// histograms.xml. Do not reorder or remove items, only add new items before
-// FIRST_SCREEN_MAX.
+// This enum must match the numbering for MigrationUIUserChoice in
+// histograms/enums.xml. Do not reorder or remove items, only add new items
+// before USER_CHOICE_COUNT.
 enum class UserChoice {
   USER_CHOICE_UPDATE = 0,
   USER_CHOICE_SKIP = 1,
+  USER_CHOICE_RESTART_ON_FAILURE = 2,
+  USER_CHOICE_RESTART_ON_LOW_STORAGE = 3,
+  USER_CHOICE_REPORT_AN_ISSUE = 4,
   USER_CHOICE_COUNT
 };
 
+// This enum must match the numbering for MigrationUIMigrationResult in
+// histograms/enums.xml. Do not reorder or remove items, only add new items
+// before COUNT.
+enum class MigrationResult {
+  SUCCESS_IN_NEW_MIGRATION = 0,
+  SUCCESS_IN_RESUMED_MIGRATION = 1,
+  GENERAL_FAILURE_IN_NEW_MIGRATION = 2,
+  GENERAL_FAILURE_IN_RESUMED_MIGRATION = 3,
+  REQUEST_FAILURE_IN_NEW_MIGRATION = 4,
+  REQUEST_FAILURE_IN_RESUMED_MIGRATION = 5,
+  MOUNT_FAILURE_IN_NEW_MIGRATION = 6,
+  MOUNT_FAILURE_IN_RESUMED_MIGRATION = 7,
+  COUNT
+};
+
+// This enum must match the numbering for MigrationUIRemoveCryptohomeResult in
+// histograms/enums.xml. Do not reorder or remove items, only add new items
+// before COUNT.
+enum class RemoveCryptohomeResult {
+  SUCCESS_IN_NEW_MIGRATION = 0,
+  SUCCESS_IN_RESUMED_MIGRATION = 1,
+  FAILURE_IN_NEW_MIGRATION = 2,
+  FAILURE_IN_RESUMED_MIGRATION = 3,
+  COUNT
+};
+
 bool IsTestingUI() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kTestEncryptionMigrationUI);
 }
 
 // Wrapper functions for histogram macros to avoid duplication of expanded code.
 void RecordFirstScreen(FirstScreen first_screen) {
-  UMA_HISTOGRAM_ENUMERATION(kUmaNameFirstScreen, static_cast<int>(first_screen),
-                            static_cast<int>(FirstScreen::FIRST_SCREEN_COUNT));
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameFirstScreen, first_screen,
+                            FirstScreen::FIRST_SCREEN_COUNT);
 }
 
 void RecordUserChoice(UserChoice user_choice) {
-  UMA_HISTOGRAM_ENUMERATION(kUmaNameUserChoice, static_cast<int>(user_choice),
-                            static_cast<int>(UserChoice::USER_CHOICE_COUNT));
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameUserChoice, user_choice,
+                            UserChoice::USER_CHOICE_COUNT);
+}
+
+void RecordMigrationResult(MigrationResult migration_result) {
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameMigrationResult, migration_result,
+                            MigrationResult::COUNT);
+}
+
+void RecordRemoveCryptohomeResult(bool success, bool is_resumed_migration) {
+  RemoveCryptohomeResult result =
+      success ? (is_resumed_migration
+                     ? RemoveCryptohomeResult::SUCCESS_IN_RESUMED_MIGRATION
+                     : RemoveCryptohomeResult::SUCCESS_IN_NEW_MIGRATION)
+              : (is_resumed_migration
+                     ? RemoveCryptohomeResult::FAILURE_IN_RESUMED_MIGRATION
+                     : RemoveCryptohomeResult::FAILURE_IN_NEW_MIGRATION);
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameRemoveCryptohomeResult, result,
+                            RemoveCryptohomeResult::COUNT);
 }
 
 }  // namespace
 
 namespace chromeos {
 
 EncryptionMigrationScreenHandler::EncryptionMigrationScreenHandler()
     : BaseScreenHandler(kScreenId), weak_ptr_factory_(this) {
   set_call_js_prefix(kJsScreenPath);
 }
@@ skipping 98 matching lines @@
   }
 }
 
 void EncryptionMigrationScreenHandler::RegisterMessages() {
   AddCallback(kJsApiStartMigration,
               &EncryptionMigrationScreenHandler::HandleStartMigration);
   AddCallback(kJsApiSkipMigration,
               &EncryptionMigrationScreenHandler::HandleSkipMigration);
   AddCallback(kJsApiRequestRestart,
               &EncryptionMigrationScreenHandler::HandleRequestRestart);
+  AddCallback(kJsApiRequestRestartOnFailure,
+              &EncryptionMigrationScreenHandler::HandleRequestRestartOnFailure);
   AddCallback(kJsApiOpenFeedbackDialog,
               &EncryptionMigrationScreenHandler::HandleOpenFeedbackDialog);
 }
 
 void EncryptionMigrationScreenHandler::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   if (proto.has_battery_percent()) {
     if (!current_battery_percent_) {
       // If initial battery level is below the minimum, migration should start
       // automatically once the device is charged enough.
@@ skipping 33 matching lines @@
   // previous attempt and dropping |is_forcing_dircrypto| flag in UserContext.
   // In this case, the user can not launch ARC apps in the session, and will be
   // asked to do the migration again in the next log-in attempt.
   if (!continue_login_callback_.is_null()) {
     user_context_.SetIsForcingDircrypto(false);
     std::move(continue_login_callback_).Run(user_context_);
   }
 }
 
 void EncryptionMigrationScreenHandler::HandleRequestRestart() {
+  RecordUserChoice(UserChoice::USER_CHOICE_RESTART_ON_LOW_STORAGE);
+  DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
+}
+
+void EncryptionMigrationScreenHandler::HandleRequestRestartOnFailure() {
+  RecordUserChoice(UserChoice::USER_CHOICE_RESTART_ON_FAILURE);
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 void EncryptionMigrationScreenHandler::HandleOpenFeedbackDialog() {
+  RecordUserChoice(UserChoice::USER_CHOICE_REPORT_AN_ISSUE);
   const std::string description = base::StringPrintf(
       "Auto generated feedback for http://crbug.com/719266.\n"
       "(uniquifier:%s)",
       base::Int64ToString(base::Time::Now().ToInternalValue()).c_str());
   login_feedback_.reset(new LoginFeedback(Profile::FromWebUI(web_ui())));
   login_feedback_->Request(description, base::Closure());
 }
 
 void EncryptionMigrationScreenHandler::UpdateUIState(UIState state) {
   if (state == current_ui_state_)
     return;
 
   current_ui_state_ = state;
   CallJS("setUIState", static_cast<int>(state));
 
   // When this handler is about to show the READY screen, we should get the
   // latest battery status and show it on the screen.
   if (state == UIState::READY)
     DBusThreadManager::Get()->GetPowerManagerClient()->RequestStatusUpdate();
 
   // We should block power save during migration.
   if (state == UIState::MIGRATING)
     StartBlockingPowerSave();
   else
     StopBlockingPowerSave();
+
+  // Record which screen is visible to the user.
+  // We record it after delay to make sure that the user was actually able
+  // to see the screen (i.e. the screen is not just a flash).
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(
+          &EncryptionMigrationScreenHandler::OnDelayedRecordVisibleScreen,
+          weak_ptr_factory_.GetWeakPtr(), state),
+      base::TimeDelta::FromSeconds(1));
 }
 
 void EncryptionMigrationScreenHandler::CheckAvailableStorage() {
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
       base::Bind(&base::SysInfo::AmountOfFreeDiskSpace,
                  base::FilePath(kCheckStoragePath)),
       base::Bind(&EncryptionMigrationScreenHandler::OnGetAvailableStorage,
                  weak_ptr_factory_.GetWeakPtr()));
 }
@@ skipping 40 matching lines @@
       cryptohome::Authorization(GetAuthKey()), mount,
       base::Bind(&EncryptionMigrationScreenHandler::OnMountExistingVault,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EncryptionMigrationScreenHandler::OnMountExistingVault(
     bool success,
     cryptohome::MountError return_code,
     const std::string& mount_hash) {
   if (!success || return_code != cryptohome::MOUNT_ERROR_NONE) {
+    RecordMigrationResult(
+        should_resume_ ? MigrationResult::MOUNT_FAILURE_IN_RESUMED_MIGRATION
+                       : MigrationResult::MOUNT_FAILURE_IN_NEW_MIGRATION);
     UpdateUIState(UIState::MIGRATION_FAILED);
     return;
   }
 
   DBusThreadManager::Get()
       ->GetCryptohomeClient()
       ->SetDircryptoMigrationProgressHandler(
           base::Bind(&EncryptionMigrationScreenHandler::OnMigrationProgress,
                      weak_ptr_factory_.GetWeakPtr()));
   cryptohome::HomedirMethods::GetInstance()->MigrateToDircrypto(
@@ skipping 31 matching lines @@
       cryptohome::Identification(user_context_.GetAccountId()),
       base::Bind(&EncryptionMigrationScreenHandler::OnRemoveCryptohome,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EncryptionMigrationScreenHandler::OnRemoveCryptohome(
     bool success,
     cryptohome::MountError return_code) {
   LOG_IF(ERROR, !success) << "Removing cryptohome failed. return code: "
                           << return_code;
+  RecordRemoveCryptohomeResult(success, should_resume_);
   UpdateUIState(UIState::MIGRATION_FAILED);
 }
 
 cryptohome::KeyDefinition EncryptionMigrationScreenHandler::GetAuthKey() {
   // |auth_key| is created in the same manner as CryptohomeAuthenticator.
   const Key* key = user_context_.GetKey();
   // If the |key| is a plain text password, crash rather than attempting to
   // mount the cryptohome with a plain text password.
   CHECK_NE(Key::KEY_TYPE_PASSWORD_PLAIN, key->GetKeyType());
   // Set the authentication's key label to an empty string, which is a wildcard
@@ skipping 11 matching lines @@
     uint64_t total) {
   switch (status) {
     case cryptohome::DIRCRYPTO_MIGRATION_INITIALIZING:
       UpdateUIState(UIState::MIGRATING);
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_IN_PROGRESS:
       UpdateUIState(UIState::MIGRATING);
       CallJS("setMigrationProgress", static_cast<double>(current) / total);
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_SUCCESS:
+      RecordMigrationResult(should_resume_
+                                ? MigrationResult::SUCCESS_IN_RESUMED_MIGRATION
+                                : MigrationResult::SUCCESS_IN_NEW_MIGRATION);
       // If the battery level decreased during migration, record the consumed
       // battery level.
       if (*current_battery_percent_ < initial_battery_percent_) {
         UMA_HISTOGRAM_PERCENTAGE(
             kUmaNameConsumedBatteryPercent,
             static_cast<int>(std::round(initial_battery_percent_ -
                                         *current_battery_percent_)));
       }
       // Restart immediately after successful migration.
       DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_FAILED:
+      RecordMigrationResult(
+          should_resume_ ? MigrationResult::GENERAL_FAILURE_IN_RESUMED_MIGRATION
+                         : MigrationResult::GENERAL_FAILURE_IN_NEW_MIGRATION);
       // Stop listening to the progress updates.
       DBusThreadManager::Get()
           ->GetCryptohomeClient()
           ->SetDircryptoMigrationProgressHandler(
               CryptohomeClient::DircryptoMigrationProgessHandler());
       // Shows error screen after removing user directory is completed.
       RemoveCryptohome();
       break;
     default:
       break;
   }
 }
 
 void EncryptionMigrationScreenHandler::OnMigrationRequested(bool success) {
   if (!success) {
     LOG(ERROR) << "Requesting MigrateToDircrypto failed.";
+    RecordMigrationResult(
+        should_resume_ ? MigrationResult::REQUEST_FAILURE_IN_RESUMED_MIGRATION
+                       : MigrationResult::REQUEST_FAILURE_IN_NEW_MIGRATION);
     UpdateUIState(UIState::MIGRATION_FAILED);
   }
 }
 
+void EncryptionMigrationScreenHandler::OnDelayedRecordVisibleScreen(
+    UIState ui_state) {
+  if (current_ui_state_ != ui_state)
+    return;
+
+  // If |current_ui_state_| is not changed for a second, record the current
+  // screen as a "visible" screen.
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameVisibleScreen, ui_state, UIState::COUNT);
+}
+
 }  // namespace chromeos