Added UMA records for OOBE portal detection.

chrome/browser/chromeos/net/network_portal_detector.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/chromeos/net/network_portal_detector.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/http/http_status_code.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using captive_portal::CaptivePortalDetector;
@@ skipping 27 matching lines @@
           IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_OFFLINE);
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_ONLINE);
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_PORTAL);
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED);
+    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT:
+      NOTREACHED();
   }
   return l10n_util::GetStringUTF8(
       IDS_CHROMEOS_CAPTIVE_PORTAL_STATUS_UNRECOGNIZED);
 }
 
 NetworkPortalDetector* g_network_portal_detector = NULL;
 
 }  // namespace
 
 NetworkPortalDetector::NetworkPortalDetector(
@@ skipping 164 matching lines @@
   next_attempt_delay_ = delay;
   if (attempt_count_ > 0) {
     base::TimeTicks now = GetCurrentTimeTicks();
     base::TimeDelta elapsed_time;
     if (now > attempt_start_time_)
       elapsed_time = now - attempt_start_time_;
     if (elapsed_time < min_time_between_attempts_ &&
         min_time_between_attempts_ - elapsed_time > next_attempt_delay_) {
       next_attempt_delay_ = min_time_between_attempts_ - elapsed_time;
     }
+  } else {
+    detection_start_time_ = GetCurrentTimeTicks();
   }
   detection_task_.Reset(
       base::Bind(&NetworkPortalDetector::DetectCaptivePortalTask,
                  weak_ptr_factory_.GetWeakPtr()));
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           detection_task_.callback(),
                                           next_attempt_delay_);
 }
 
 void NetworkPortalDetector::DetectCaptivePortalTask() {
@@ skipping 107 matching lines @@
 
 bool NetworkPortalDetector::IsCheckingForPortal() const {
   return state_ == STATE_CHECKING_FOR_PORTAL;
 }
 
 void NetworkPortalDetector::SetCaptivePortalState(
     const Network* network,
     const CaptivePortalState& state) {
   DCHECK(network);
 
+  if (!detection_start_time_.is_null()) {
+    UMA_HISTOGRAM_LONG_TIMES("CaptivePortal.OOBE.DetectionDuration",

[Nikita (slow), 2013/02/11 16:26:41]

Comment says: Use this macro when times can routinely be much longer than 10
seconds.
This one is hold buckets for up to 1 hour.

UMA_HISTOGRAM_TIMES seems to be better suited here (1..10s, 50 buckets).

[ygorshenin1, 2013/02/12 14:20:06]

Done.

+                             GetCurrentTimeTicks() - detection_start_time_);
+  }
+
   CaptivePortalStateMap::const_iterator it =
       portal_state_map_.find(network->service_path());
   if (it == portal_state_map_.end() ||
       it->second.status != state.status ||
       it->second.response_code != state.response_code) {
     VLOG(1) << "Updating Chrome Captive Portal state: "
             << "network=" << network->unique_id() << ", "
             << "status=" << CaptivePortalStatusString(state.status) << ", "
             << "response_code=" << state.response_code;
     portal_state_map_[network->service_path()] = state;
     NotifyPortalStateChanged(network, state);
   }
 }
 
 void NetworkPortalDetector::NotifyPortalStateChanged(
     const Network* network,
     const CaptivePortalState& state) {
   FOR_EACH_OBSERVER(Observer, observers_, OnPortalStateChanged(network, state));
 }
 
 base::TimeTicks NetworkPortalDetector::GetCurrentTimeTicks() const {
   if (time_ticks_for_testing_.is_null())
     return base::TimeTicks::Now();
   else
     return time_ticks_for_testing_;
 }
 
 }  // namespace chromeos