PM: Add the frame token to FrameNode.

Bug: 1096543
Change-Id: I87a723e23fe4454eb54704f3bd6b35f5085c63d9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2252692Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Commit-Queue: Sigurður Ásgeirsson <siggi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#780300}

chrome/browser/performance_manager/observers/isolation_context_metrics_unittest.cc

@@ -82,7 +82,8 @@ class IsolationContextMetricsTest : public GraphTestHarness {
     return CreateNode<FrameNodeImpl>(
         process_node, page_node, parent_frame_node, 0 /* frame_tree_node_id */,
         ++next_render_frame_id_, base::UnguessableToken::Create(),
-        browsing_instance_id, site_instance_id);
+        FrameToken(base::UnguessableToken::Create()), browsing_instance_id,
+        site_instance_id);
   }
 
   // Advance time until the timer fires.

components/performance_manager/graph/frame_node_impl.cc

@@ -27,6 +27,7 @@ FrameNodeImpl::FrameNodeImpl(ProcessNodeImpl* process_node,
                              int frame_tree_node_id,
                              int render_frame_id,
                              const base::UnguessableToken& dev_tools_token,
+                             const FrameToken& frame_token,
                              int32_t browsing_instance_id,
                              int32_t site_instance_id)
     : parent_frame_node_(parent_frame_node),
@@ -35,6 +36,7 @@ FrameNodeImpl::FrameNodeImpl(ProcessNodeImpl* process_node,
       frame_tree_node_id_(frame_tree_node_id),
       render_frame_id_(render_frame_id),
       dev_tools_token_(dev_tools_token),
+      frame_token_(frame_token),
       browsing_instance_id_(browsing_instance_id),
       site_instance_id_(site_instance_id),
       render_frame_host_proxy_(content::GlobalFrameRoutingId(
@@ -140,6 +142,10 @@ const base::UnguessableToken& FrameNodeImpl::dev_tools_token() const {
   return dev_tools_token_;
 }
 
+const FrameToken& FrameNodeImpl::frame_token() const {
+  return frame_token_;
+}
+
 int32_t FrameNodeImpl::browsing_instance_id() const {
   return browsing_instance_id_;
 }
@@ -374,6 +380,11 @@ const base::UnguessableToken& FrameNodeImpl::GetDevToolsToken() const {
   return dev_tools_token();
 }
 
+const FrameToken& FrameNodeImpl::GetFrameToken() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return frame_token();
+}
+
 int32_t FrameNodeImpl::GetBrowsingInstanceId() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return browsing_instance_id();

components/performance_manager/graph/frame_node_impl.h

@@ -66,6 +66,7 @@ class FrameNodeImpl
                 int frame_tree_node_id,
                 int render_frame_id,
                 const base::UnguessableToken& dev_tools_token,
+                const FrameToken& frame_token,
                 int32_t browsing_instance_id,
                 int32_t site_instance_id);
   ~FrameNodeImpl() override;
@@ -94,6 +95,7 @@ class FrameNodeImpl
   int frame_tree_node_id() const;
   int render_frame_id() const;
   const base::UnguessableToken& dev_tools_token() const;
+  const FrameToken& frame_token() const;
   int32_t browsing_instance_id() const;
   int32_t site_instance_id() const;
   const RenderFrameHostProxy& render_frame_host_proxy() const;
@@ -160,6 +162,7 @@ class FrameNodeImpl
   const ProcessNode* GetProcessNode() const override;
   int GetFrameTreeNodeId() const override;
   const base::UnguessableToken& GetDevToolsToken() const override;
+  const FrameToken& GetFrameToken() const override;
   int32_t GetBrowsingInstanceId() const override;
   int32_t GetSiteInstanceId() const override;
   bool VisitChildFrameNodes(const FrameNodeVisitor& visitor) const override;
@@ -255,6 +258,11 @@ class FrameNodeImpl
   // is never sent back from the renderer in control calls. It should never be
   // used to look up the FrameTreeNode instance.
   const base::UnguessableToken dev_tools_token_;
+
+  // This is the unique token for this frame instance as per e.g.
+  // RenderFrameHost::GetFrameToken().
+  const FrameToken frame_token_;
+
   // The unique ID of the BrowsingInstance this frame belongs to. Frames in the
   // same BrowsingInstance are allowed to script each other at least
   // asynchronously (if cross-site), and sometimes synchronously (if same-site,

components/performance_manager/graph/frame_node_impl_unittest.cc

@@ -399,6 +399,7 @@ TEST_F(FrameNodeImplTest, PublicInterface) {
             public_frame_node->GetFrameTreeNodeId());
   EXPECT_EQ(frame_node->dev_tools_token(),
             public_frame_node->GetDevToolsToken());
+  EXPECT_EQ(frame_node->frame_token(), public_frame_node->GetFrameToken());
   EXPECT_EQ(frame_node->browsing_instance_id(),
             public_frame_node->GetBrowsingInstanceId());
   EXPECT_EQ(frame_node->site_instance_id(),

components/performance_manager/performance_manager_impl.cc

@@ -118,12 +118,13 @@ std::unique_ptr<FrameNodeImpl> PerformanceManagerImpl::CreateFrameNode(
     int frame_tree_node_id,
     int render_frame_id,
     const base::UnguessableToken& dev_tools_token,
+    const FrameToken& frame_token,
     int32_t browsing_instance_id,
     int32_t site_instance_id,
     FrameNodeCreationCallback creation_callback) {
   return CreateNodeImpl<FrameNodeImpl>(
       std::move(creation_callback), process_node, page_node, parent_frame_node,
-      frame_tree_node_id, render_frame_id, dev_tools_token,
+      frame_tree_node_id, render_frame_id, dev_tools_token, frame_token,
       browsing_instance_id, site_instance_id);
 }
 

components/performance_manager/performance_manager_impl.h

@@ -17,6 +17,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "components/performance_manager/graph/graph_impl.h"
+#include "components/performance_manager/public/graph/frame_node.h"
 #include "components/performance_manager/public/graph/worker_node.h"
 #include "components/performance_manager/public/performance_manager.h"
 #include "components/performance_manager/public/render_process_host_proxy.h"
@@ -92,6 +93,7 @@ class PerformanceManagerImpl : public PerformanceManager {
       int frame_tree_node_id,
       int render_frame_id,
       const base::UnguessableToken& dev_tools_token,
+      const FrameToken& frame_token,
       int32_t browsing_instance_id,
       int32_t site_instance_id,
       FrameNodeCreationCallback creation_callback =

components/performance_manager/performance_manager_impl_unittest.cc

@@ -64,7 +64,8 @@ TEST_F(PerformanceManagerImplTest, InstantiateNodes) {
   std::unique_ptr<FrameNodeImpl> frame_node =
       PerformanceManagerImpl::CreateFrameNode(
           process_node.get(), page_node.get(), nullptr, 0,
-          ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0);
+          ++next_render_frame_id, base::UnguessableToken::Create(),
+          FrameToken(base::UnguessableToken::Create()), 0, 0);
   EXPECT_NE(nullptr, frame_node.get());
 
   PerformanceManagerImpl::DeleteNode(std::move(frame_node));
@@ -86,29 +87,35 @@ TEST_F(PerformanceManagerImplTest, BatchDeleteNodes) {
   std::unique_ptr<FrameNodeImpl> parent1_frame =
       PerformanceManagerImpl::CreateFrameNode(
           process_node.get(), page_node.get(), nullptr, 0,
-          ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0);
+          ++next_render_frame_id, base::UnguessableToken::Create(),
+          FrameToken(base::UnguessableToken::Create()), 0, 0);
   std::unique_ptr<FrameNodeImpl> parent2_frame =
       PerformanceManagerImpl::CreateFrameNode(
           process_node.get(), page_node.get(), nullptr, 1,
-          ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0);
+          ++next_render_frame_id, base::UnguessableToken::Create(),
+          FrameToken(base::UnguessableToken::Create()), 0, 0);
 
   std::unique_ptr<FrameNodeImpl> child1_frame =
       PerformanceManagerImpl::CreateFrameNode(
           process_node.get(), page_node.get(), parent1_frame.get(), 2,
-          ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0);
+          ++next_render_frame_id, base::UnguessableToken::Create(),
+          FrameToken(base::UnguessableToken::Create()), 0, 0);
   std::unique_ptr<FrameNodeImpl> child2_frame =
       PerformanceManagerImpl::CreateFrameNode(
           process_node.get(), page_node.get(), parent2_frame.get(), 3,
-          ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0);
+          ++next_render_frame_id, base::UnguessableToken::Create(),
+          FrameToken(base::UnguessableToken::Create()), 0, 0);
 
   std::vector<std::unique_ptr<NodeBase>> nodes;
   for (size_t i = 0; i < 10; ++i) {
     nodes.push_back(PerformanceManagerImpl::CreateFrameNode(
         process_node.get(), page_node.get(), child1_frame.get(), 0,
-        ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0));
+        ++next_render_frame_id, base::UnguessableToken::Create(),
+        FrameToken(base::UnguessableToken::Create()), 0, 0));
     nodes.push_back(PerformanceManagerImpl::CreateFrameNode(
         process_node.get(), page_node.get(), child1_frame.get(), 1,
-        ++next_render_frame_id, base::UnguessableToken::Create(), 0, 0));
+        ++next_render_frame_id, base::UnguessableToken::Create(),
+        FrameToken(base::UnguessableToken::Create()), 0, 0));
   }
 
   nodes.push_back(std::move(process_node));

components/performance_manager/performance_manager_tab_helper.cc

@@ -167,6 +167,7 @@ void PerformanceManagerTabHelper::RenderFrameCreated(
           render_frame_host->GetFrameTreeNodeId(),
           render_frame_host->GetRoutingID(),
           render_frame_host->GetDevToolsFrameToken(),
+          FrameToken(render_frame_host->GetFrameToken()),
           site_instance->GetBrowsingInstanceId(), site_instance->GetId(),
           base::BindOnce(
               [](const GURL& url, bool is_current, FrameNodeImpl* frame_node) {

components/performance_manager/public/graph/frame_node.h

@@ -7,6 +7,7 @@
 
 #include "base/containers/flat_set.h"
 #include "base/macros.h"
+#include "base/util/type_safety/strong_alias.h"
 #include "components/performance_manager/public/frame_priority/frame_priority.h"
 #include "components/performance_manager/public/graph/node.h"
 #include "components/performance_manager/public/mojom/coordination_unit.mojom.h"
@@ -26,6 +27,10 @@ class ProcessNode;
 class RenderFrameHostProxy;
 class WorkerNode;
 
+// A strongly typed unguessable token for the frame tokens.
+using FrameToken =
+    util::StrongAlias<class FrameTokenTag, base::UnguessableToken>;
+
 // Frame nodes form a tree structure, each FrameNode at most has one parent that
 // is a FrameNode. Conceptually, a frame corresponds to a
 // content::RenderFrameHost in the browser, and a content::RenderFrameImpl /
@@ -89,6 +94,10 @@ class FrameNode : public Node {
   // the lifetime of the frame.
   virtual const base::UnguessableToken& GetDevToolsToken() const = 0;
 
+  // Gets the unique token associated with this frame. This is a constant over
+  // the lifetime of the frame and unique across all frames for all time.
+  virtual const FrameToken& GetFrameToken() const = 0;
+
   // Gets the ID of the browsing instance to which this frame belongs. This is a
   // constant over the lifetime of the frame.
   virtual int32_t GetBrowsingInstanceId() const = 0;

components/performance_manager/test_support/graph_test_harness.h

@@ -79,12 +79,16 @@ struct TestNodeWrapper<FrameNodeImpl>::Factory {
       FrameNodeImpl* parent_frame_node,
       int frame_tree_node_id,
       int render_frame_id,
-      const base::UnguessableToken& token = base::UnguessableToken::Create(),
+      const base::UnguessableToken& dev_tools_token =
+          base::UnguessableToken::Create(),
+      const FrameToken& frame_token =
+          FrameToken(base::UnguessableToken::Create()),
       int32_t browsing_instance_id = 0,
       int32_t site_instance_id = 0) {
     return std::make_unique<FrameNodeImpl>(
         process_node, page_node, parent_frame_node, frame_tree_node_id,
-        render_frame_id, token, browsing_instance_id, site_instance_id);
+        render_frame_id, dev_tools_token, frame_token, browsing_instance_id,
+        site_instance_id);
   }
 };
 

components/performance_manager/worker_watcher_unittest.cc

@@ -557,7 +557,8 @@ content::GlobalFrameRoutingId TestFrameNodeSource::CreateFrameNode(
                                                      frame_id);
   auto frame_node = PerformanceManagerImpl::CreateFrameNode(
       process_node, page_node_.get(), nullptr, 0, frame_id,
-      base::UnguessableToken::Null(), 0, 0);
+      base::UnguessableToken::Null(),
+      FrameToken(base::UnguessableToken::Create()), 0, 0);
 
   bool inserted =
       frame_node_map_.insert({render_frame_host_id, std::move(frame_node)})