UMA metrics added for HID detection dialog.

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

 // Copyright 2014 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/hid_detection_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/metrics/histogram.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
+#include "chrome/common/pref_names.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 const char kJsScreenPath[] = "login.HIDDetectionScreen";
 
 // Variants of pairing state.
@@ skipping 36 matching lines @@
 
 namespace chromeos {
 
 HIDDetectionScreenHandler::HIDDetectionScreenHandler()
     : BaseScreenHandler(kJsScreenPath),
       delegate_(NULL),
       show_on_init_(false),
       mouse_is_pairing_(false),
       keyboard_is_pairing_(false),
       switch_on_adapter_when_ready_(false),
-      skip_screen_if_devices_present_(true),
+      first_time_screen_show_(true),
       weak_ptr_factory_(this) {
 }
 
 HIDDetectionScreenHandler::~HIDDetectionScreenHandler() {
   if (adapter_.get())
     adapter_->RemoveObserver(this);
   input_service_proxy_.RemoveObserver(this);
   if (delegate_)
     delegate_->OnActorDestroyed(this);
 }
@@ skipping 12 matching lines @@
 void HIDDetectionScreenHandler::FindDevicesError() {
   VLOG(1) << "Failed to start Bluetooth discovery.";
 }
 
 void HIDDetectionScreenHandler::Show() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
   input_service_proxy_.AddObserver(this);
-  skip_screen_if_devices_present_ = true;
-  UpdateDevices();
+  first_time_screen_show_ = true;
+  GetDevicesFirstTime();
   ShowScreen(OobeUI::kScreenHIDDetection, NULL);
 }
 
 void HIDDetectionScreenHandler::Hide() {
   if (adapter_.get())
     adapter_->RemoveObserver(this);
   input_service_proxy_.RemoveObserver(this);
 }
 
 void HIDDetectionScreenHandler::SetDelegate(Delegate* delegate) {
@@ skipping 33 matching lines @@
     show_on_init_ = false;
   }
 }
 
 void HIDDetectionScreenHandler::RegisterMessages() {
   AddCallback(
       "HIDDetectionOnContinue", &HIDDetectionScreenHandler::HandleOnContinue);
 }
 
 void HIDDetectionScreenHandler::HandleOnContinue() {
+  if (!first_time_screen_show_) {
+    // Continue button pressed.
+    ContinueScenarioType scenario_type;
+    if (!pointing_device_id_.empty() && !keyboard_device_id_.empty())
+      scenario_type = All_DEVICES_DETECTED;
+    else if (pointing_device_id_.empty())
+      scenario_type = KEYBOARD_DEVICE_ONLY_DETECTED;
+    else
+      scenario_type = POINTING_DEVICE_ONLY_DETECTED;
+
+    UMA_HISTOGRAM_ENUMERATION(
+        "HIDDetection.OOBEDevicesDetectedOnContinuePressed",
+        scenario_type,
+        CONTINUE_SCENARIO_TYPE_SIZE);
+  }
   if (delegate_)
     delegate_->OnExit();
 }
 
 void HIDDetectionScreenHandler::InitializeAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   adapter_ = adapter;
   CHECK(adapter_.get());
 
   adapter_->AddObserver(this);
@@ skipping 155 matching lines @@
     UpdateDevices();
   } else if (id == pointing_device_id_) {
     pointing_device_id_.clear();
     pointing_device_name_.clear();
     pointing_device_connect_type_ = InputDeviceInfo::TYPE_UNKNOWN;
     SendPointingDeviceNotification();
     UpdateDevices();
   }
 }
 
+// static
+void HIDDetectionScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterIntegerPref(prefs::kTimesHIDDialogShown, 0);
+}
+
+void HIDDetectionScreenHandler::GetDevicesFirstTime() {
+  input_service_proxy_.GetDevices(
+      base::Bind(&HIDDetectionScreenHandler::OnGetInputDevicesListFirstTime,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void HIDDetectionScreenHandler::UpdateDevices() {
   input_service_proxy_.GetDevices(
       base::Bind(&HIDDetectionScreenHandler::OnGetInputDevicesList,
-                 base::Unretained(this)));
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void HIDDetectionScreenHandler::UpdateBTDevices() {
   if (!adapter_ || !adapter_->IsPresent() || !adapter_->IsPowered())
     return;
 
   // If no connected devices found as pointing device and keyboard, we try to
   // connect some type-suitable active bluetooth device.
   std::vector<device::BluetoothDevice*> bt_devices = adapter_->GetDevices();
   for (std::vector<device::BluetoothDevice*>::const_iterator it =
            bt_devices.begin();
        it != bt_devices.end() &&
            (keyboard_device_id_.empty() || pointing_device_id_.empty());
        ++it) {
     TryPairingAsPointingDevice(*it);
     TryPairingAsKeyboardDevice(*it);
   }
 }
 
-void HIDDetectionScreenHandler::OnGetInputDevicesList(
+void HIDDetectionScreenHandler::ProcessConnectedDevicesList(
     const std::vector<InputDeviceInfo>& devices) {
   for (std::vector<InputDeviceInfo>::const_iterator it = devices.begin();
        it != devices.end() &&
        (pointing_device_id_.empty() || keyboard_device_id_.empty());
        ++it) {
     if (pointing_device_id_.empty() && DeviceIsPointing(*it)) {
       pointing_device_id_ = it->id;
       pointing_device_name_ = it->name;
       pointing_device_connect_type_ = it->type;
       SendPointingDeviceNotification();
     }
     if (keyboard_device_id_.empty() && it->is_keyboard) {
       keyboard_device_id_ = it->id;
       keyboard_device_name_ = it->name;
       keyboard_device_connect_type_ = it->type;
       SendKeyboardDeviceNotification(NULL);
     }
   }
-  // Skip screen if both devices are present and skip was requested.
-  if (!pointing_device_id_.empty() &&
-      !keyboard_device_id_.empty() &&
-      skip_screen_if_devices_present_) {
-    HandleOnContinue();
-  }
-  // Skip requested only once on dialog show.
-  skip_screen_if_devices_present_ = false;
+}
+
+void HIDDetectionScreenHandler::TryInitiateBTDevicesUpdate() {
   if ((pointing_device_id_.empty() || keyboard_device_id_.empty()) &&
       adapter_) {
     if (!adapter_->IsPresent()) {
       // Switch on BT adapter later when it's available.
       switch_on_adapter_when_ready_ = true;
     } else if (!adapter_->IsPowered()) {
       adapter_->SetPowered(
           true,
           base::Bind(&HIDDetectionScreenHandler::StartBTDiscoverySession,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&HIDDetectionScreenHandler::SetPoweredError,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       UpdateBTDevices();
     }
   }
 }
 
+void HIDDetectionScreenHandler::OnGetInputDevicesListFirstTime(
+    const std::vector<InputDeviceInfo>& devices) {
+  ProcessConnectedDevicesList(devices);
+
+  // Skip screen if both devices are present.
+  bool all_devices_autodetected = !pointing_device_id_.empty() &&
+                                  !keyboard_device_id_.empty();
+  UMA_HISTOGRAM_BOOLEAN("HIDDetection.OOBEDialogShown",
+                        !all_devices_autodetected);
+  if (all_devices_autodetected) {
+    HandleOnContinue();
+    return;
+  }
+  PrefService* local_state = g_browser_process->local_state();
+  int num_of_times_dialog_was_shown = local_state->GetInteger(
+      prefs::kTimesHIDDialogShown);
+  local_state->SetInteger(prefs::kTimesHIDDialogShown,
+                          num_of_times_dialog_was_shown + 1);
+  first_time_screen_show_ = false;
+
+  TryInitiateBTDevicesUpdate();
+}
+
+void HIDDetectionScreenHandler::OnGetInputDevicesList(
+    const std::vector<InputDeviceInfo>& devices) {
+  ProcessConnectedDevicesList(devices);
+  TryInitiateBTDevicesUpdate();
+}
+
 void HIDDetectionScreenHandler::ConnectBTDevice(
     device::BluetoothDevice* device) {
   if (!device->IsPairable() || device->IsPaired())
     return;
   device::BluetoothDevice::DeviceType device_type = device->GetDeviceType();
 
   if (device_type == device::BluetoothDevice::DEVICE_MOUSE ||
       device_type == device::BluetoothDevice::DEVICE_TABLET) {
     if (mouse_is_pairing_)
       return;
@@ skipping 81 matching lines @@
         l10n_util::GetStringFUTF16(
             IDS_HID_DETECTION_PAIRED_BLUETOOTH_KEYBOARD,
             base::UTF8ToUTF16(keyboard_device_name_)));
   } else {
     state_info.SetString("state", kUSBConnectedState);
   }
   CallJS("setKeyboardDeviceState", state_info);
 }
 
 }  // namespace chromeos