Revert of base: Remove use of MessageLoopProxy

base/trace_event/trace_event_memory.cc

 // Copyright 2013 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 "base/trace_event/trace_event_memory.h"
 
 #include "base/debug/leak_annotations.h"
 #include "base/lazy_instance.h"
-#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
@@ skipping 115 matching lines @@
   // Each item in the trace event stack contains both name and category so tell
   // tcmalloc that we have returned |count| * 2 stack frames.
   return static_cast<int>(count * 2);
 }
 
 }  // namespace
 
 //////////////////////////////////////////////////////////////////////////////
 
 TraceMemoryController::TraceMemoryController(
-    scoped_refptr<SingleThreadTaskRunner> task_runner,
+    scoped_refptr<MessageLoopProxy> message_loop_proxy,
     HeapProfilerStartFunction heap_profiler_start_function,
     HeapProfilerStopFunction heap_profiler_stop_function,
     GetHeapProfileFunction get_heap_profile_function)
-    : task_runner_(task_runner.Pass()),
+    : message_loop_proxy_(message_loop_proxy),
       heap_profiler_start_function_(heap_profiler_start_function),
       heap_profiler_stop_function_(heap_profiler_stop_function),
       get_heap_profile_function_(get_heap_profile_function),
       weak_factory_(this) {
   // Force the "memory" category to show up in the trace viewer.
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("memory"), "init");
   // Watch for the tracing system being enabled.
   TraceLog::GetInstance()->AddEnabledStateObserver(this);
 }
 
 TraceMemoryController::~TraceMemoryController() {
   if (dump_timer_.IsRunning())
     StopProfiling();
   TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
 }
 
 // base::trace_event::TraceLog::EnabledStateChangedObserver overrides:
 void TraceMemoryController::OnTraceLogEnabled() {
   // Check to see if tracing is enabled for the memory category.
   bool enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory"),
                                      &enabled);
   if (!enabled)
     return;
   DVLOG(1) << "OnTraceLogEnabled";
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&TraceMemoryController::StartProfiling,
-                                    weak_factory_.GetWeakPtr()));
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&TraceMemoryController::StartProfiling,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void TraceMemoryController::OnTraceLogDisabled() {
   // The memory category is always disabled before OnTraceLogDisabled() is
   // called, so we cannot tell if it was enabled before. Always try to turn
   // off profiling.
   DVLOG(1) << "OnTraceLogDisabled";
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&TraceMemoryController::StopProfiling,
-                                    weak_factory_.GetWeakPtr()));
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&TraceMemoryController::StopProfiling,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void TraceMemoryController::StartProfiling() {
   // Watch for the tracing framework sending enabling more than once.
   if (dump_timer_.IsRunning())
     return;
   DVLOG(1) << "Starting trace memory";
   if (!InitThreadLocalStorage())
     return;
   ScopedTraceMemory::set_enabled(true);
@@ skipping 229 matching lines @@
   if (!base::HexStringToUInt64(hex_address, &address))
     return "error";
   if (!address)
     return "null";
   // Note that this cast handles 64-bit to 32-bit conversion if necessary.
   return reinterpret_cast<const char*>(address);
 }
 
 }  // namespace trace_event
 }  // namespace base