[cros] Added histograms for user image usage

chrome/browser/chromeos/login/user_manager.cc

 // Copyright (c) 2011 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/user_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "crypto/nss_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
@@ skipping 193 matching lines @@
 }  // namespace
 
 UserManager::User::User() : oauth_token_status_(OAUTH_TOKEN_STATUS_UNKNOWN),
                             is_displayname_unique_(false) {
   image_ = *ResourceBundle::GetSharedInstance().GetBitmapNamed(
       kDefaultImageResources[0]);
 }
 
 UserManager::User::~User() {}
 
+void UserManager::User::SetImage(const SkBitmap& image,
+                                 int default_image_index) {
+  image_ = image;
+  default_image_index_ = default_image_index;
+}
+
 std::string UserManager::User::GetDisplayName() const {
   size_t i = email_.find('@');
   if (i == 0 || i == std::string::npos) {
     return email_;
   }
   return email_.substr(0, i);
 }
 
 bool UserManager::User::NeedsNameTooltip() const {
   return !is_displayname_unique_;
@@ skipping 60 matching lines @@
         } else {
           int oauth_token_status = OAUTH_TOKEN_STATUS_UNKNOWN;
           if (prefs_oauth_status &&
               prefs_oauth_status->GetIntegerWithoutPathExpansion(email,
                   &oauth_token_status)) {
             user.set_oauth_token_status(
                 static_cast<OAuthTokenStatus>(oauth_token_status));
           }
         }
 
-        UserImages::const_iterator image_it = user_images_.find(email);
         std::string image_path;
-        if (image_it == user_images_.end()) {
-          // Get account image path.
-          if (prefs_images &&
-              prefs_images->GetStringWithoutPathExpansion(email, &image_path)) {
-            int default_image_id = kDefaultImagesCount;
-            if (IsDefaultImagePath(image_path, &default_image_id)) {
-              DCHECK(default_image_id < kDefaultImagesCount);
-              int resource_id = kDefaultImageResources[default_image_id];
-              user.set_image(
-                  *ResourceBundle::GetSharedInstance().GetBitmapNamed(
-                      resource_id));
-              user_images_[email] = user.image();
-            } else {
+        // Get account image path.
+        if (prefs_images &&
+            prefs_images->GetStringWithoutPathExpansion(email, &image_path)) {
+          int default_image_id = kDefaultImagesCount;
+          if (IsDefaultImagePath(image_path, &default_image_id)) {
+            DCHECK(default_image_id >= 0);
+            DCHECK(default_image_id < kDefaultImagesCount);
+            int resource_id = kDefaultImageResources[default_image_id];
+            user.SetImage(
+                *ResourceBundle::GetSharedInstance().GetBitmapNamed(
+                    resource_id),
+                default_image_id);
+          } else {
+            UserImages::const_iterator image_it = user_images_.find(email);
+            if (image_it == user_images_.end()) {
               // Insert the default image so we don't send another request if
               // GetUsers is called twice.
               user_images_[email] = user.image();
               image_loader_->Start(email, image_path, false);
+            } else {
+              user.SetImage(image_it->second, -1);
             }
           }
-        } else {
-          user.set_image(image_it->second);
         }
 
         // Makes table to determine whether displayname is unique.
         const std::string& display_name = user.GetDisplayName();
         ++display_name_count[display_name];
 
         users.push_back(user);
       }
     }
 
@@ skipping 43 matching lines @@
     std::string user_email = it->email();
     // Skip the most recent user.
     if (email != user_email) {
       prefs_users_update->Append(Value::CreateStringValue(user_email));
     } else {
       logged_in_user_ = *it;
     }
   }
   prefs->SavePersistentPrefs();
   NotifyOnLogin();
-  if (current_user_is_new_)
+  if (current_user_is_new_) {
     SetDefaultUserImage(email);
+  } else {
+    int metric = kDefaultImagesCount;
+    if (logged_in_user_.default_image_index() != -1)
+      metric = logged_in_user_.default_image_index();

[jar (doing other things), 2011/08/10 17:48:52]

personal style nit: not critical:  I prefer to call functions only once, as the
code is sometimes faster and race-free, and often easier to read.  The above
could be:

int metric = logged_in_user_.default_image_index();
if (metric == -1)
  metric = kDefaultImagesCount;

+    UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
+                              metric,
+                              kDefaultImagesCount + 1);
+  }
 }
 
 void UserManager::RemoveUser(const std::string& email,
                              RemoveUserDelegate* delegate) {
   // Get a copy of the current users.
   std::vector<User> users = GetUsers();
 
   // Sanity check: we must not remove single user. This check may seem
   // redundant at a first sight because this single user must be an owner and
   // we perform special check later in order not to remove an owner.  However
@@ skipping 169 matching lines @@
   return image_id;
 }
 
 void UserManager::OnImageLoaded(const std::string& username,
                                 const SkBitmap& image,
                                 bool should_save_image) {
   DVLOG(1) << "Loaded image for " << username;
   user_images_[username] = image;
   User user;
   user.set_email(username);
-  user.set_image(image);
+  user.SetImage(image, -1);
   if (logged_in_user_.email() == username)
-    logged_in_user_.set_image(image);
+    logged_in_user_.SetImage(image, -1);
   if (should_save_image)
     SaveUserImage(username, image);
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
       Source<UserManager>(this),
       Details<const User>(&user));
 }
 
 bool UserManager::IsLoggedInAsGuest() const {
   return logged_in_user().email() == kGuestUser;
@@ skipping 110 matching lines @@
 }
 
 void UserManager::NotifyLocalStateChanged() {
  FOR_EACH_OBSERVER(
     Observer,
     observer_list_,
     LocalStateChanged(this));
 }
 
 }  // namespace chromeos