Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/base/metrics/cast_metrics_helper.cc

 // Copyright 2014 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 "chromecast/base/metrics/cast_metrics_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chromecast/base/metrics/cast_histograms.h"
 #include "chromecast/base/metrics/grouped_histogram.h"
 
 namespace chromecast {
 namespace metrics {
 
 // A useful macro to make sure current member function runs on the valid thread.
-#define MAKE_SURE_THREAD(callback, ...)                    \
-  if (!message_loop_proxy_->BelongsToCurrentThread()) {    \
-    message_loop_proxy_->PostTask(FROM_HERE, base::Bind(   \
-        &CastMetricsHelper::callback,                      \
-        base::Unretained(this), ##__VA_ARGS__));           \
-    return;                                                \
+#define MAKE_SURE_THREAD(callback, ...)                                        \
+  if (!task_runner_->BelongsToCurrentThread()) {                               \
+    task_runner_->PostTask(FROM_HERE,                                          \
+                           base::Bind(&CastMetricsHelper::callback,            \
+                                      base::Unretained(this), ##__VA_ARGS__)); \
+    return;                                                                    \
   }
 
 namespace {
 
 CastMetricsHelper* g_instance = NULL;
 
 // Displayed frames are logged in frames per second (but sampling can be over
 // a longer period of time, e.g. 5 seconds).
 const int kDisplayedFramesPerSecondPeriod = 1000000;
 
@@ skipping 48 matching lines @@
   return JoinString(parts, kMetricsNameAppInfoDelimiter);
 }
 
 // static
 CastMetricsHelper* CastMetricsHelper::GetInstance() {
   DCHECK(g_instance);
   return g_instance;
 }
 
 CastMetricsHelper::CastMetricsHelper(
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy)
-    : message_loop_proxy_(message_loop_proxy),
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : task_runner_(task_runner),
       metrics_sink_(NULL),
       record_action_callback_(base::Bind(&base::RecordComputedAction)) {
-  DCHECK(message_loop_proxy_.get());
+  DCHECK(task_runner_.get());
   DCHECK(!g_instance);
   g_instance = this;
 }
 
 CastMetricsHelper::CastMetricsHelper()
     : metrics_sink_(NULL) {
   DCHECK(!g_instance);
   g_instance = this;
 }
 
@@ skipping 133 matching lines @@
           value, 50);
     }
   }
 
   previous_video_stat_sample_time_ = sample_time;
 }
 
 std::string CastMetricsHelper::GetMetricsNameWithAppName(
     const std::string& prefix,
     const std::string& suffix) const {
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   std::string metrics_name(prefix);
   if (!app_id_.empty()) {
     if (!metrics_name.empty())
       metrics_name.push_back('.');
     metrics_name.append(app_id_);
   }
   if (!suffix.empty()) {
     if (!metrics_name.empty())
       metrics_name.push_back('.');
     metrics_name.append(suffix);
   }
   return metrics_name;
 }
 
 void CastMetricsHelper::SetMetricsSink(MetricsSink* delegate) {
   MAKE_SURE_THREAD(SetMetricsSink, delegate);
   metrics_sink_ = delegate;
 }
 
 void CastMetricsHelper::SetRecordActionCallback(
       const RecordActionCallback& callback) {
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   record_action_callback_ = callback;
 }
 
 void CastMetricsHelper::RecordSimpleAction(const std::string& action) {
   MAKE_SURE_THREAD(RecordSimpleAction, action);
 
   if (metrics_sink_) {
     metrics_sink_->OnAction(action);
   } else {
     record_action_callback_.Run(action);
@@ skipping 30 matching lines @@
     const base::TimeDelta& value) {
   // Follow UMA_HISTOGRAM_MEDIUM_TIMES definition.
   LogTimeHistogramEvent(name, value,
                         base::TimeDelta::FromMilliseconds(10),
                         base::TimeDelta::FromMinutes(3),
                         50);
 }
 
 }  // namespace metrics
 }  // namespace chromecast