UMA for pin unlock success/failure.

chrome/browser/chromeos/login/lock/screen_locker.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/chromeos/login/lock/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
@@ skipping 122 matching lines @@
 
 //////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, public:
 
 ScreenLocker::ScreenLocker(const user_manager::UserList& users)
     : users_(users),
       locked_(false),
       start_time_(base::Time::Now()),
       auth_status_consumer_(NULL),
       incorrect_passwords_count_(0),
+      is_pin_attempt_(false),

[jdufault, 2016/08/12 21:57:33]

Since you're already modifying this, please move all of these initializations
(where possible) to the header. Replace the NULL with nullptr.

[sammiequon, 2016/08/16 17:29:09]

Done.

       weak_factory_(this) {
   DCHECK(!screen_locker_);
   screen_locker_ = this;
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   media::SoundsManager* manager = media::SoundsManager::Get();
   manager->Initialize(SOUND_LOCK,
                       bundle.GetRawDataResource(IDR_SOUND_LOCK_WAV));
   manager->Initialize(SOUND_UNLOCK,
                       bundle.GetRawDataResource(IDR_SOUND_UNLOCK_WAV));
@@ skipping 29 matching lines @@
 void ScreenLocker::OnAuthFailure(const AuthFailure& error) {
   content::RecordAction(UserMetricsAction("ScreenLocker_OnLoginFailure"));
   if (authentication_start_time_.is_null()) {
     LOG(ERROR) << "Start time is not set at authentication failure";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication failure: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationFailureTime", delta);
   }
 
+  if (is_pin_attempt_) {
+    UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationFailure",
+                              UnlockFailure::AUTH_FAILURE_PIN,

[jdufault, 2016/08/12 21:57:33]

Can we replace this with

UMA(..., is_pin_attempt_ ? UnlockFailure::AUTH_FAILURE_PIN :
UnlockFailure::AUTH_FAILURE_PASSWORD, ...)

[sammiequon, 2016/08/16 17:29:09]

Done.

+                              UnlockFailure::AUTH_FAILURE_COUNT);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationFailure",
+                              UnlockFailure::AUTH_FAILURE_PASSWORD,
+                              UnlockFailure::AUTH_FAILURE_COUNT);
+  }
+
   EnableInput();
   // Don't enable signout button here as we're showing
   // MessageBubble.
 
   delegate_->ShowErrorMessage(incorrect_passwords_count_++ ?
                                   IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME :
                                   IDS_LOGIN_ERROR_AUTHENTICATING,
                               HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnAuthFailure(error);
 }
 
 void ScreenLocker::OnAuthSuccess(const UserContext& user_context) {
   incorrect_passwords_count_ = 0;
   if (authentication_start_time_.is_null()) {
     if (user_context.GetAccountId().is_valid())
       LOG(ERROR) << "Start time is not set at authentication success";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication success: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationSuccessTime", delta);
   }
 
+  if (is_pin_attempt_) {
+    UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationSuccess",
+                              UnlockSuccess::AUTH_SUCCESS_PIN,
+                              UnlockSuccess::AUTH_SUCCESS_COUNT);

[jdufault, 2016/08/12 21:57:33]

See above UMA comment

[sammiequon, 2016/08/16 17:29:09]

Done.

+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationSuccess",
+                              UnlockSuccess::AUTH_SUCCESS_PASSWORD,
+                              UnlockSuccess::AUTH_SUCCESS_COUNT);
+  }
+
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(user_context.GetAccountId());
   if (user) {
     if (!user->is_active()) {
       saved_ime_state_ = NULL;
       user_manager::UserManager::Get()->SwitchActiveUser(
           user_context.GetAccountId());
     }
 
     // Reset the number of PIN attempts available to the user. We always do this
@@ skipping 50 matching lines @@
   chromeos::ScreenLocker::Hide();
 }
 
 void ScreenLocker::Authenticate(const UserContext& user_context) {
   LOG_ASSERT(IsUserLoggedIn(user_context.GetAccountId()))
       << "Invalid user trying to unlock.";
 
   authentication_start_time_ = base::Time::Now();
   delegate_->SetInputEnabled(false);
   delegate_->OnAuthenticate();
+  is_pin_attempt_ = user_context.IsUsingPin();
 
   const user_manager::User* user = FindUnlockUser(user_context.GetAccountId());
   if (user) {
     // Check to see if the user submitted a PIN and it is valid.
     const std::string pin = user_context.GetKey()->GetSecret();
 
     // We only want to try authenticating the pin if it is a number,
     // otherwise we will timeout PIN if the user enters their account password
     // incorrectly more than a few times.
     int dummy_value;
-    if (base::StringToInt(pin, &dummy_value)) {
+    if (is_pin_attempt_ && base::StringToInt(pin, &dummy_value)) {
       chromeos::PinStorage* pin_storage =
           chromeos::PinStorageFactory::GetForUser(user);
       if (pin_storage && pin_storage->TryAuthenticatePin(pin)) {
         OnAuthSuccess(user_context);
         return;
       }
     }
 
     // Special case: supervised users. Use special authenticator.
     if (user->GetType() == user_manager::USER_TYPE_SUPERVISED) {
@@ skipping 232 matching lines @@
 
 bool ScreenLocker::IsUserLoggedIn(const AccountId& account_id) const {
   for (user_manager::User* user : users_) {
     if (user->GetAccountId() == account_id)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos