Task Manager should listen to WebContentsObserver::RenderFrameCreated.

content/browser/renderer_host/render_process_host_impl.cc

Index: content/browser/renderer_host/render_process_host_impl.cc
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 39ed616b2f0a89fa5f08c05eb2435d70d5a03295..e31c4daa4956cf147212bff109e3798cfd12170b 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -515,6 +515,51 @@ class WorkerURLLoaderFactoryProviderImpl
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
 };
 
+class RenderProcessHostIsReadyObserver : public RenderProcessHostObserver {
+ public:
+  RenderProcessHostIsReadyObserver(RenderProcessHost* render_process_host,
+                                   base::OnceClosure task)
+      : render_process_host_(render_process_host),
+        task_(std::move(task)),
+        weak_factory_(this) {
+    render_process_host_->AddObserver(this);
+    if (render_process_host_->IsReady())
+      PostTask();
+  }
+
+  ~RenderProcessHostIsReadyObserver() override {
+    render_process_host_->RemoveObserver(this);
+  }
+
+  void RenderProcessReady(RenderProcessHost* host) override { PostTask(); }
+
+  void RenderProcessHostDestroyed(RenderProcessHost* host) override {
+    delete this;
+  }
+
+ private:
+  void PostTask() {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RenderProcessHostIsReadyObserver::CallTask,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  void CallTask() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    if (render_process_host_->IsReady()) {
+      std::move(task_).Run();
+      delete this;

[ncarter (slow), 2017/05/12 21:56:02]

I'd probably elect to |delete this| unconditionally here, if we get here and the
process has died already. Otherwise the Observer could live on until the user
reloads the page again, at which point the caller would probably queue up
another PostTaskWhenProcessIsReady.

[Łukasz Anforowicz, 2017/05/16 16:37:25]

Done.

I think in the scenario you point out RenderProcessHostDestroyed would be
called.  OTOH, I see that if a process is not ready in CallTask method, then it
will never become ready and there is no point in keeping the observer alive.

+    }
+  }
+
+  RenderProcessHost* render_process_host_;
+  base::OnceClosure task_;
+  base::WeakPtrFactory<RenderProcessHostIsReadyObserver> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderProcessHostIsReadyObserver);
+};
+
 }  // namespace
 
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
@@ -2832,6 +2877,12 @@ size_t RenderProcessHost::GetActiveViewCount() {
   return num_active_views;
 }
 
+void RenderProcessHost::PostTaskWhenProcessIsReady(base::OnceClosure task) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(!task.is_null());
+  new RenderProcessHostIsReadyObserver(this, std::move(task));
+}
+
 void RenderProcessHostImpl::ReleaseOnCloseACK(
     RenderProcessHost* host,
     const SessionStorageNamespaceMap& sessions,