Add tracing domain to the tab target.

Bug: 1444753
Change-Id: Id0aa449e8ff4b20835bb69e8bd79b1a5ee70db01
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4497759
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Commit-Queue: Danil Somsikov <dsv@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1150723}

content/browser/devtools/browser_devtools_agent_host.cc

@@ -208,7 +208,8 @@ bool BrowserDevToolsAgentHost::AttachSession(DevToolsSession* session,
     session->CreateAndAddHandler<protocol::TetheringHandler>(
         socket_callback_, tethering_task_runner_);
   }
-  session->CreateAndAddHandler<protocol::TracingHandler>(GetIOContext());
+  session->CreateAndAddHandler<protocol::TracingHandler>(
+      protocol::TracingHandler::kBrowser, GetIOContext());
 
 #if BUILDFLAG(CLANG_PROFILING_INSIDE_SANDBOX) && BUILDFLAG(CLANG_PGO)
   session->CreateAndAddHandler<protocol::NativeProfilingHandler>();

content/browser/devtools/devtools_instrumentation.cc

@@ -43,6 +43,7 @@
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_package/signed_exchange_envelope.h"
 #include "content/public/browser/browser_context.h"
+#include "devtools_agent_host_impl.h"
 #include "devtools_instrumentation.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
@@ -94,6 +95,23 @@ void DispatchToAgents(int frame_tree_node_id,
     DispatchToAgents(ftn, method, std::forward<Args>(args)...);
 }
 
+template <typename Handler, typename... MethodArgs, typename... Args>
+void DispatchToAgents(WebContents* web_contents,
+                      void (Handler::*method)(MethodArgs...),
+                      Args&&... args) {
+  auto agent_host = DevToolsAgentHost::GetForTab(web_contents);
+  if (agent_host) {
+    DispatchToAgents(static_cast<DevToolsAgentHostImpl*>(agent_host.get()),
+                     method, std::forward<Args>(args)...);
+  }
+  if (content::DevToolsAgentHost::HasFor(web_contents)) {
+    DispatchToAgents(
+        static_cast<DevToolsAgentHostImpl*>(
+            content::DevToolsAgentHost::GetOrCreateFor(web_contents).get()),
+        method, std::forward<Args>(args)...);
+  }
+}
+
 std::unique_ptr<protocol::Audits::InspectorIssue> BuildHeavyAdIssue(
     const blink::mojom::HeavyAdIssueDetailsPtr& issue_details) {
   protocol::String status =
@@ -1268,10 +1286,11 @@ void DidCreateProcessForAuctionWorklet(RenderFrameHostImpl* owner,
   // TracingHandler lives on the very root, not local root.
   // TODO(morlovich): This may not be right for fenced frames, though
   // that should not currently matter.
-  FrameTreeNode* node = owner->GetMainFrame()->frame_tree_node();
-  if (!node)
+  WebContents* web_contents = WebContents::FromRenderFrameHost(owner);
+  if (!web_contents) {
     return;
-  DispatchToAgents(node, &protocol::TracingHandler::AddProcess, pid);
+  }
+  DispatchToAgents(web_contents, &protocol::TracingHandler::AddProcess, pid);
 }
 
 void WillStartDragging(FrameTreeNode* main_frame_tree_node,

content/browser/devtools/protocol/tracing_handler.cc

@@ -44,6 +44,7 @@
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/tracing_service.h"
+#include "content/public/browser/web_contents.h"
 #include "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_config.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_session.h"
@@ -553,8 +554,11 @@ class TracingHandler::PerfettoTracingSession {
   base::WeakPtrFactory<PerfettoTracingSession> weak_factory_{this};
 };
 
-TracingHandler::TracingHandler(DevToolsIOContext* io_context)
+TracingHandler::TracingHandler(TargetType target_type,
+                               DevToolsIOContext* io_context)
     : DevToolsDomainHandler(Tracing::Metainfo::domainName),
+      target_type_(target_type),
+      web_contents_(nullptr),
       io_context_(io_context),
       did_initiate_recording_(false),
       return_as_stream_(false),
@@ -574,13 +578,21 @@ std::vector<TracingHandler*> TracingHandler::ForAgentHost(
 
 void TracingHandler::SetRenderer(int process_host_id,
                                  RenderFrameHostImpl* frame_host) {
-  frame_host_ = frame_host;
-  if (!frame_host)
+  if (!frame_host) {
     return;
+  }
   video_consumer_->SetFrameSinkId(
       frame_host->GetRenderWidgetHost()->GetFrameSinkId());
 }
 
+void TracingHandler::ConnectWebContents(WebContents* web_contents) {
+  web_contents_ = web_contents;
+}
+
+void TracingHandler::DisconnectWebContents() {
+  web_contents_ = nullptr;
+}
+
 void TracingHandler::Wire(UberDispatcher* dispatcher) {
   frontend_ = std::make_unique<Tracing::Frontend>(dispatcher->channel());
   Tracing::Dispatcher::wire(dispatcher, this);
@@ -858,22 +870,36 @@ perfetto::TraceConfig TracingHandler::CreatePerfettoConfiguration(
 void TracingHandler::SetupProcessFilter(
     base::ProcessId gpu_pid,
     RenderFrameHost* new_render_frame_host) {
-  if (!frame_host_)
+  if (!web_contents_) {
     return;
+  }
 
   base::ProcessId browser_pid = base::Process::Current().Pid();
   pids_being_traced_.insert(browser_pid);
 
   if (gpu_pid != base::kNullProcessId)
     pids_being_traced_.insert(gpu_pid);
 
-  if (new_render_frame_host)
+  if (new_render_frame_host) {
     AppendProcessId(new_render_frame_host, &pids_being_traced_);
-
-  DCHECK(!frame_host_->GetParent());
-  for (FrameTreeNode* node : frame_host_->frame_tree()->Nodes()) {
-    if (RenderFrameHost* frame_host = node->current_frame_host())
-      AppendProcessId(frame_host, &pids_being_traced_);
+  }
+  auto setup_filter_for_frame = [this](RenderFrameHost* rfh) {
+    if (rfh->GetParent()) {
+      return;
+    }
+    RenderFrameHostImpl* rfhi = static_cast<RenderFrameHostImpl*>(rfh);
+    for (FrameTreeNode* node : rfhi->frame_tree()->Nodes()) {
+      if (RenderFrameHost* frame_host = node->current_frame_host()) {
+        AppendProcessId(frame_host, &pids_being_traced_);
+      }
+    }
+  };
+  if (target_type_ == kFrame) {
+    setup_filter_for_frame(web_contents_->GetPrimaryMainFrame());
+  } else if (target_type_ == kTab) {
+    web_contents_->ForEachRenderFrameHost(setup_filter_for_frame);
+  } else {
+    NOTREACHED();
   }
 
   AddPidsToProcessFilter(pids_being_traced_, trace_config_);
@@ -911,8 +937,9 @@ void TracingHandler::AttemptAdoptStartupSession(
     bool gzip_compression,
     bool proto_format,
     perfetto::BackendType tracing_backend) {
-  if (frame_host_ != nullptr)
+  if (target_type_ != kBrowser) {
     return;
+  }
   auto* startup_config = tracing::TraceStartupConfig::GetInstance();
   if (!startup_config->AttemptAdoptBySessionOwner(
           tracing::TraceStartupConfig::SessionOwner::kDevToolsTracingHandler)) {
@@ -1128,17 +1155,28 @@ bool TracingHandler::IsTracing() const {
 
 void TracingHandler::EmitFrameTree() {
   auto data = std::make_unique<base::trace_event::TracedValue>();
-  if (frame_host_) {
-    DCHECK(!frame_host_->GetParent());
-    data->SetInteger("frameTreeNodeId",
-                     frame_host_->frame_tree_node()->frame_tree_node_id());
+  if (target_type_ != kBrowser && web_contents_) {
+    RenderFrameHostImpl* primary_frame_host =
+        static_cast<RenderFrameHostImpl*>(web_contents_->GetPrimaryMainFrame());
+    DCHECK(!primary_frame_host->GetParent());
+    data->SetInteger(
+        "frameTreeNodeId",
+        primary_frame_host->frame_tree_node()->frame_tree_node_id());
     data->SetBoolean("persistentIds", true);
     data->BeginArray("frames");
-    for (FrameTreeNode* node : frame_host_->frame_tree()->Nodes()) {
-      data->BeginDictionary();
-      FillFrameData(data.get(), node, node->current_frame_host(),
-                    node->current_url());
-      data->EndDictionary();
+    auto emit_frames_for_host = [&data](RenderFrameHost* rfh) {
+      RenderFrameHostImpl* rfhi = static_cast<RenderFrameHostImpl*>(rfh);
+      for (FrameTreeNode* node : rfhi->frame_tree()->Nodes()) {
+        data->BeginDictionary();
+        FillFrameData(data.get(), node, node->current_frame_host(),
+                      node->current_url());
+        data->EndDictionary();
+      }
+    };
+    if (target_type_ == kTab) {
+      web_contents_->ForEachRenderFrameHost(emit_frames_for_host);
+    } else {
+      emit_frames_for_host(primary_frame_host);
     }
     data->EndArray();
   }
@@ -1147,6 +1185,23 @@ void TracingHandler::EmitFrameTree() {
                        "data", std::move(data));
 }
 
+void TracingHandler::WillInitiatePrerender(FrameTreeNode* frame_tree_node) {
+  if (!did_initiate_recording_) {
+    return;
+  }
+  auto data = std::make_unique<base::trace_event::TracedValue>();
+  FillFrameData(data.get(), frame_tree_node,
+                frame_tree_node->current_frame_host(),
+                frame_tree_node->current_url());
+  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
+                       "FrameCommittedInBrowser", TRACE_EVENT_SCOPE_THREAD,
+                       "data", std::move(data));
+
+  SetupProcessFilter(base::kNullProcessId,
+                     frame_tree_node->current_frame_host());
+  session_->ChangeTraceConfig(trace_config_);
+}
+
 void TracingHandler::ReadyToCommitNavigation(
     NavigationRequest* navigation_request) {
   if (!did_initiate_recording_)

content/browser/devtools/protocol/tracing_handler.h

@@ -37,6 +37,7 @@ class VideoFrame;
 
 namespace content {
 
+class FrameTreeNode;
 class DevToolsAgentHostImpl;
 class DevToolsVideoConsumer;
 class DevToolsIOContext;
@@ -48,7 +49,9 @@ namespace protocol {
 
 class TracingHandler : public DevToolsDomainHandler, public Tracing::Backend {
  public:
-  CONTENT_EXPORT explicit TracingHandler(DevToolsIOContext* io_context);
+  enum TargetType { kBrowser, kTab, kFrame };
+  CONTENT_EXPORT TracingHandler(TargetType target_type,
+                                DevToolsIOContext* io_context);
 
   TracingHandler(const TracingHandler&) = delete;
   TracingHandler& operator=(const TracingHandler&) = delete;
@@ -63,6 +66,10 @@ class TracingHandler : public DevToolsDomainHandler, public Tracing::Backend {
   // DevToolsDomainHandler implementation.
   void SetRenderer(int process_host_id,
                    RenderFrameHostImpl* frame_host) override;
+  void ConnectWebContents(WebContents* web_contents);
+  void DisconnectWebContents();
+  void WillInitiatePrerender(FrameTreeNode* ftn);
+
   void Wire(UberDispatcher* dispatcher) override;
   Response Disable() override;
 
@@ -147,6 +154,8 @@ class TracingHandler : public DevToolsDomainHandler, public Tracing::Backend {
                                   bool proto_format,
                                   perfetto::BackendType tracing_backend);
 
+  TargetType target_type_;
+  WebContents* web_contents_;
   std::unique_ptr<base::RepeatingTimer> buffer_usage_poll_timer_;
 
   std::unique_ptr<Tracing::Frontend> frontend_;

content/browser/devtools/protocol/tracing_handler_unittest.cc

@@ -77,7 +77,8 @@ const char kCustomTraceConfigStringDevToolsStyle[] =
 class TracingHandlerTest : public testing::Test {
  public:
   void SetUp() override {
-    tracing_handler_ = std::make_unique<TracingHandler>(nullptr);
+    tracing_handler_ =
+        std::make_unique<TracingHandler>(TracingHandler::kBrowser, nullptr);
   }
 
   void TearDown() override { tracing_handler_.reset(); }

content/browser/devtools/render_frame_devtools_agent_host.cc

@@ -373,7 +373,10 @@ bool RenderFrameDevToolsAgentHost::AttachSession(DevToolsSession* session,
       session->GetClient()->MayReadLocalFiles());
   session->CreateAndAddHandler<protocol::SecurityHandler>();
   if (!frame_tree_node_ || !frame_tree_node_->parent()) {
-    session->CreateAndAddHandler<protocol::TracingHandler>(GetIOContext());
+    auto* tracing_handler =
+        session->CreateAndAddHandler<protocol::TracingHandler>(
+            protocol::TracingHandler::kFrame, GetIOContext());
+    tracing_handler->ConnectWebContents(web_contents());
   }
   session->CreateAndAddHandler<protocol::LogHandler>();
   session->CreateAndAddHandler<protocol::FedCmHandler>();
@@ -690,6 +693,9 @@ void RenderFrameDevToolsAgentHost::DidCreateFencedFrame(
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {
   WebContentsObserver::Observe(nullptr);
   navigation_requests_.clear();
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->DisconnectWebContents();
+  }
   SetFrameTreeNode(nullptr);
   // UpdateFrameHost may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
@@ -703,6 +709,9 @@ void RenderFrameDevToolsAgentHost::ConnectWebContents(WebContents* wc) {
       static_cast<RenderFrameHostImpl*>(wc->GetPrimaryMainFrame());
   DCHECK(host);
   WebContentsObserver::Observe(wc);
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->ConnectWebContents(wc);
+  }
   SetFrameTreeNode(host->frame_tree_node());
   UpdateFrameHost(host);
   // UpdateFrameHost may destruct |this|.

content/browser/devtools/web_contents_devtools_agent_host.cc

@@ -7,6 +7,7 @@
 #include "base/unguessable_token.h"
 #include "content/browser/devtools/protocol/target_auto_attacher.h"
 #include "content/browser/devtools/protocol/target_handler.h"
+#include "content/browser/devtools/protocol/tracing_handler.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/portal/portal.h"
 #include "content/browser/renderer_host/frame_tree_node.h"
@@ -170,6 +171,9 @@ void WebContentsDevToolsAgentHost::InnerAttach(WebContents* wc) {
   const bool inserted =
       g_agent_host_instances.Get().insert(std::make_pair(wc, this)).second;
   CHECK(inserted);
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->ConnectWebContents(wc);
+  }
   auto_attacher_->SetWebContents(wc);
   Observe(wc);
   // Once created, persist till underlying WC is detached, so that
@@ -179,6 +183,9 @@ void WebContentsDevToolsAgentHost::InnerAttach(WebContents* wc) {
 
 void WebContentsDevToolsAgentHost::InnerDetach() {
   DCHECK_EQ(this, FindAgentHost(web_contents()));
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->DisconnectWebContents();
+  }
   auto_attacher_->SetWebContents(nullptr);
   g_agent_host_instances.Get().erase(web_contents());
   Observe(nullptr);
@@ -204,6 +211,9 @@ void WebContentsDevToolsAgentHost::PortalActivated(const Portal& portal) {
 
 void WebContentsDevToolsAgentHost::WillInitiatePrerender(FrameTreeNode* ftn) {
   auto_attacher_->WillInitiatePrerender(ftn);
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->WillInitiatePrerender(ftn);
+  }
 }
 
 void WebContentsDevToolsAgentHost::UpdateChildFrameTrees(
@@ -364,6 +374,21 @@ void WebContentsDevToolsAgentHost::RenderFrameHostChanged(
   }
 }
 
+void WebContentsDevToolsAgentHost::ReadyToCommitNavigation(
+    NavigationHandle* navigation_handle) {
+  CHECK(web_contents());
+  NavigationRequest* request = NavigationRequest::From(navigation_handle);
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->ReadyToCommitNavigation(request);
+  }
+}
+
+void WebContentsDevToolsAgentHost::FrameDeleted(int frame_tree_node_id) {
+  for (auto* tracing : protocol::TracingHandler::ForAgentHost(this)) {
+    tracing->FrameDeleted(frame_tree_node_id);
+  }
+}
+
 // DevToolsAgentHostImpl overrides.
 DevToolsSession::Mode WebContentsDevToolsAgentHost::GetSessionMode() {
   return DevToolsSession::Mode::kSupportsTabTarget;
@@ -382,6 +407,8 @@ bool WebContentsDevToolsAgentHost::AttachSession(DevToolsSession* session,
           ? protocol::TargetHandler::AccessMode::kRegular
           : protocol::TargetHandler::AccessMode::kAutoAttachOnly,
       GetId(), auto_attacher_.get(), session);
+  session->CreateAndAddHandler<protocol::TracingHandler>(
+      protocol::TracingHandler::kTab, GetIOContext());
   return true;
 }
 

content/browser/devtools/web_contents_devtools_agent_host.h

@@ -84,6 +84,8 @@ class CONTENT_EXPORT WebContentsDevToolsAgentHost
   void WebContentsDestroyed() override;
   void RenderFrameHostChanged(RenderFrameHost* old_host,
                               RenderFrameHost* new_host) override;
+  void ReadyToCommitNavigation(NavigationHandle* navigation_handle) override;
+  void FrameDeleted(int frame_tree_node_id) override;
 
   DevToolsAgentHostImpl* GetPrimaryFrameAgent();
   scoped_refptr<DevToolsAgentHost> GetOrCreatePrimaryFrameAgent();

third_party/blink/web_tests/FlagExpectations/disable-site-isolation-trials

@@ -149,3 +149,5 @@ crbug.com/626703 external/wpt/infrastructure/channels/test_serialize.html [ Time
 # reenable print ref tests
 crbug.com/1090628 external/wpt/html/browsers/windows/iframe-cross-origin-print.sub.html [ Pass ]
 crbug.com/1090628 external/wpt/html/browsers/windows/iframe-cross-origin-scaled-print.sub.html [ Pass ]
+
+crbug.com/1444753 http/tests/inspector-protocol/tracing/prerender.js [ Skip ]

third_party/blink/web_tests/http/tests/inspector-protocol/tracing/prerender-expected.txt

@@ -0,0 +1,6 @@
+Test that prerender page is included in the trace events
+Recording started
+Tracing complete
+Got prerender frame: true
+Got parse prerender HTML: true
+