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/metrics/user_metrics.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";
 
-// 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_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 {

[fukino, 2017/05/31 12:21:28]

MigrationResult and RemoveCryptohomeResult have the same set of potential
results.
However, this may differ when we get more information about the result of each
operation, so I prepared enums separately.

+  SUCCESS_IN_NEW_MIGRATION = 0,
+  SUCCESS_IN_RESUMED_MIGRATION = 1,
+  FAILURE_IN_NEW_MIGRATION = 2,
+  FAILURE_IN_RESUMED_MIGRATION = 3,
+  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));
 }
 
 void RecordUserChoice(UserChoice user_choice) {
   UMA_HISTOGRAM_ENUMERATION(kUmaNameUserChoice, static_cast<int>(user_choice),
                             static_cast<int>(UserChoice::USER_CHOICE_COUNT));
 }
 
+void RecordMigrationResult(bool success, bool is_resumed_migration) {
+  MigrationResult result =
+      success ? (is_resumed_migration
+                     ? MigrationResult::SUCCESS_IN_RESUMED_MIGRATION
+                     : MigrationResult::SUCCESS_IN_NEW_MIGRATION)
+              : (is_resumed_migration
+                     ? MigrationResult::FAILURE_IN_RESUMED_MIGRATION
+                     : MigrationResult::FAILURE_IN_NEW_MIGRATION);
+  UMA_HISTOGRAM_ENUMERATION(kUmaNameMigrationResult, static_cast<int>(result),
+                            static_cast<int>(MigrationResult::COUNT));

[Ilya Sherman, 2017/05/31 23:34:44]

nit: static_casts shouldn't be needed anymore when using enum classes with
UMA_HISTOGRAM_ENUMERATION macros.

[fukino, 2017/06/01 09:28:38]

Done.

+}
+
+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,
+                            static_cast<int>(result),
+                            static_cast<int>(RemoveCryptohomeResult::COUNT));
+}
+
+void RecordShowFailureScreen() {
+  base::RecordAction(
+      base::UserMetricsAction("Cryptohome.MigrationUI.ShowFailureScreen"));
+}
+
 }  // namespace
 
 namespace chromeos {
 
 EncryptionMigrationScreenHandler::EncryptionMigrationScreenHandler()
     : BaseScreenHandler(kScreenId), weak_ptr_factory_(this) {
   set_call_js_prefix(kJsScreenPath);
 }
 
 EncryptionMigrationScreenHandler::~EncryptionMigrationScreenHandler() {
@@ skipping 96 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 36 matching lines @@
   if (!continue_login_callback_.is_null()) {
     user_context_.SetIsForcingDircrypto(false);
     std::move(continue_login_callback_).Run(user_context_);
   }
 }
 
 void EncryptionMigrationScreenHandler::HandleRequestRestart() {
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
+void EncryptionMigrationScreenHandler::HandleRequestRestartOnFailure() {
+  base::RecordAction(base::UserMetricsAction(
+      "Cryptohome.MigrationUI.RestartClickedOnFailure"));
+  DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
+}
+
 void EncryptionMigrationScreenHandler::HandleOpenFeedbackDialog() {
   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) {
@@ skipping 117 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(true, should_resume_);
       // 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(false, should_resume_);
+      // Record an event that the user sees the failure screen.
+      // We record it after delay to make sure that the user was actually able
+      // to see the failure screen. There is a potential race condition where
+      // the user can see only flash of failure screen on shutting down.
+      // crbug.com/727980.
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE, base::BindOnce(&RecordShowFailureScreen),
+          base::TimeDelta::FromSeconds(1));
       // 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.";
     UpdateUIState(UIState::MIGRATION_FAILED);
   }
 }
 
 }  // namespace chromeos