Update UMA histograms as discussed with jar.

chrome/browser/ui/views/network_profile_bubble.cc

 // Copyright (c) 2012 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/views/network_profile_bubble.h"
 
 #include <wtsapi32.h>
 // Make sure we link the wtsapi lib file in.
 #pragma comment(lib, "wtsapi32.lib")
 
@@ skipping 24 matching lines @@
 namespace {
 
 // The duration of the silent period before we start nagging the user again.
 const int kSilenceDurationDays = 100;
 
 // Bubble layout constants.
 const int kAnchorVerticalInset = 5;
 const int kInset = 2;
 const int kNotificationBubbleWidth = 250;
 
+// The name of the UMA histogram collecting our stats.
+const char kMetricNetworkedProfileCheck[] = "NetworkedProfile.Check";
+
+enum MetricNetworkedProfileCheck {
+  // Check was suppressed by command line flag.
+  METRIC_CHECK_SUPPRESSED,
+  // WTSQuerySessionInformation call failed.
+  METRIC_CHECK_FAILED,
+  // File access in profile dir failed.
+  METRIC_CHECK_IO_FAILED,
+
+  // Profile on a network share detected.
+  METRIC_PROFILE_ON_NETWORK,
+  // Profile not on a network share detected.
+  METRIC_PROFILE_NOT_ON_NETWORK,
+
+  // Check was suppressed because of remote session.
+  METRIC_REMOTE_SESSION,
+
+  // User has clicked learn more on the notification bubble.
+  METRIC_LEARN_MORE_CLICKED,
+  // User has clicked OK on the notification bubble.
+  METRIC_ACKNOWLEDGED,
+
+  METRIC_NETWORKED_PROFILE_CHECK_SIZE  // Must be the last.
+};
+
 // Implementation of BrowserList::Observer used to wait for a browser window.
 class BrowserListObserver : public BrowserList::Observer {
  private:
   virtual ~BrowserListObserver();
 
   // Overridden from BrowserList::Observer:
   virtual void OnBrowserAdded(const Browser* browser) OVERRIDE;
   virtual void OnBrowserRemoved(const Browser* browser) OVERRIDE;
   virtual void OnBrowserSetLastActive(const Browser* browser) OVERRIDE;
 };
@@ skipping 29 matching lines @@
   // share as we don't officially support this setup yet.
   // However we don't want to bother users on Cytrix setups as those have no
   // real choice and their admins must be well aware of the risks associated.
   // Also the command line flag --no-network-profile-warning can stop this
   // warning from popping up. In this case we can skip the check to make the
   // start faster.
   // Collect a lot of stats along the way to see which cases do occur in the
   // wild often enough.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNoNetworkProfileWarning)) {
-    UMA_HISTOGRAM_COUNTS("NetworkedProfile.CheckSuppressed", 1);
+    UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,

[jar (doing other things), 2012/05/16 16:57:43]

nit: Not a big deal.... but when you have to repeate a histogram in a bunch of
places, it is probably nicer to factor out a static method that just takes the
enum, and call it. This way you can just put the name (sen on line 46) in the
actual histogram call.... and also, the histogram macro is a tab big, and might
as well be done once-and-for-all in one place.

[pastarmovj, 2012/05/18 09:48:52]

Done.

+                              METRIC_CHECK_SUPPRESSED,
+                              METRIC_NETWORKED_PROFILE_CHECK_SIZE);
     return;
   }
 
   LPWSTR buffer = NULL;
   DWORD buffer_length = 0;
   // Checking for RDP is cheaper than checking for a network drive so do this
   // one first.
   if (!WTSQuerySessionInformation(WTS_CURRENT_SERVER, WTS_CURRENT_SESSION,
                                   WTSClientProtocolType,
                                   &buffer, &buffer_length)) {
-    UMA_HISTOGRAM_COUNTS("NetworkedProfile.CheckFailed", 1);
+    UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                              METRIC_CHECK_FAILED,
+                              METRIC_NETWORKED_PROFILE_CHECK_SIZE);
     return;
   }
 
   unsigned short* type = reinterpret_cast<unsigned short*>(buffer);
   // Zero means local session and we should warn the users if they have
   // their profile on a network share.
   if (*type == 0) {
     bool profile_on_network = false;
     if (!profile_path.empty()) {
       FilePath temp_file;
       // Try to create some non-empty temp file in the profile dir and use
       // it to check if there is a reparse-point free path to it.
       if (file_util::CreateTemporaryFileInDir(profile_path, &temp_file) &&
           file_util::WriteFile(temp_file, ".", 1)) {
         FilePath normalized_temp_file;
         if (!file_util::NormalizeFilePath(temp_file, &normalized_temp_file))
           profile_on_network = true;
       } else {
-        UMA_HISTOGRAM_COUNTS("NetworkedProfile.CheckIOFailed", 1);
+        UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                                  METRIC_CHECK_IO_FAILED,
+                                  METRIC_NETWORKED_PROFILE_CHECK_SIZE);
       }
       file_util::Delete(temp_file, false);
     }
     if (profile_on_network) {
-      UMA_HISTOGRAM_COUNTS("NetworkedProfile.ProfileOnNetwork", 1);
+      UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                                METRIC_PROFILE_ON_NETWORK,
+                                METRIC_NETWORKED_PROFILE_CHECK_SIZE);
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
           base::Bind(&NetworkProfileBubble::NotifyNetworkProfileDetected));
     } else {
-      UMA_HISTOGRAM_COUNTS("NetworkedProfile.ProfileNotOnNetwork", 1);
+      UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                                METRIC_PROFILE_NOT_ON_NETWORK,
+                                METRIC_NETWORKED_PROFILE_CHECK_SIZE);
     }
   } else {
-    UMA_HISTOGRAM_COUNTS("NetworkedProfile.RemoteSession", 1);
+    UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                              METRIC_REMOTE_SESSION,
+                              METRIC_NETWORKED_PROFILE_CHECK_SIZE);
   }
 
   WTSFreeMemory(buffer);
 }
 
 // static
 bool NetworkProfileBubble::ShouldCheckNetworkProfile(PrefService* prefs) {
   if (prefs->GetInteger(prefs::kNetworkProfileWarningsLeft))
     return !notification_shown_;
   int64 last_check = prefs->GetInt64(prefs::kNetworkProfileLastWarningTime);
@@ skipping 78 matching lines @@
 }
 
 gfx::Rect NetworkProfileBubble::GetAnchorRect() {
   // Compensate for padding in anchor.
   gfx::Rect rect(BubbleDelegateView::GetAnchorRect());
   rect.Inset(0, anchor_view() ? kAnchorVerticalInset : 0);
   return rect;
 }
 
 void NetworkProfileBubble::LinkClicked(views::Link* source, int event_flags) {
-  UMA_HISTOGRAM_COUNTS("NetworkedProfile.LearnMoreClicked", 1);
+  UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                            METRIC_LEARN_MORE_CLICKED,
+                            METRIC_NETWORKED_PROFILE_CHECK_SIZE);
   Browser* browser = BrowserList::GetLastActive();
   if (browser) {
     WindowOpenDisposition disposition =
         event_utils::DispositionFromEventFlags(event_flags);
     content::OpenURLParams params(
         GURL("https://sites.google.com/a/chromium.org/dev/administrators/"
              "common-problems-and-solutions#network_profile"),
         content::Referrer(),
         disposition == CURRENT_TAB ? NEW_FOREGROUND_TAB : disposition,
         content::PAGE_TRANSITION_LINK, false);
     browser->OpenURL(params);
     // If the user interacted with the bubble we don't reduce the number of
     // warnings left.
     PrefService* prefs = browser->profile()->GetPrefs();
     int left_warnings = prefs->GetInteger(prefs::kNetworkProfileWarningsLeft);
     prefs->SetInteger(prefs::kNetworkProfileWarningsLeft, ++left_warnings);
   }
   GetWidget()->Close();
 }
 
 void NetworkProfileBubble::ButtonPressed(views::Button* sender,
                                          const views::Event& event) {
-  UMA_HISTOGRAM_COUNTS("NetworkedProfile.Acknowledged", 1);
+  UMA_HISTOGRAM_ENUMERATION(kMetricNetworkedProfileCheck,
+                            METRIC_ACKNOWLEDGED,
+                            METRIC_NETWORKED_PROFILE_CHECK_SIZE);
 
   GetWidget()->Close();
 }
 
 // static
 void NetworkProfileBubble::NotifyNetworkProfileDetected() {
   if (BrowserList::GetLastActive() != NULL)
     ShowNotification(BrowserList::GetLastActive());
   else
     BrowserList::AddObserver(new BrowserListObserver());
 }