DevTools: Restore GPU tasks recording in performance profiles.

Add GPU process pid to the list of processes where tracing is enabled.

Change-Id: Ic401ee4ea7d218cad36f687be226d092cd4e54a0
Reviewed-on: https://chromium-review.googlesource.com/1182304
Commit-Queue: Alexei Filippov <alph@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#585301}

content/browser/devtools/protocol/tracing_handler.cc

@@ -34,6 +34,7 @@
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/browser_thread.h"
@@ -404,7 +405,28 @@ void TracingHandler::Start(Maybe<std::string> categories,
                                                    options.fromMaybe(""));
   }
 
-  SetupProcessFilter(nullptr);
+  // GPU process id can only be retrieved on IO thread. Do some thread hopping.
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO, FROM_HERE, base::BindOnce([]() {
+        GpuProcessHost* gpu_process_host = GpuProcessHost::Get();
+        return gpu_process_host ? gpu_process_host->GetProcessId()
+                                : base::kNullProcessId;
+      }),
+      base::BindOnce(&TracingHandler::StartTracingWithGpuPid,
+                     weak_factory_.GetWeakPtr(), std::move(callback)));
+}
+
+void TracingHandler::StartTracingWithGpuPid(
+    std::unique_ptr<StartCallback> callback,
+    base::ProcessId gpu_pid) {
+  // Check if tracing was stopped in mid-air.
+  if (!did_initiate_recording_) {
+    callback->sendFailure(Response::Error(
+        "Tracing was stopped before start has been completed."));
+    return;
+  }
+
+  SetupProcessFilter(gpu_pid, nullptr);
 
   TracingController::GetInstance()->StartTracing(
       trace_config_, base::BindRepeating(&TracingHandler::OnRecordingEnabled,
@@ -413,14 +435,20 @@ void TracingHandler::Start(Maybe<std::string> categories,
 }
 
 void TracingHandler::SetupProcessFilter(
+    base::ProcessId gpu_pid,
     RenderFrameHost* new_render_frame_host) {
   if (!frame_tree_node_)
     return;
 
   base::ProcessId browser_pid = base::Process::Current().Pid();
   std::unordered_set<base::ProcessId> included_process_ids({browser_pid});
+
+  if (gpu_pid != base::kNullProcessId)
+    included_process_ids.insert(gpu_pid);
+
   if (new_render_frame_host)
     AppendProcessId(new_render_frame_host, &included_process_ids);
+
   for (FrameTreeNode* node :
        frame_tree_node_->frame_tree()->SubtreeNodes(frame_tree_node_)) {
     RenderFrameHost* frame_host = node->current_frame_host();
@@ -495,8 +523,13 @@ void TracingHandler::GetCategories(
 
 void TracingHandler::OnRecordingEnabled(
     std::unique_ptr<StartCallback> callback) {
-  EmitFrameTree();
+  if (!did_initiate_recording_) {
+    callback->sendFailure(Response::Error(
+        "Tracing was stopped before start has been completed."));
+    return;
+  }
 
+  EmitFrameTree();
   callback->sendSuccess();
 
   bool screenshot_enabled;
@@ -646,7 +679,8 @@ void TracingHandler::ReadyToCommitNavigation(
                        "FrameCommittedInBrowser", TRACE_EVENT_SCOPE_THREAD,
                        "data", std::move(data));
 
-  SetupProcessFilter(navigation_handle->GetRenderFrameHost());
+  SetupProcessFilter(base::kNullProcessId,
+                     navigation_handle->GetRenderFrameHost());
   TracingController::GetInstance()->StartTracing(
       trace_config_, base::RepeatingCallback<void()>());
 }

content/browser/devtools/protocol/tracing_handler.h

@@ -116,7 +116,9 @@ class TracingHandler : public DevToolsDomainHandler, public Tracing::Backend {
   CONTENT_EXPORT static base::trace_event::TraceConfig
       GetTraceConfigFromDevToolsConfig(
           const base::DictionaryValue& devtools_config);
-  void SetupProcessFilter(RenderFrameHost*);
+  void SetupProcessFilter(base::ProcessId gpu_pid, RenderFrameHost*);
+  void StartTracingWithGpuPid(std::unique_ptr<StartCallback>,
+                              base::ProcessId gpu_pid);
   void AppendProcessId(RenderFrameHost*,
                        std::unordered_set<base::ProcessId>* process_set);
   void OnProcessReady(RenderProcessHost*);

content/browser/gpu/gpu_process_host.cc

@@ -677,6 +677,10 @@ GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   return nullptr;
 }
 
+base::ProcessId GpuProcessHost::GetProcessId() const {
+  return initialized_ ? process_->GetProcess().Pid() : base::kNullProcessId;
+}
+
 // static
 int GpuProcessHost::GetGpuCrashCount() {
   return static_cast<int>(base::subtle::NoBarrier_Load(&gpu_crash_count_));

content/browser/gpu/gpu_process_host.h

@@ -118,6 +118,7 @@ class GpuProcessHost : public BrowserChildProcessHostDelegate,
   // null if the process no longer exists.
   static GpuProcessHost* FromID(int host_id);
   int host_id() const { return host_id_; }
+  base::ProcessId GetProcessId() const;
 
   // IPC::Sender implementation.
   bool Send(IPC::Message* msg) override;

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-gpu-tasks-expected.txt

+Tests the Timeline events for GPUTask
+
+Found GPUTask events: true
+

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-gpu-tasks.js

+// Copyright 2018 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.
+
+(async function() {
+  TestRunner.addResult(`Tests the Timeline events for GPUTask\n`);
+  await TestRunner.loadModule('performance_test_runner');
+  await TestRunner.showPanel('timeline');
+  await TestRunner.evaluateInPagePromise(`
+      async function performActions() {
+        const gl = document.createElement('canvas').getContext('webgl');
+        return gl.getParameter(gl.MAX_VIEWPORT_DIMS);
+      }
+  `);
+
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
+
+  const tracingModel = PerformanceTestRunner.tracingModel();
+  const hasGPUTasks = tracingModel.sortedProcesses().some(p => p.sortedThreads().some(t => t.events().some(
+      event => event.name === TimelineModel.TimelineModel.RecordType.GPUTask)));
+  TestRunner.addResult(`Found GPUTask events: ${hasGPUTasks}`);
+
+  TestRunner.completeTest();
+})();

third_party/WebKit/LayoutTests/inspector-protocol/timeline/tracing-process-filter-expected.txt

@@ -2,5 +2,5 @@ Tests that tracing does not record unrelated processes.
 Recording started
 Another page
 Tracing complete
-There should be just 2 processes (browser and renderer): 2
+There should be just 3 processes (browser, GPU, and renderer): 3
 

third_party/WebKit/LayoutTests/inspector-protocol/timeline/tracing-process-filter.js

@@ -16,7 +16,7 @@
   const pids = new Set();
   for (const event of events)
     pids.add(event.pid);
-  testRunner.log(`There should be just 2 processes (browser and renderer): ${pids.size}`);
+  testRunner.log(`There should be just 3 processes (browser, GPU, and renderer): ${pids.size}`);
 
   testRunner.completeTest();
 })