memory-infra: Finish moving memory_infra from TracingController

services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_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/public/cpp/memory/memory_dump_manager_delegate_impl.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/lazy_instance.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/resource_coordinator/public/cpp/memory/coordinator.h"
 #include "services/resource_coordinator/public/interfaces/memory/memory_instrumentation.mojom.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 
 namespace memory_instrumentation {
 
-MemoryDumpManagerDelegateImpl::MemoryDumpManagerDelegateImpl(
-    service_manager::InterfaceProvider* interface_provider)
-    : is_coordinator_(false), binding_(this) {
+namespace {
+
+base::LazyInstance<MemoryDumpManagerDelegateImpl>::Leaky
+    g_memory_dump_manager_delegate = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static
+MemoryDumpManagerDelegateImpl* MemoryDumpManagerDelegateImpl::GetInstance() {
+  return g_memory_dump_manager_delegate.Pointer();
+}
+
+MemoryDumpManagerDelegateImpl::MemoryDumpManagerDelegateImpl()
+    : initialized_(false),
+      binding_(this),
+      task_runner_(nullptr),
+      pending_memory_dump_guid_(0) {}
+
+MemoryDumpManagerDelegateImpl::~MemoryDumpManagerDelegateImpl() {}
+
+void MemoryDumpManagerDelegateImpl::InitializeWithInterfaceProvider(
+    service_manager::InterfaceProvider* interface_provider) {
+  {
+    base::AutoLock lock(initialized_lock_);
+    DCHECK(!initialized_);
+    initialized_ = true;
+  }
+
+  is_coordinator_ = false;
   interface_provider->GetInterface(mojo::MakeRequest(&coordinator_));
   coordinator_->RegisterProcessLocalDumpManager(
       binding_.CreateInterfacePtrAndBind());
+  base::trace_event::MemoryDumpManager::GetInstance()->Initialize(this);
 }
 
-MemoryDumpManagerDelegateImpl::MemoryDumpManagerDelegateImpl(
-    Coordinator* coordinator)
-    : is_coordinator_(true), binding_(this) {
+void MemoryDumpManagerDelegateImpl::InitializeWithCoordinator(
+    Coordinator* coordinator,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(task_runner);
+  if (!task_runner->RunsTasksOnCurrentThread()) {
+    task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(&MemoryDumpManagerDelegateImpl::InitializeWithCoordinator,
+                   base::Unretained(this), base::Unretained(coordinator),
+                   task_runner));
+    return;
+  }
+
+  {
+    base::AutoLock lock(initialized_lock_);
+    DCHECK(!initialized_);
+    initialized_ = true;
+  }
+
+  task_runner_ = task_runner;
+  is_coordinator_ = true;
   coordinator->BindCoordinatorRequest(mojo::MakeRequest(&coordinator_));
   coordinator_->RegisterProcessLocalDumpManager(
       binding_.CreateInterfacePtrAndBind());
+  base::trace_event::MemoryDumpManager::GetInstance()->Initialize(this);
 }
 
-MemoryDumpManagerDelegateImpl::~MemoryDumpManagerDelegateImpl() {}
-
 bool MemoryDumpManagerDelegateImpl::IsCoordinator() const {
   return is_coordinator_;
 }
 
 void MemoryDumpManagerDelegateImpl::RequestProcessMemoryDump(
     const base::trace_event::MemoryDumpRequestArgs& args,
     const RequestProcessMemoryDumpCallback& callback) {
   MemoryDumpManagerDelegate::CreateProcessDump(args, callback);
 }
 
 void MemoryDumpManagerDelegateImpl::RequestGlobalMemoryDump(
     const base::trace_event::MemoryDumpRequestArgs& args,
     const base::trace_event::MemoryDumpCallback& callback) {
-  coordinator_->RequestGlobalMemoryDump(args, callback);
+  // TODO(chiniforooshan): This condition is here to match the current

[ssid, 2017/02/24 23:19:05]

Match the old behavior? and add "behavior of queuing global dump requests only
in browser process". It is not very clear from the code that it is queuing.
does "the transition" mean moving to mojo?

[chiniforooshan, 2017/02/25 00:04:51]

Yes. Is the new comment more clear?

[ssid, 2017/02/25 16:07:21]

Yes thanks

+  // behaviour. After the transition, we should enable queueing parallel global
+  // memory dump requests by delegates on all processes.
+  if (is_coordinator_) {
+    DCHECK(task_runner_);
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&mojom::Coordinator::RequestGlobalMemoryDump,
+                   base::Unretained(coordinator_.get()), args, callback));
+    return;
+  }
+
+  {
+    base::AutoLock lock(pending_memory_dump_guid_lock_);
+    if (pending_memory_dump_guid_) {
+      callback.Run(args.dump_guid, false);
+      return;
+    }
+    pending_memory_dump_guid_ = args.dump_guid;
+  }
+  DCHECK(!task_runner_);
+  auto callback_proxy =
+      base::Bind(&MemoryDumpManagerDelegateImpl::MemoryDumpCallbackProxy,
+                 base::Unretained(this), callback);
+  coordinator_->RequestGlobalMemoryDump(args, callback_proxy);
+}
+
+void MemoryDumpManagerDelegateImpl::MemoryDumpCallbackProxy(
+    const base::trace_event::MemoryDumpCallback& callback,
+    uint64_t dump_guid,
+    bool success) {
+  DCHECK_NE(0U, pending_memory_dump_guid_);
+  pending_memory_dump_guid_ = 0;
+  callback.Run(dump_guid, success);
+}
+
+void MemoryDumpManagerDelegateImpl::SetAsNonCoordinatorForTesting() {
+  is_coordinator_ = false;
+  task_runner_ = nullptr;
 }
 
 }  // namespace memory_instrumentation