Hold histograms in static variables instead of allocating heap.

chrome/browser/net/websocket_experiment/websocket_experiment_runner.cc

 // Copyright (c) 2009 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/net/websocket_experiment/websocket_experiment_runner.h"
 
 #include "base/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "chrome/browser/chrome_thread.h"
 #include "net/base/net_errors.h"
 
 namespace chrome_browser_net_websocket_experiment {
 
 static const char *kExperimentHost = "websocket-experiment.chromium.org";
 static const int kAlternativePort = 61985;
 
-static const char kLastStateName[] = "LastState";
-static const char kUrlFetchName[] = "UrlFetch";
-static const char kWebSocketConnectName[] = "WebSocketConnect";
-static const char kWebSocketEchoName[] = "WebSocketEcho";
-static const char kWebSocketIdleName[] = "WebSocketIdle";
-static const char kWebSocketTotalName[] = "WebSocketTotal";
 static const int kUrlFetchDeadlineSec = 10;
 static const int kWebSocketConnectDeadlineSec = 10;
 static const int kWebSocketEchoDeadlineSec = 5;
 static const int kWebSocketIdleSec = 1;
 static const int kWebSocketPushDeadlineSec = 1;
 static const int kWebSocketByeDeadlineSec = 10;
 static const int kWebSocketCloseDeadlineSec = 5;
 static const int kWebSocketTimeSec = 10;
+static const int kTimeBucketCount = 50;
+
+// TODO(ukai): Use new thread-safe-reference-counted Histograms.
+#define UPDATE_HISTOGRAM(name, sample, min, max, bucket_count) do { \
+    switch (task_state_) {                                          \
+      case STATE_RUN_WS:                                            \
+        {                                                           \
+          static LinearHistogram counter(                               \
+              "WebSocketExperiment.Basic." name, min, max, bucket_count); \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.Add(sample);                                          \
+        }                                                               \
+        break;                                                          \
+      case STATE_RUN_WSS:                                               \
+        {                                                               \
+          static LinearHistogram counter(                               \
+              "WebSocketExperiment.Secure." name, min, max, bucket_count); \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.Add(sample);                                          \
+        }                                                               \
+        break;                                                          \
+      case STATE_RUN_WS_NODEFAULT_PORT:                                 \
+        {                                                               \
+          static LinearHistogram counter(                               \
+              "WebSocketExperiment.NoDefaultPort." name,                \
+              min, max, bucket_count);                                  \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.Add(sample);                                          \
+        }                                                               \
+        break;                                                          \
+      default:                                                          \
+        NOTREACHED();                                                   \
+        break;                                                          \
+    }                                                                   \
+  } while (0)
+
+#define UPDATE_HISTOGRAM_TIMES(name, sample, min, max, bucket_count) do {    \
+    switch (task_state_) {                                              \
+      case STATE_RUN_WS:                                                \
+        {                                                               \
+          static Histogram counter(                                     \
+              "WebSocketExperiment.Basic." name, min, max, bucket_count); \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.AddTime(sample);                                      \
+        }                                                               \
+        break;                                                          \
+      case STATE_RUN_WSS:                                               \
+        {                                                               \
+          static Histogram counter(                                     \
+              "WebSocketExperiment.Secure." name, min, max, bucket_count); \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.AddTime(sample);                                      \
+        }                                                               \
+        break;                                                          \
+      case STATE_RUN_WS_NODEFAULT_PORT:                                 \
+        {                                                               \
+          static Histogram counter(                                     \
+              "WebSocketExperiment.NoDefaultPort." name,                \
+              min, max, bucket_count);                                  \
+          counter.SetFlags(kUmaTargetedHistogramFlag);                  \
+          counter.AddTime(sample);                                      \
+        }                                                               \
+        break;                                                          \
+      default:                                                          \
+        NOTREACHED();                                                   \
+        break;                                                          \
+    }                                                                   \
+  } while (0);
 
 // Hold reference while experiment is running.
 static scoped_refptr<WebSocketExperimentRunner> runner;
 
 /* static */
 void WebSocketExperimentRunner::Start() {
   DCHECK(!runner.get());
   runner = new WebSocketExperimentRunner;
   runner->Run();
 }
 
 /* static */
 void WebSocketExperimentRunner::Stop() {
   if (runner.get())
     runner->Cancel();
   runner = NULL;
 }
 
 WebSocketExperimentRunner::WebSocketExperimentRunner()
     : next_state_(STATE_NONE),
       task_state_(STATE_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           task_callback_(this, &WebSocketExperimentRunner::OnTaskCompleted)) {
   InitConfig();
-  InitHistograms();
 }
 
 WebSocketExperimentRunner::~WebSocketExperimentRunner() {
   DLOG(INFO) << "WebSocketExperimentRunner deleted";
   DCHECK(!task_.get());
 }
 
 void WebSocketExperimentRunner::Run() {
   DCHECK_EQ(next_state_, STATE_NONE);
   next_state_ = STATE_RUN_WS;
@@ skipping 56 matching lines @@
       GURL(StringPrintf("ws://%s:%d/live_exp",
                         kExperimentHost, kAlternativePort));
   config_.ws_nondefault_config.ws_location =
       StringPrintf("ws://%s:%d/live_exp",
                    kExperimentHost, kAlternativePort);
   config_.ws_nondefault_config.http_url =
       GURL(StringPrintf("http://%s:%d/",
                         kExperimentHost, kAlternativePort));
 }
 
-void WebSocketExperimentRunner::InitHistograms() {
-  InitHistogram<LinearHistogram, Histogram::Sample>(
-      kLastStateName, 1, WebSocketExperimentTask::NUM_STATES,
-      WebSocketExperimentTask::NUM_STATES + 1);
-
-  InitHistogram<Histogram, base::TimeDelta>(
-      kUrlFetchName, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromSeconds(kUrlFetchDeadlineSec), 50);
-
-  InitHistogram<Histogram, base::TimeDelta>(
-      kWebSocketConnectName, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromSeconds(kWebSocketConnectDeadlineSec), 50);
-
-  InitHistogram<Histogram, base::TimeDelta>(
-      kWebSocketEchoName, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromSeconds(kWebSocketEchoDeadlineSec), 50);
-
-  InitHistogram<Histogram, base::TimeDelta>(
-      kWebSocketIdleName, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromSeconds(
-          kWebSocketIdleSec + kWebSocketPushDeadlineSec), 50);
-
-  InitHistogram<Histogram, base::TimeDelta>(
-      kWebSocketTotalName, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromSeconds(kWebSocketTimeSec), 50);
-}
-
 void WebSocketExperimentRunner::DoLoop() {
   if (next_state_ == STATE_NONE) {
     if (task_.get()) {
       AddRef();  // Release in OnTaskCompleted.
       task_->Cancel();
     }
     return;
   }
 
   State state = next_state_;
@@ skipping 64 matching lines @@
              << " url_fetch=" << task_result.url_fetch.InSecondsF()
              << " websocket_connect="
              << task_result.websocket_connect.InSecondsF()
              << " websocket_echo="
              << task_result.websocket_echo.InSecondsF()
              << " websocket_idle="
              << task_result.websocket_idle.InSecondsF()
              << " websocket_total="
              << task_result.websocket_total.InSecondsF();
 
+  UPDATE_HISTOGRAM("LastState", task_result.last_state,
+                   1, WebSocketExperimentTask::NUM_STATES,
+                   WebSocketExperimentTask::NUM_STATES + 1);
 
-  Histogram* last_state = GetHistogram(kLastStateName);
-  DCHECK(last_state);
-  last_state->Add(task_result.last_state);
-
-  Histogram* url_fetch = GetHistogram(kUrlFetchName);
-  DCHECK(url_fetch);
-  url_fetch->AddTime(task_result.url_fetch);
+  UPDATE_HISTOGRAM_TIMES("UrlFetch", task_result.url_fetch,
+                         base::TimeDelta::FromMilliseconds(1),
+                         base::TimeDelta::FromSeconds(kUrlFetchDeadlineSec),
+                         kTimeBucketCount);
 
   if (task_result.last_state <
       WebSocketExperimentTask::STATE_WEBSOCKET_CONNECT_COMPLETE)
     return;
 
-  Histogram* websocket_connect = GetHistogram(kWebSocketConnectName);
-  DCHECK(websocket_connect);
-  websocket_connect->AddTime(task_result.websocket_connect);
+  UPDATE_HISTOGRAM_TIMES("WebSocketConnect", task_result.websocket_connect,
+                         base::TimeDelta::FromMilliseconds(1),
+                         base::TimeDelta::FromSeconds(
+                             kWebSocketConnectDeadlineSec),
+                         kTimeBucketCount);
 
   if (task_result.last_state <
       WebSocketExperimentTask::STATE_WEBSOCKET_RECV_HELLO)
     return;
 
-  Histogram* websocket_echo = GetHistogram(kWebSocketEchoName);
-  DCHECK(websocket_echo);
-  websocket_echo->AddTime(task_result.websocket_echo);
+  UPDATE_HISTOGRAM_TIMES("WebSocketEcho", task_result.websocket_echo,
+                         base::TimeDelta::FromMilliseconds(1),
+                         base::TimeDelta::FromSeconds(
+                             kWebSocketEchoDeadlineSec),
+                         kTimeBucketCount);
 
   if (task_result.last_state <
       WebSocketExperimentTask::STATE_WEBSOCKET_KEEP_IDLE)
     return;
 
-  Histogram* websocket_idle = GetHistogram(kWebSocketIdleName);
-  DCHECK(websocket_idle);
-  websocket_idle->AddTime(task_result.websocket_idle);
+  UPDATE_HISTOGRAM_TIMES("WebSocketIdle", task_result.websocket_idle,
+                         base::TimeDelta::FromMilliseconds(1),
+                         base::TimeDelta::FromSeconds(
+                             kWebSocketIdleSec + kWebSocketPushDeadlineSec),
+                         kTimeBucketCount);
 
   if (task_result.last_state <
       WebSocketExperimentTask::STATE_WEBSOCKET_CLOSE_COMPLETE)
     return;
 
-  Histogram* websocket_total = GetHistogram(kWebSocketTotalName);
-  DCHECK(websocket_total);
-  websocket_total->AddTime(task_result.websocket_total);
-}
-
-template<class HistogramType, typename HistogramSample>
-void WebSocketExperimentRunner::InitHistogram(
-    const char* type_name,
-    HistogramSample min, HistogramSample max, size_t bucket_count) {
-  static std::string name = StringPrintf(
-      "WebSocketExperiment.Basic.%s", type_name);
-  HistogramType* counter = new HistogramType(name.c_str(),
-                                             min, max, bucket_count);
-  counter->SetFlags(kUmaTargetedHistogramFlag);
-  ws_histograms_[type_name] = linked_ptr<Histogram>(counter);
-
-  name = StringPrintf("WebSocketExperiment.Secure.%s", type_name);
-  counter = new HistogramType(name.c_str(), min, max, bucket_count);
-  counter->SetFlags(kUmaTargetedHistogramFlag);
-  wss_histograms_[type_name] = linked_ptr<Histogram>(counter);
-
-  name = StringPrintf("WebSocketExperiment.NoDefaultPort.%s", type_name);
-  counter = new HistogramType(name.c_str(), min, max, bucket_count);
-  counter->SetFlags(kUmaTargetedHistogramFlag);
-  ws_nondefault_histograms_[type_name] = linked_ptr<Histogram>(counter);
-}
-
-Histogram* WebSocketExperimentRunner::GetHistogram(
-    const std::string& type_name) const {
-  const HistogramMap* histogram_map = NULL;
-  switch (task_state_) {
-    case STATE_RUN_WS:
-      histogram_map = &ws_histograms_;
-      break;
-    case STATE_RUN_WSS:
-      histogram_map = &wss_histograms_;
-      break;
-    case STATE_RUN_WS_NODEFAULT_PORT:
-      histogram_map = &ws_nondefault_histograms_;
-      break;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-  DCHECK(histogram_map);
-  HistogramMap::const_iterator found = histogram_map->find(type_name);
-  DCHECK(found != histogram_map->end());
-  return found->second.get();
+  UPDATE_HISTOGRAM_TIMES("WebSocketTotal", task_result.websocket_total,
+                         base::TimeDelta::FromMilliseconds(1),
+                         base::TimeDelta::FromSeconds(kWebSocketTimeSec),
+                         kTimeBucketCount);
 }
 
 }  // namespace chrome_browser_net_websocket_experiment