Add a static getter for ChildMemoryCoordinator

components/memory_coordinator/child/child_memory_coordinator_impl.cc

Index: components/memory_coordinator/child/child_memory_coordinator_impl.cc
diff --git a/components/memory_coordinator/child/child_memory_coordinator_impl.cc b/components/memory_coordinator/child/child_memory_coordinator_impl.cc
index 1e4a9c8ecd22df7664935112f75398660279c1ba..75dd8ed5243e46e1ee1cec024a90a67f034a700d 100644
--- a/components/memory_coordinator/child/child_memory_coordinator_impl.cc
+++ b/components/memory_coordinator/child/child_memory_coordinator_impl.cc
@@ -4,17 +4,39 @@
 
 #include "components/memory_coordinator/child/child_memory_coordinator_impl.h"
 
+#include "base/lazy_instance.h"
+#include "base/synchronization/lock.h"
+
 namespace memory_coordinator {
 
+namespace {
+
+base::LazyInstance<base::Lock>::Leaky g_lock = LAZY_INSTANCE_INITIALIZER;

[bashi, 2016/08/29 09:52:06]

Not sure we really need a lock. Can be removed when all callsites access the
getter only RenderTreadImpl is alive.

[haraken, 2016/09/01 18:49:10]

I begin to think that ChildMemoryCoordinator must be accessed only on the main
thread. Calling RegisterClient/UnregisterClient on a non-main thread would not
be a safe thing. Even if we make the registration/unregistration thread-safe,
it's still not safe to call OnMemoryStateChange on a non-main thread.

So I think we should add DCHECK(isMainThread()) instead of adding a lock.

[bashi, 2016/09/01 22:53:39]

Making ChildMemoryCoordinator only accessible via the main thread seems fine to
me, but registerClient/unregisterClient is thread-safe now as we use
base::ObserverListThreadSafe<MemoryCoordinatorClient>. OnStateChange() will be
called on the thread registerClient() is called.

At this point I don't think we need DCHECK(isMainThread()).

If we want CMC be accessible only on the main thread, we need to provide a way
to specify which thread OnStateChange() should be called.

+ChildMemoryCoordinatorImpl* g_child_memory_coordinator = nullptr;
+
+}  // namespace
+
+// static
+ChildMemoryCoordinatorImpl* ChildMemoryCoordinatorImpl::GetInstance() {
+  base::AutoLock lock(*g_lock.Pointer());
+  return g_child_memory_coordinator;
+}
+
 ChildMemoryCoordinatorImpl::ChildMemoryCoordinatorImpl(
     mojom::MemoryCoordinatorHandlePtr parent,
     ChildMemoryCoordinatorDelegate* delegate)
     : binding_(this), parent_(std::move(parent)), delegate_(delegate) {
+  base::AutoLock lock(*g_lock.Pointer());
   DCHECK(delegate_);
+  DCHECK(!g_child_memory_coordinator);
+  g_child_memory_coordinator = this;
   parent_->AddChild(binding_.CreateInterfacePtrAndBind());
 }
 
 ChildMemoryCoordinatorImpl::~ChildMemoryCoordinatorImpl() {
+  base::AutoLock lock(*g_lock.Pointer());
+  DCHECK(g_child_memory_coordinator == this);
+  g_child_memory_coordinator = nullptr;
 }
 
 void ChildMemoryCoordinatorImpl::OnStateChange(mojom::MemoryState state) {