Add Profile metric counting to new User Manager.

chrome/browser/ui/webui/signin/user_manager_screen_handler.cc

 // Copyright 2013 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/signin/user_manager_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/profiles/avatar_menu.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/profiles/profile_info_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/local_auth.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ skipping 143 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ProfileUpdateObserver);
 };
 
 // UserManagerScreenHandler ---------------------------------------------------
 
 UserManagerScreenHandler::UserManagerScreenHandler()
     : desktop_type_(chrome::GetActiveDesktop()) {
   profileInfoCacheObserver_.reset(
       new UserManagerScreenHandler::ProfileUpdateObserver(
           g_browser_process->profile_manager(), this));
+  ProfileMetrics::LogProfileSwitchUser(ProfileMetrics::OPEN_PROFILE_MANAGER);

[noms (inactive), 2014/01/23 17:00:57]

I'm not sure whether this should be in here, or in chrome::ShowUserManager().
The user can choose to show the dialog while it's still open, in which case we'd
reuse the instance, the constructor wouldn't get hit, and we wouldn't count it.
Maybe a webui owner can comment?

[bcwhite, 2014/01/23 18:14:05]

Gotcha.  Moved to UserManagerView::Show() for now.

 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
   SendUserList();
   web_ui()->CallJavascriptFunction("cr.ui.Oobe.showUserManagerScreen");
   desktop_type_ = chrome::GetHostDesktopTypeForNativeView(
       web_ui()->GetWebContents()->GetView()->GetNativeView());
 }
 
 void UserManagerScreenHandler::HandleAddUser(const base::ListValue* args) {
   profiles::CreateAndSwitchToNewProfile(desktop_type_,
                                         base::Bind(&chrome::HideUserManager));
+  ProfileMetrics::LogProfileAddNewUser(ProfileMetrics::ADD_NEW_USER_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAuthenticatedLaunchUser(
     const base::ListValue* args) {
   base::string16 email_address;
   if (!args->GetString(0, &email_address))
     return;
 
   base::string16 display_name;
   if (!args->GetString(1, &display_name))
@@ skipping 27 matching lines @@
         email_string,
         password,
         GaiaConstants::kSyncService,
         std::string(),
         std::string(),
         GaiaAuthFetcher::HostedAccountsAllowed);
     password_attempt_ = password;
     return;
   }
 
-  ReportAuthenticationResult(true);
+  ReportAuthenticationResult(true, ProfileMetrics::AUTH_LOCAL);
 }
 
 void UserManagerScreenHandler::HandleRemoveUser(const base::ListValue* args) {
   DCHECK(args);
   const base::Value* profile_path_value;
   if (!args->Get(0, &profile_path_value))
     return;
 
   base::FilePath profile_path;
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path))
     return;
 
   // This handler could have been called in managed mode, for example because
   // the user fiddled with the web inspector. Silently return in this case.
   if (Profile::FromWebUI(web_ui())->IsManaged())
     return;
 
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   g_browser_process->profile_manager()->ScheduleProfileForDeletion(
       profile_path,
       base::Bind(&OpenNewWindowForProfile, desktop_type_));
+  ProfileMetrics::LogProfileDeleteUser(ProfileMetrics::PROFILE_DELETED);
 }
 
 void UserManagerScreenHandler::HandleLaunchGuest(const base::ListValue* args) {
   profiles::SwitchToGuestProfile(desktop_type_,
                                  base::Bind(&chrome::HideUserManager));
+  ProfileMetrics::LogProfileSwitchUser(ProfileMetrics::SWITCH_PROFILE_GUEST);
 }
 
 void UserManagerScreenHandler::HandleLaunchUser(const base::ListValue* args) {
   base::string16 email_address;
   base::string16 display_name;
 
   if (!args->GetString(0, &email_address) ||
       !args->GetString(1, &display_name)) {
     NOTREACHED();
     return;
   }
 
   ProfileInfoCache& info_cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   size_t profile_index = GetIndexOfProfileWithEmailAndName(
       info_cache, email_address, display_name);
 
   if (profile_index >= info_cache.GetNumberOfProfiles()) {
     NOTREACHED();
     return;
   }
 
   // It's possible that a user breaks into the user-manager page using the
   // JavaScript Inspector and causes a "locked" profile to call this
   // unauthenticated version of "launch" instead of the proper one.  Thus,
   // we have to validate in (secure) C++ code that it really is a profile
   // not needing authentication.  If it is, just ignore the "launch" request.
   if (info_cache.ProfileIsSigninRequiredAtIndex(profile_index))
     return;
+  ProfileMetrics::LogProfileAuthResult(ProfileMetrics::AUTH_UNNECESSARY);
 
   base::FilePath path = info_cache.GetPathOfProfileAtIndex(profile_index);
   profiles::SwitchToProfile(
       path, desktop_type_, true, base::Bind(&chrome::HideUserManager));
+  ProfileMetrics::LogProfileSwitchUser(ProfileMetrics::SWITCH_PROFILE_MANAGER);
 }
 
 void UserManagerScreenHandler::OnClientLoginSuccess(
     const ClientLoginResult& result) {
   chrome::SetLocalAuthCredentials(authenticating_profile_index_,
                                   password_attempt_);
-  ReportAuthenticationResult(true);
+  ReportAuthenticationResult(true, ProfileMetrics::AUTH_ONLINE);
 }
 
 void UserManagerScreenHandler::OnClientLoginFailure(
     const GoogleServiceAuthError& error) {
-  ReportAuthenticationResult(false);
+  ReportAuthenticationResult(false, ProfileMetrics::AUTH_ONLINE);
 }
 
 void UserManagerScreenHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(kJsApiUserManagerInitialize,
       base::Bind(&UserManagerScreenHandler::HandleInitialize,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiUserManagerAddUser,
       base::Bind(&UserManagerScreenHandler::HandleAddUser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiUserManagerAuthLaunchUser,
@@ skipping 113 matching lines @@
     if (is_active_user)
       users_list.Insert(0, profile_value);
     else
       users_list.Append(profile_value);
   }
 
   web_ui()->CallJavascriptFunction("login.AccountPickerScreen.loadUsers",
     users_list, base::FundamentalValue(false), base::FundamentalValue(true));
 }
 
-void UserManagerScreenHandler::ReportAuthenticationResult(bool success) {
+void UserManagerScreenHandler::ReportAuthenticationResult(
+    bool success, ProfileMetrics::ProfileAuth auth) {
   if (success) {
+    ProfileMetrics::LogProfileAuthResult(auth);
     ProfileInfoCache& info_cache =
         g_browser_process->profile_manager()->GetProfileInfoCache();
     info_cache.SetProfileSigninRequiredAtIndex(
         authenticating_profile_index_, false);
     base::FilePath path = info_cache.GetPathOfProfileAtIndex(
         authenticating_profile_index_);
     profiles::SwitchToProfile(path, desktop_type_, true,
                               base::Bind(&chrome::HideUserManager));
+    ProfileMetrics::LogProfileSwitchUser(ProfileMetrics::SWITCH_PROFILE_UNLOCK);
   } else {
+    ProfileMetrics::LogProfileAuthResult(ProfileMetrics::AUTH_FAILED);
     web_ui()->CallJavascriptFunction(
         "cr.ui.Oobe.showSignInError",
         base::FundamentalValue(0),
         base::StringValue(
             l10n_util::GetStringUTF8(IDS_LOGIN_ERROR_AUTHENTICATING)),
         base::StringValue(""),
         base::FundamentalValue(0));
   }
 
   password_attempt_.clear();
 }