memory-infra: Finish moving memory_infra from TracingController

services/resource_coordinator/memory/coordinator/coordinator_impl.cc

 // Copyright 2017 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 "services/resource_coordinator/memory/coordinator/coordinator_impl.h"
 
+#include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_request_args.h"
+#include "services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.h"
 #include "services/resource_coordinator/public/interfaces/memory/memory_instrumentation.mojom.h"
 
 namespace memory_instrumentation {
 
 namespace {
 
 base::LazyInstance<CoordinatorImpl>::Leaky g_coordinator =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
-CoordinatorImpl* CoordinatorImpl::GetInstance() {
-  return g_coordinator.Pointer();
+CoordinatorImpl* CoordinatorImpl::GetInstance(
+    base::SingleThreadTaskRunner* task_runner) {
+  CoordinatorImpl* out = g_coordinator.Pointer();
+  out->Initialize(task_runner);
+  return out;
 }
 
-// TODO(chiniforooshan): Initialize the global MemoryDumpManager instance here.
-// This is how the global MemoryDumpManager gets a reference to the delegate on
-// the service (read the browser) process for service process memory dumps. This
-// can be done when the delegate implementation is landed.
-CoordinatorImpl::CoordinatorImpl() : failed_memory_dump_count_(0) {}
+CoordinatorImpl::CoordinatorImpl()
+    : failed_memory_dump_count_(0), task_runner_(nullptr) {}
 
 CoordinatorImpl::~CoordinatorImpl() {}
 
+void CoordinatorImpl::Initialize(base::SingleThreadTaskRunner* task_runner) {

[Primiano Tucci (use gerrit), 2017/02/17 19:08:44]

Hmm you should't keep pointers to the TaskRunner themselves as they are proxy
objects and can be short lived. Instead you should have your own
scoped_refptr<STTR>.
That wil NOT keep the taskrunner alive, but will give you a long lived proxy
(and PostTask will fail if the taskrunner goes away)

[chiniforooshan, 2017/02/22 05:16:34]

Done.

+  DCHECK(!task_runner_ || task_runner_ == task_runner);
+  if (!task_runner_) {
+    task_runner_ = task_runner;
+    if (task_runner->RunsTasksOnCurrentThread()) {
+      InitializeMemoryDumpManager();
+    } else {
+      task_runner->PostTask(
+          FROM_HERE, base::Bind(&CoordinatorImpl::InitializeMemoryDumpManager,
+                                base::Unretained(this)));
+    }
+  }
+}
+
+void CoordinatorImpl::InitializeForTest(
+    base::SingleThreadTaskRunner* task_runner) {
+  task_runner_ = task_runner;
+}
+
+void CoordinatorImpl::InitializeMemoryDumpManager() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  auto delegate =
+      base::MakeUnique<memory_instrumentation::MemoryDumpManagerDelegateImpl>(
+          this, task_runner_);
+  base::trace_event::MemoryDumpManager::GetInstance()->Initialize(
+      std::move(delegate));
+}
+
 void CoordinatorImpl::BindCoordinatorRequest(
     mojom::CoordinatorRequest request) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   bindings_.AddBinding(this, std::move(request));
 }
 
 CoordinatorImpl::QueuedMemoryDumpRequest::QueuedMemoryDumpRequest(
     const base::trace_event::MemoryDumpRequestArgs args,
     const RequestGlobalMemoryDumpCallback callback)
     : args(args), callback(callback) {}
 
 CoordinatorImpl::QueuedMemoryDumpRequest::~QueuedMemoryDumpRequest() {}
 
 void CoordinatorImpl::RequestGlobalMemoryDump(
     const base::trace_event::MemoryDumpRequestArgs& args,
     const RequestGlobalMemoryDumpCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   bool another_dump_already_in_progress = !queued_memory_dump_requests_.empty();
 
   // If this is a periodic memory dump request and there already is another
   // request in the queue with the same level of detail, there's no point in
   // enqueuing this request.
   if (another_dump_already_in_progress &&
       args.dump_type == base::trace_event::MemoryDumpType::PERIODIC_INTERVAL) {
     for (const auto& request : queued_memory_dump_requests_) {
       if (request.args.level_of_detail == args.level_of_detail) {
         VLOG(1) << base::trace_event::MemoryDumpManager::kLogPrefix << " ("
@@ skipping 14 matching lines @@
   // If another dump is already in progress, this dump will automatically be
   // scheduled when the other dump finishes.
   if (another_dump_already_in_progress)
     return;
 
   PerformNextQueuedGlobalMemoryDump();
 }
 
 void CoordinatorImpl::RegisterProcessLocalDumpManager(
     mojom::ProcessLocalDumpManagerPtr process_manager) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   process_manager.set_connection_error_handler(
       base::Bind(&CoordinatorImpl::UnregisterProcessLocalDumpManager,
                  base::Unretained(this), process_manager.get()));
   auto result = process_managers_.insert(
       std::make_pair<mojom::ProcessLocalDumpManager*,
                      mojom::ProcessLocalDumpManagerPtr>(
           process_manager.get(), std::move(process_manager)));
   DCHECK(result.second);
 }
 
 void CoordinatorImpl::UnregisterProcessLocalDumpManager(
     mojom::ProcessLocalDumpManager* process_manager) {
-  DCHECK(process_managers_.erase(process_manager) == 1);
+  size_t num_deleted = process_managers_.erase(process_manager);
+  DCHECK(num_deleted == 1);
 
   // Check if we are waiting for an ack from this process-local manager.
   if (pending_process_managers_.find(process_manager) !=
       pending_process_managers_.end()) {
     DCHECK(!queued_memory_dump_requests_.empty());
     OnProcessMemoryDumpResponse(
         process_manager, queued_memory_dump_requests_.front().args.dump_guid,
         false /* success */);
   }
 }
@@ skipping 56 matching lines @@
   // Schedule the next queued dump (if applicable).
   if (!queued_memory_dump_requests_.empty()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&CoordinatorImpl::PerformNextQueuedGlobalMemoryDump,
                    base::Unretained(this)));
   }
 }
 
 }  // namespace memory_instrumentation