Add user metrics for the login screen.

chrome/browser/chromeos/login/login_performer.cc

 // Copyright (c) 2010 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/login_performer.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
+#include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
 
 namespace chromeos {
 
 namespace {
+
+// Records the login failure with the error code as user metrics. This
+// function is verbose, but we need to enumerate all actions as described
+// in user_metrics.h. Another option is to add some code in
+// extract_actions.py, which is no better than this.
+void RecordLoginFailure(const chromeos::LoginFailure& failure) {
+  switch (failure.reason()) {
+    case chromeos::LoginFailure::NONE:
+      UserMetrics::RecordAction(

[Nikita (slow), 2010/12/02 10:45:12]

I think what you need here instead is

UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.ErrorCodesForMainFrame",
                                     request->status().os_error(),
                                     GetAllNetErrorCodes());

[satorux1, 2010/12/02 10:52:18]

My understanding is that histogram is used for collecting times. Repurposing
this for collecting error code doesn't sound right. Besides, histgorams are
shown in a different dashboard page than the user metrics actions.

[Nikita (slow), 2010/12/02 11:38:22]

Having Login status error/success codes reported as histogram gives us better
understanding on error codes distribution, gives nice graph.

We might track successful login as a user action too.
Makes sense to me.

+          UserMetricsAction("Login_Failure_NONE"));
+      break;
+    case chromeos::LoginFailure::COULD_NOT_MOUNT_CRYPTOHOME:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_COULD_NOT_MOUNT_CRYPTOHOME"));
+      break;
+    case chromeos::LoginFailure::COULD_NOT_MOUNT_TMPFS:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_COULD_NOT_MOUNT_TMPFS"));
+      break;
+    case chromeos::LoginFailure::COULD_NOT_UNMOUNT_CRYPTOHOME:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_COULD_NOT_UNMOUNT_CRYPTOHOME"));
+      break;
+    case chromeos::LoginFailure::DATA_REMOVAL_FAILED:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_DATA_REMOVAL_FAILED"));
+      break;
+    case chromeos::LoginFailure::LOGIN_TIMED_OUT:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_LOGIN_TIMED_OUT"));
+      break;
+    case chromeos::LoginFailure::UNLOCK_FAILED:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_UNLOCK_FAILED"));
+      break;
+    case chromeos::LoginFailure::NETWORK_AUTH_FAILED:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_NETWORK_AUTH_FAILED"));
+      break;
+    default:
+      UserMetrics::RecordAction(
+          UserMetricsAction("Login_Failure_UNKNOWN"));
+      break;
+  }
+}
+
 }  // namespace
 
 LoginPerformer::LoginPerformer(Delegate* delegate)
     : last_login_failure_(LoginFailure::None()),
       delegate_(delegate),
       method_factory_(this) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // LoginPerformer, LoginStatusConsumer implementation:
 
 void LoginPerformer::OnLoginFailure(const LoginFailure& failure) {
- last_login_failure_ = failure;
- if (delegate_) {
-   captcha_.clear();
-   captcha_token_.clear();
-   if (failure.reason() == LoginFailure::NETWORK_AUTH_FAILED &&
-       failure.error().state() == GoogleServiceAuthError::CAPTCHA_REQUIRED) {
-     captcha_token_ = failure.error().captcha().token;
-   }
-   delegate_->OnLoginFailure(failure);
- } else {
-   // TODO(nkostylev): Provide blocking UI using ScreenLocker.
- }
+  RecordLoginFailure(failure);
+
+  last_login_failure_ = failure;
+  if (delegate_) {
+    captcha_.clear();
+    captcha_token_.clear();
+    if (failure.reason() == LoginFailure::NETWORK_AUTH_FAILED &&
+        failure.error().state() == GoogleServiceAuthError::CAPTCHA_REQUIRED) {
+      captcha_token_ = failure.error().captcha().token;
+    }
+    delegate_->OnLoginFailure(failure);
+  } else {
+    // TODO(nkostylev): Provide blocking UI using ScreenLocker.
+  }
 }
 
 void LoginPerformer::OnLoginSuccess(
     const std::string& username,
     const std::string& password,
     const GaiaAuthConsumer::ClientLoginResult& credentials,
     bool pending_requests) {
+  if (pending_requests) {
+    UserMetrics::RecordAction(
+        UserMetricsAction("Login_Success_OfflineOnly"));
+  } else {
+    UserMetrics::RecordAction(
+        UserMetricsAction("Login_Success_OfflineAndOnline"));
+  }
+
   if (delegate_) {
     delegate_->OnLoginSuccess(username,
                               password,
                               credentials,
                               pending_requests);
     if (!pending_requests)
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   } else {
     DCHECK(!pending_requests);
     // Online login has succeeded. Delete our instance.
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
 
 void LoginPerformer::OnOffTheRecordLoginSuccess() {
+  UserMetrics::RecordAction(
+      UserMetricsAction("Login_OffTheRecordLoginSuccess"));
+
   if (delegate_)
     delegate_->OnOffTheRecordLoginSuccess();
   else
     NOTREACHED();
 }
 
 void LoginPerformer::OnPasswordChangeDetected(
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
   cached_credentials_ = credentials;
   if (delegate_) {
@@ skipping 88 matching lines @@
                         &Authenticator::AuthenticateToLogin,
                         profile,
                         username_,
                         password_,
                         captcha_token_,
                         captcha_));
   password_.clear();
 }
 
 }  // namespace chromeos