memory-infra: Finish moving memory_infra from TracingController

services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc

Index: services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc
diff --git a/services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc b/services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc
index 7072b6775487065afc73b76e77c2a5084d60d0d0..4e023284036d5d361284a2751227a944e25c2335 100644
--- a/services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc
+++ b/services/resource_coordinator/public/cpp/memory/memory_dump_manager_delegate_impl.cc
@@ -4,6 +4,11 @@
 
 #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"
@@ -12,24 +17,68 @@
 
 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_;
 }
@@ -43,7 +92,34 @@ void MemoryDumpManagerDelegateImpl::RequestProcessMemoryDump(
 void MemoryDumpManagerDelegateImpl::RequestGlobalMemoryDump(
     const base::trace_event::MemoryDumpRequestArgs& args,
     const base::trace_event::MemoryDumpCallback& callback) {
-  coordinator_->RequestGlobalMemoryDump(args, callback);
+  {
+    base::AutoLock lock(pending_memory_dump_guid_lock_);
+    if (pending_memory_dump_guid_) {
+      callback.Run(args.dump_guid, false);

[ssid, 2017/02/23 20:21:50]

Sorry if I am mis-remembering something. But, how does this work in the browser
process? Currently we trigger periodic dumps in browser process and if we get
explicit triggers when the dump is in progress then we queue the memory dump.
But now with this change we would not queue the requests in browser process,
which is not expected. Right? We want to continue queuing requests in browser.

What I think should be done here is we get rid of the logic about the pending
memory dump guid and always queue the memory dumps from all process. Unless we
check for is_coordinator_ here and do it differently for each process to keep it
consistent with the current state where the queueing is not done in child and
done in browser.

[chiniforooshan, 2017/02/24 15:51:03]

As discussed, I'll change this to match the current behaviour, that is not
dropping parallel requests for the browser process and dropping them for child
processes. Parallel requests from the browser will be queued by the coordinator
service.

I will fix things to queue requests in every processes in a follow up CL. A TODO
is added.

+      return;
+    }
+    pending_memory_dump_guid_ = args.dump_guid;
+  }
+
+  auto callback_proxy = base::Bind(&MemoryDumpManagerDelegateImpl::OnMemoryDump,
+                                   base::Unretained(this), callback);
+  if (task_runner_ && !task_runner_->RunsTasksOnCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&mojom::Coordinator::RequestGlobalMemoryDump,
+                   base::Unretained(coordinator_.get()), args, callback_proxy));
+  } else {
+    coordinator_->RequestGlobalMemoryDump(args, callback_proxy);
+  }
+}
+
+void MemoryDumpManagerDelegateImpl::OnMemoryDump(
+    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);
 }
 
 }  // namespace memory_instrumentation