Move content/renderer/performance_manager to blink/renderer/controller

Bug: 1085129
Change-Id: I5ad0528aac918934395eca23b0bb66157638e9fc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2329592Reviewed-by: Will Harris <wfh@chromium.org>
Reviewed-by: Chris Hamilton <chrisha@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#794245}

components/performance_manager/DEPS

@@ -10,6 +10,7 @@ include_rules = [
   "+services/service_manager/public/cpp",
   "+third_party/blink/public/common/tokens",
   "+third_party/blink/public/mojom/favicon",
+  "+third_party/blink/public/mojom/performance_manager",
   "+third_party/blink/public/mojom/service_worker",
   "+third_party/blink/public/mojom/tokens",
   "+third_party/leveldatabase",

components/performance_manager/public/v8_memory/v8_per_frame_memory_decorator.h

@@ -20,7 +20,7 @@
 #include "components/performance_manager/public/graph/process_node.h"
 #include "components/performance_manager/public/render_process_host_id.h"
 #include "content/public/browser/global_routing_id.h"
-#include "content/public/common/performance_manager/v8_per_frame_memory.mojom.h"
+#include "third_party/blink/public/mojom/performance_manager/v8_per_frame_memory.mojom.h"
 
 namespace performance_manager {
 
@@ -493,7 +493,7 @@ namespace internal {
 // communicate with the given process. Exposed so that it can be overridden to
 // implement the interface with a test fake.
 using BindV8PerFrameMemoryReporterCallback = base::RepeatingCallback<void(
-    mojo::PendingReceiver<performance_manager::mojom::V8PerFrameMemoryReporter>,
+    mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>,
     RenderProcessHostProxy)>;
 
 // Sets a callback that will be used to bind the V8PerFrameMemoryReporter

components/performance_manager/v8_memory/v8_per_frame_memory_decorator.cc

@@ -49,7 +49,7 @@ namespace {
 // Forwards the pending receiver to the RenderProcessHost and binds it on the
 // UI thread.
 void BindReceiverOnUIThread(
-    mojo::PendingReceiver<performance_manager::mojom::V8PerFrameMemoryReporter>
+    mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
         pending_receiver,
     RenderProcessHostProxy proxy) {
   auto* render_process_host = proxy.Get();
@@ -157,12 +157,11 @@ class NodeAttachedProcessData
   void StartMeasurement();
   void EnsureRemote();
   void OnPerFrameV8MemoryUsageData(
-      performance_manager::mojom::PerProcessV8MemoryUsageDataPtr result);
+      blink::mojom::PerProcessV8MemoryUsageDataPtr result);
 
   const ProcessNode* const process_node_;
 
-  mojo::Remote<performance_manager::mojom::V8PerFrameMemoryReporter>
-      resource_usage_reporter_;
+  mojo::Remote<blink::mojom::V8PerFrameMemoryReporter> resource_usage_reporter_;
 
   enum class State {
     kWaiting,    // Waiting to take a measurement.
@@ -243,7 +242,7 @@ void NodeAttachedProcessData::StartMeasurement() {
 }
 
 void NodeAttachedProcessData::OnPerFrameV8MemoryUsageData(
-    performance_manager::mojom::PerProcessV8MemoryUsageDataPtr result) {
+    blink::mojom::PerProcessV8MemoryUsageDataPtr result) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, State::kMeasuring);
 
@@ -254,14 +253,15 @@ void NodeAttachedProcessData::OnPerFrameV8MemoryUsageData(
   uint64_t unassociated_v8_bytes_used = result->unassociated_bytes_used;
 
   // Create a mapping from token to per-frame usage for the merge below.
-  std::vector<std::pair<FrameToken, mojom::PerFrameV8MemoryUsageDataPtr>> tmp;
+  std::vector<std::pair<FrameToken, blink::mojom::PerFrameV8MemoryUsageDataPtr>>
+      tmp;
   for (auto& entry : result->associated_memory) {
     tmp.emplace_back(
         std::make_pair(FrameToken(entry->frame_token), std::move(entry)));
   }
   DCHECK_EQ(tmp.size(), result->associated_memory.size());
 
-  base::flat_map<FrameToken, mojom::PerFrameV8MemoryUsageDataPtr>
+  base::flat_map<FrameToken, blink::mojom::PerFrameV8MemoryUsageDataPtr>
       associated_memory(std::move(tmp));
   // Validate that the frame tokens were all unique. If there are duplicates,
   // the map will arbirarily drop all but one record per unique token.
@@ -315,7 +315,7 @@ void NodeAttachedProcessData::EnsureRemote() {
     return;
 
   // This interface is implemented in //content/renderer/performance_manager.
-  mojo::PendingReceiver<performance_manager::mojom::V8PerFrameMemoryReporter>
+  mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
       pending_receiver = resource_usage_reporter_.BindNewPipeAndPassReceiver();
 
   RenderProcessHostProxy proxy = process_node_->GetRenderProcessHostProxy();

components/performance_manager/v8_memory/v8_per_frame_memory_decorator_unittest.cc

@@ -45,7 +45,7 @@ constexpr uint64_t kUnassociatedBytes = 0xABBA;
 namespace {
 
 class LenientMockV8PerFrameMemoryReporter
-    : public mojom::V8PerFrameMemoryReporter {
+    : public blink::mojom::V8PerFrameMemoryReporter {
  public:
   LenientMockV8PerFrameMemoryReporter() : receiver_(this) {}
 
@@ -54,13 +54,13 @@ class LenientMockV8PerFrameMemoryReporter
               (GetPerFrameV8MemoryUsageDataCallback callback),
               (override));
 
-  void Bind(
-      mojo::PendingReceiver<mojom::V8PerFrameMemoryReporter> pending_receiver) {
+  void Bind(mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
+                pending_receiver) {
     return receiver_.Bind(std::move(pending_receiver));
   }
 
  private:
-  mojo::Receiver<mojom::V8PerFrameMemoryReporter> receiver_;
+  mojo::Receiver<blink::mojom::V8PerFrameMemoryReporter> receiver_;
 };
 
 using MockV8PerFrameMemoryReporter =
@@ -122,7 +122,7 @@ class V8PerFrameMemoryDecoratorTestBase {
   GetMainThreadTaskRunner() = 0;
 
   void ReplyWithData(
-      mojom::PerProcessV8MemoryUsageDataPtr data,
+      blink::mojom::PerProcessV8MemoryUsageDataPtr data,
       MockV8PerFrameMemoryReporter::GetPerFrameV8MemoryUsageDataCallback
           callback) {
     std::move(callback).Run(std::move(data));
@@ -130,7 +130,7 @@ class V8PerFrameMemoryDecoratorTestBase {
 
   void DelayedReplyWithData(
       const base::TimeDelta& delay,
-      mojom::PerProcessV8MemoryUsageDataPtr data,
+      blink::mojom::PerProcessV8MemoryUsageDataPtr data,
       MockV8PerFrameMemoryReporter::GetPerFrameV8MemoryUsageDataCallback
           callback) {
     GetMainThreadTaskRunner()->PostDelayedTask(
@@ -152,16 +152,17 @@ class V8PerFrameMemoryDecoratorTestBase {
   }
 
   void ExpectQueryAndReply(MockV8PerFrameMemoryReporter* mock_reporter,
-                           mojom::PerProcessV8MemoryUsageDataPtr data) {
+                           blink::mojom::PerProcessV8MemoryUsageDataPtr data) {
     ExpectQuery(
         mock_reporter,
         base::BindRepeating(&V8PerFrameMemoryDecoratorTestBase::ReplyWithData,
                             base::Unretained(this), base::Passed(&data)));
   }
 
-  void ExpectQueryAndDelayReply(MockV8PerFrameMemoryReporter* mock_reporter,
-                                const base::TimeDelta& delay,
-                                mojom::PerProcessV8MemoryUsageDataPtr data) {
+  void ExpectQueryAndDelayReply(
+      MockV8PerFrameMemoryReporter* mock_reporter,
+      const base::TimeDelta& delay,
+      blink::mojom::PerProcessV8MemoryUsageDataPtr data) {
     ExpectQuery(mock_reporter,
                 base::BindRepeating(
                     &V8PerFrameMemoryDecoratorTestBase::DelayedReplyWithData,
@@ -170,26 +171,25 @@ class V8PerFrameMemoryDecoratorTestBase {
 
   void ExpectBindAndRespondToQuery(
       MockV8PerFrameMemoryReporter* mock_reporter,
-      mojom::PerProcessV8MemoryUsageDataPtr data,
+      blink::mojom::PerProcessV8MemoryUsageDataPtr data,
       RenderProcessHostId expected_process_id = kTestProcessID) {
     // Wrap the move-only |data| in a callback for the expectation below.
     ExpectQueryAndReply(mock_reporter, std::move(data));
 
     EXPECT_CALL(*this, BindReceiverWithProxyHost(_, _))
-        .WillOnce([mock_reporter, expected_process_id](
-                      mojo::PendingReceiver<
-                          performance_manager::mojom::V8PerFrameMemoryReporter>
-                          pending_receiver,
-                      RenderProcessHostProxy proxy) {
-          DCHECK_EQ(expected_process_id, proxy.render_process_host_id());
-          mock_reporter->Bind(std::move(pending_receiver));
-        });
+        .WillOnce(
+            [mock_reporter, expected_process_id](
+                mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
+                    pending_receiver,
+                RenderProcessHostProxy proxy) {
+              DCHECK_EQ(expected_process_id, proxy.render_process_host_id());
+              mock_reporter->Bind(std::move(pending_receiver));
+            });
   }
 
   MOCK_METHOD(void,
               BindReceiverWithProxyHost,
-              (mojo::PendingReceiver<
-                   performance_manager::mojom::V8PerFrameMemoryReporter>
+              (mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
                    pending_receiver,
                RenderProcessHostProxy proxy),
               (const));
@@ -197,8 +197,7 @@ class V8PerFrameMemoryDecoratorTestBase {
   // Always bind the receiver callback on the main sequence.
   internal::BindV8PerFrameMemoryReporterCallback bind_callback_ =
       base::BindLambdaForTesting(
-          [this](mojo::PendingReceiver<
-                     performance_manager::mojom::V8PerFrameMemoryReporter>
+          [this](mojo::PendingReceiver<blink::mojom::V8PerFrameMemoryReporter>
                      pending_receiver,
                  RenderProcessHostProxy proxy) {
             this->GetMainThreadTaskRunner()->PostTask(
@@ -211,11 +210,12 @@ class V8PerFrameMemoryDecoratorTestBase {
   base::TimeTicks last_query_time_;
 };
 
-void AddPerFrameIsolateMemoryUsage(FrameToken frame_token,
-                                   int64_t world_id,
-                                   uint64_t bytes_used,
-                                   mojom::PerProcessV8MemoryUsageData* data) {
-  mojom::PerFrameV8MemoryUsageData* per_frame_data = nullptr;
+void AddPerFrameIsolateMemoryUsage(
+    FrameToken frame_token,
+    int64_t world_id,
+    uint64_t bytes_used,
+    blink::mojom::PerProcessV8MemoryUsageData* data) {
+  blink::mojom::PerFrameV8MemoryUsageData* per_frame_data = nullptr;
   for (auto& datum : data->associated_memory) {
     if (datum->frame_token == frame_token.value()) {
       per_frame_data = datum.get();
@@ -224,15 +224,15 @@ void AddPerFrameIsolateMemoryUsage(FrameToken frame_token,
   }
 
   if (!per_frame_data) {
-    mojom::PerFrameV8MemoryUsageDataPtr datum =
-        mojom::PerFrameV8MemoryUsageData::New();
+    blink::mojom::PerFrameV8MemoryUsageDataPtr datum =
+        blink::mojom::PerFrameV8MemoryUsageData::New();
     datum->frame_token = frame_token.value();
     per_frame_data = datum.get();
     data->associated_memory.push_back(std::move(datum));
   }
   ASSERT_FALSE(base::Contains(per_frame_data->associated_bytes, world_id));
 
-  auto isolated_world_usage = mojom::V8IsolatedWorldMemoryUsage::New();
+  auto isolated_world_usage = blink::mojom::V8IsolatedWorldMemoryUsage::New();
   isolated_world_usage->bytes_used = bytes_used;
   per_frame_data->associated_bytes[world_id] = std::move(isolated_world_usage);
 }
@@ -267,7 +267,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, InstantiateOnEmptyGraph) {
   V8PerFrameMemoryRequest memory_request(kMinTimeBetweenRequests, graph());
 
   MockV8PerFrameMemoryReporter mock_reporter;
-  auto data = mojom::PerProcessV8MemoryUsageData::New();
+  auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
   data->unassociated_bytes_used = kUnassociatedBytes;
   ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
 
@@ -296,7 +296,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, InstantiateOnNonEmptyGraph) {
       RenderProcessHostProxy::CreateForTesting(kTestProcessID));
 
   MockV8PerFrameMemoryReporter mock_reporter;
-  auto data = mojom::PerProcessV8MemoryUsageData::New();
+  auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
   data->unassociated_bytes_used = kUnassociatedBytes;
   ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
 
@@ -341,7 +341,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, QueryRateIsLimited) {
 
   MockV8PerFrameMemoryReporter mock_reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     // Response to request 1.
     data->unassociated_bytes_used = 1;
     ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
@@ -384,7 +384,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, QueryRateIsLimited) {
 
   // Expect another query once completing the query above.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     // Response to request 3.
     data->unassociated_bytes_used = 3;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
@@ -392,7 +392,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, QueryRateIsLimited) {
 
   // Reply to the request above.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     // Response to request 2.
     data->unassociated_bytes_used = 2;
     std::move(callback).Run(std::move(data));
@@ -417,7 +417,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MultipleProcessesHaveDistinctSchedules) {
   // Create a process node and validate that it gets a request.
   MockV8PerFrameMemoryReporter reporter1;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1;
     ExpectBindAndRespondToQuery(&reporter1, std::move(data));
   }
@@ -432,7 +432,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MultipleProcessesHaveDistinctSchedules) {
   // Create a second process node and validate that it gets a request.
   MockV8PerFrameMemoryReporter reporter2;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 2;
     ExpectBindAndRespondToQuery(&reporter2, std::move(data));
   }
@@ -457,7 +457,8 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MultipleProcessesHaveDistinctSchedules) {
          MockV8PerFrameMemoryReporter::GetPerFrameV8MemoryUsageDataCallback
              callback) {
         *request_time = base::TimeTicks::Now();
-        std::move(callback).Run(mojom::PerProcessV8MemoryUsageData::New());
+        std::move(callback).Run(
+            blink::mojom::PerProcessV8MemoryUsageData::New());
       };
 
   base::TimeTicks process1_request_time;
@@ -483,7 +484,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, PerFrameDataIsDistributed) {
 
   MockV8PerFrameMemoryReporter reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     // Add data for an unknown frame.
     AddPerFrameIsolateMemoryUsage(FrameToken(base::UnguessableToken::Create()),
                                   0, 1024u, data.get());
@@ -514,7 +515,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, PerFrameDataIsDistributed) {
   auto frame2 = CreateNode<FrameNodeImpl>(process.get(), page.get(), nullptr, 3,
                                           4, frame2_id);
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     AddPerFrameIsolateMemoryUsage(frame1_id, 0, 1001u, data.get());
     AddPerFrameIsolateMemoryUsage(frame2_id, 0, 1002u, data.get());
     ExpectQueryAndReply(&reporter, std::move(data));
@@ -535,7 +536,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, PerFrameDataIsDistributed) {
   // Now verify that data is cleared for any frame that doesn't get an update,
   // plus verify that unknown frame data toes to unassociated bytes.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     AddPerFrameIsolateMemoryUsage(frame1_id, 0, 1003u, data.get());
     AddPerFrameIsolateMemoryUsage(FrameToken(base::UnguessableToken::Create()),
                                   0, 2233u, data.get());
@@ -577,7 +578,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   // frequency.
   MockV8PerFrameMemoryReporter mock_reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1U;
     ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
   }
@@ -598,7 +599,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   // Another measurement should be taken after the shortest interval.
   EXPECT_EQ(kShortInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 2U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -612,7 +613,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   short_memory_request.reset();
   EXPECT_EQ(kMediumInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 3U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -629,7 +630,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   long_memory_request.reset();
   EXPECT_EQ(kMediumInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 4U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -642,7 +643,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   medium_memory_request.reset();
   EXPECT_TRUE(decorator->GetMinTimeBetweenRequestsPerProcess().is_zero());
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 5U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -662,7 +663,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
                     ->unassociated_v8_bytes_used());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 6U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -679,7 +680,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   EXPECT_EQ(kMediumInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 7U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -689,7 +690,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   }
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 8U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -713,7 +714,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   EXPECT_EQ(kMediumInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 9U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -729,7 +730,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   EXPECT_EQ(kMediumInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 10U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -744,7 +745,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   EXPECT_EQ(kLongInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 11U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -758,7 +759,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsSorted) {
   EXPECT_EQ(kLongInterval, decorator->GetMinTimeBetweenRequestsPerProcess());
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 12U;
     ExpectQueryAndReply(&mock_reporter, std::move(data));
 
@@ -788,7 +789,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   // and QueryAndDelayReply expectations.
   MockV8PerFrameMemoryReporter mock_reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 0U;
     ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
   }
@@ -803,7 +804,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   // update GetMinTimeBetweenRequestsPerProcess but not start a new
   // measurement until the existing measurement finishes.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1U;
     ExpectQueryAndDelayReply(&mock_reporter, kMeasurementLength,
                              std::move(data));
@@ -828,7 +829,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   // Next measurement should start kMediumInterval secs after the START of the
   // last measurement.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 2U;
     ExpectQueryAndDelayReply(&mock_reporter, kMeasurementLength,
                              std::move(data));
@@ -850,7 +851,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   // Create a request that would be sent in the middle of a measurement. It
   // should start immediately after the measurement finishes.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 3U;
     ExpectQueryAndDelayReply(&mock_reporter, kMeasurementLength,
                              std::move(data));
@@ -869,7 +870,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   EXPECT_EQ(last_query_time_, measurement_start_time);
 
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 4U;
     ExpectQueryAndDelayReply(&mock_reporter, kMeasurementLength,
                              std::move(data));
@@ -896,7 +897,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestsWithDelay) {
   // Delete the last request while a measurement is in process. The
   // measurement should finish successfully but no more should be sent.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 5U;
     ExpectQueryAndDelayReply(&mock_reporter, kMeasurementLength,
                              std::move(data));
@@ -931,7 +932,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, MeasurementRequestOutlivesDecorator) {
 
   MockV8PerFrameMemoryReporter mock_reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1U;
     ExpectBindAndRespondToQuery(&mock_reporter, std::move(data));
   }
@@ -962,7 +963,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, NotifyObservers) {
   // measurement is available for it.
   MockV8PerFrameMemoryReporter reporter1;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1U;
     ExpectBindAndRespondToQuery(&reporter1, std::move(data));
   }
@@ -984,12 +985,12 @@ TEST_F(V8PerFrameMemoryDecoratorTest, NotifyObservers) {
   // for process2 and the second measurement for process1 will arrive.
   MockV8PerFrameMemoryReporter reporter2;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 2U;
     ExpectBindAndRespondToQuery(&reporter2, std::move(data));
   }
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 3U;
     ExpectQueryAndReply(&reporter1, std::move(data));
   }
@@ -1012,12 +1013,12 @@ TEST_F(V8PerFrameMemoryDecoratorTest, NotifyObservers) {
   // Remove an observer and make sure the other is still notified after the
   // next measurement.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 4U;
     ExpectQueryAndReply(&reporter1, std::move(data));
   }
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 5U;
     ExpectQueryAndReply(&reporter2, std::move(data));
   }
@@ -1047,7 +1048,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, ObserverOutlivesDecorator) {
   // Create a process node and move past the initial request to it.
   MockV8PerFrameMemoryReporter reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 1U;
     ExpectBindAndRespondToQuery(&reporter, std::move(data));
   }
@@ -1064,7 +1065,7 @@ TEST_F(V8PerFrameMemoryDecoratorTest, ObserverOutlivesDecorator) {
 
   // Start the next measurement.
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = 2U;
     ExpectQueryAndDelayReply(&reporter, kMinTimeBetweenRequests,
                              std::move(data));
@@ -1148,7 +1149,7 @@ TEST_F(V8PerFrameMemoryRequestAnySeqTest, RequestIsSequenceSafe) {
 
   MockV8PerFrameMemoryReporter reporter;
   {
-    auto data = mojom::PerProcessV8MemoryUsageData::New();
+    auto data = blink::mojom::PerProcessV8MemoryUsageData::New();
     data->unassociated_bytes_used = kUnassociatedBytes;
     AddPerFrameIsolateMemoryUsage(frame_token, 0, kAssociatedBytes, data.get());
     ExpectBindAndRespondToQuery(&reporter, std::move(data), process_id);

content/public/common/BUILD.gn

@@ -309,7 +309,6 @@ mojom("interfaces") {
     "browser_controls_state.mojom",
     "drop_data.mojom",
     "fullscreen_video_element.mojom",
-    "performance_manager/v8_per_frame_memory.mojom",
     "resource_usage_reporter.mojom",
     "was_activated_option.mojom",
     "webplugininfo.mojom",

content/renderer/BUILD.gn

@@ -189,8 +189,6 @@ target(link_target_type, "renderer") {
     "navigation_state.h",
     "net_info_helper.cc",
     "net_info_helper.h",
-    "performance_manager/v8_per_frame_memory_reporter_impl.cc",
-    "performance_manager/v8_per_frame_memory_reporter_impl.h",
     "peripheral_content_heuristic.cc",
     "peripheral_content_heuristic.h",
     "queue_message_swap_promise.cc",

content/renderer/browser_exposed_renderer_interfaces.cc

@@ -33,10 +33,6 @@
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "v8/include/v8.h"
 
-#if !defined(OS_ANDROID)
-#include "content/renderer/performance_manager/v8_per_frame_memory_reporter_impl.h"
-#endif
-
 namespace content {
 
 namespace {
@@ -225,14 +221,6 @@ void ExposeRendererInterfacesToBrowser(
   binders->Add(base::BindRepeating(&CreateFrameFactory),
                base::ThreadTaskRunnerHandle::Get());
 
-#if !defined(OS_ANDROID)
-  // Currently nothing on Android samples V8PerFrameMemory, so only initialize
-  // the reporter on desktop to save memory.
-  binders->Add(base::BindRepeating(
-                   &performance_manager::V8PerFrameMemoryReporterImpl::Create),
-               base::SequencedTaskRunnerHandle::Get());
-#endif
-
   GetContentClient()->renderer()->ExposeInterfacesToBrowser(binders);
 }
 

third_party/blink/public/mojom/BUILD.gn

@@ -116,6 +116,7 @@ mojom("mojom_platform") {
     "page/widget.mojom",
     "payments/payment_app.mojom",
     "peerconnection/peer_connection_tracker.mojom",
+    "performance_manager/v8_per_frame_memory.mojom",
     "permissions/permission.mojom",
     "permissions/permission_automation.mojom",
     "permissions/permission_status.mojom",

content/public/common/performance_manager/v8_per_frame_memory.mojom → third_party/blink/public/mojom/performance_manager/v8_per_frame_memory.mojom

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module performance_manager.mojom;
+module blink.mojom;
 
 import "mojo/public/mojom/base/unguessable_token.mojom";
 

third_party/blink/renderer/controller/BUILD.gn

@@ -61,6 +61,11 @@ jumbo_component("controller") {
       "oom_intervention_impl.cc",
       "oom_intervention_impl.h",
     ]
+  } else {
+    sources += [
+      "performance_manager/v8_per_frame_memory_reporter_impl.cc",
+      "performance_manager/v8_per_frame_memory_reporter_impl.h",
+    ]
   }
   if (is_win) {
     sources += [

third_party/blink/renderer/controller/blink_initializer.cc

@@ -63,6 +63,8 @@
 #if defined(OS_ANDROID)
 #include "third_party/blink/renderer/controller/crash_memory_metrics_reporter_impl.h"
 #include "third_party/blink/renderer/controller/oom_intervention_impl.h"
+#else
+#include "third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.h"
 #endif
 
 #if defined(OS_LINUX)
@@ -203,7 +205,14 @@ void BlinkInitializer::RegisterInterfaces(mojo::BinderMap& binders) {
   binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
                   &CrashMemoryMetricsReporterImpl::Bind)),
               main_thread->GetTaskRunner());
+#else
+  // Currently nothing on Android samples V8PerFrameMemory, so only initialize
+  // the reporter on desktop to save memory.
+  binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
+                  &V8PerFrameMemoryReporterImpl::Create)),
+              main_thread->GetTaskRunner());
 #endif
+
 #if defined(OS_LINUX)
   binders.Add(ConvertToBaseRepeatingCallback(
                   CrossThreadBindRepeating(&MemoryUsageMonitorPosix::Bind)),

content/renderer/performance_manager/v8_per_frame_memory_reporter_impl.cc → third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.cc

@@ -2,24 +2,35 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/performance_manager/v8_per_frame_memory_reporter_impl.h"
+#include "third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.h"
 
-#include "base/containers/flat_map.h"
-#include "content/public/common/isolated_world_ids.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "third_party/blink/public/platform/web_isolated_world_info.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/public/web/web_local_frame_client.h"
+#include "third_party/blink/renderer/platform/bindings/dom_wrapper_world.h"
+#include "third_party/blink/renderer/platform/wtf/hash_map.h"
 #include "v8/include/v8.h"
 
-namespace performance_manager {
+namespace WTF {
+template <>
+struct HashTraits<::blink::mojom::blink::PerFrameV8MemoryUsageDataPtr>
+    : GenericHashTraits<::blink::mojom::blink::PerFrameV8MemoryUsageDataPtr> {
+  // The default PeekOutType is a value type that requires a copy constructor
+  // in the at() getter. Override it to a reference.
+  typedef const ::blink::mojom::blink::PerFrameV8MemoryUsageDataPtr&
+      PeekOutType;
+};
+}  // namespace WTF
+
+namespace blink {
 
 namespace {
 
 class FrameAssociatedMeasurementDelegate : public v8::MeasureMemoryDelegate {
  public:
-  using GetPerFrameV8MemoryUsageDataCallback =
-      mojom::V8PerFrameMemoryReporter::GetPerFrameV8MemoryUsageDataCallback;
+  using GetPerFrameV8MemoryUsageDataCallback = mojom::blink::
+      V8PerFrameMemoryReporter::GetPerFrameV8MemoryUsageDataCallback;
 
   explicit FrameAssociatedMeasurementDelegate(
       GetPerFrameV8MemoryUsageDataCallback&& callback)
@@ -27,7 +38,8 @@ class FrameAssociatedMeasurementDelegate : public v8::MeasureMemoryDelegate {
 
   ~FrameAssociatedMeasurementDelegate() override {
     if (callback_) {
-      std::move(callback_).Run(mojom::PerProcessV8MemoryUsageData::New());
+      std::move(callback_).Run(
+          mojom::blink::PerProcessV8MemoryUsageData::New());
     }
   }
 
@@ -41,13 +53,14 @@ class FrameAssociatedMeasurementDelegate : public v8::MeasureMemoryDelegate {
       const std::vector<std::pair<v8::Local<v8::Context>, size_t>>&
           context_sizes_in_bytes,
       size_t unattributed_size_in_bytes) override {
-    mojom::PerProcessV8MemoryUsageDataPtr result =
-        mojom::PerProcessV8MemoryUsageData::New();
+    mojom::blink::PerProcessV8MemoryUsageDataPtr result =
+        mojom::blink::PerProcessV8MemoryUsageData::New();
 
     result->unassociated_bytes_used = unattributed_size_in_bytes;
 
     // Keep track of the per-frame data throughout this loop.
-    base::flat_map<blink::WebLocalFrame*, mojom::PerFrameV8MemoryUsageDataPtr>
+    WTF::HashMap<blink::WebLocalFrame*,
+                 mojom::blink::PerFrameV8MemoryUsageDataPtr>
         frames;
     for (const auto& context_and_size : context_sizes_in_bytes) {
       const v8::Local<v8::Context>& context = context_and_size.first;
@@ -63,45 +76,45 @@ class FrameAssociatedMeasurementDelegate : public v8::MeasureMemoryDelegate {
         ++(result->num_unassociated_contexts);
         result->unassociated_context_bytes_used += size;
       } else {
-        mojom::PerFrameV8MemoryUsageData* per_frame_resources =
-            frames[frame].get();
+        mojom::blink::PerFrameV8MemoryUsageData* per_frame_resources =
+            frames.at(frame).get();
         if (!per_frame_resources) {
 #if DCHECK_IS_ON()
           // Check that the frame token didn't already occur.
           for (const auto& entry : frames) {
             // This frame was already added to the map by frames[frame] above.
-            if (frame == entry.first)
+            if (frame == entry.key)
               continue;
-            DCHECK_NE(entry.first->GetFrameToken(), frame->GetFrameToken());
+            DCHECK_NE(entry.key->GetFrameToken(), frame->GetFrameToken());
           }
 #endif
-          auto new_resources = mojom::PerFrameV8MemoryUsageData::New();
+          auto new_resources = mojom::blink::PerFrameV8MemoryUsageData::New();
           new_resources->frame_token = frame->GetFrameToken();
           per_frame_resources = new_resources.get();
-          frames[frame] = std::move(new_resources);
+          frames.Set(frame, std::move(new_resources));
         }
 
-        mojom::V8IsolatedWorldMemoryUsagePtr isolated_world_usage =
-            mojom::V8IsolatedWorldMemoryUsage::New();
+        mojom::blink::V8IsolatedWorldMemoryUsagePtr isolated_world_usage =
+            mojom::blink::V8IsolatedWorldMemoryUsage::New();
         isolated_world_usage->bytes_used = size;
         int32_t world_id = frame->GetScriptContextWorldId(context);
 
-        if (world_id != content::ISOLATED_WORLD_ID_GLOBAL) {
+        if (world_id != DOMWrapperWorld::WorldId::kMainWorldId) {
           isolated_world_usage->stable_id =
-              blink::GetIsolatedWorldStableId(context).Utf8();
+              blink::GetIsolatedWorldStableId(context);
           isolated_world_usage->human_readable_name =
-              blink::GetIsolatedWorldHumanReadableName(context).Utf8();
+              blink::GetIsolatedWorldHumanReadableName(context);
         }
 
         DCHECK(
             !base::Contains(per_frame_resources->associated_bytes, world_id));
-        per_frame_resources->associated_bytes[world_id] =
-            std::move(isolated_world_usage);
+        per_frame_resources->associated_bytes.Set(
+            world_id, std::move(isolated_world_usage));
       }
     }
     // Move the per-frame memory values to the result.
     for (auto& entry : frames)
-      result->associated_memory.push_back(std::move(entry.second));
+      result->associated_memory.push_back(std::move(entry.value));
 
     std::move(callback_).Run(std::move(result));
   }
@@ -113,7 +126,7 @@ class FrameAssociatedMeasurementDelegate : public v8::MeasureMemoryDelegate {
 
 // static
 void V8PerFrameMemoryReporterImpl::Create(
-    mojo::PendingReceiver<mojom::V8PerFrameMemoryReporter> receiver) {
+    mojo::PendingReceiver<mojom::blink::V8PerFrameMemoryReporter> receiver) {
   mojo::MakeSelfOwnedReceiver(std::make_unique<V8PerFrameMemoryReporterImpl>(),
                               std::move(receiver));
 }
@@ -122,7 +135,7 @@ void V8PerFrameMemoryReporterImpl::GetPerFrameV8MemoryUsageData(
     GetPerFrameV8MemoryUsageDataCallback callback) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   if (!isolate) {
-    std::move(callback).Run(mojom::PerProcessV8MemoryUsageData::New());
+    std::move(callback).Run(mojom::blink::PerProcessV8MemoryUsageData::New());
   } else {
     std::unique_ptr<FrameAssociatedMeasurementDelegate> delegate =
         std::make_unique<FrameAssociatedMeasurementDelegate>(
@@ -132,4 +145,4 @@ void V8PerFrameMemoryReporterImpl::GetPerFrameV8MemoryUsageData(
   }
 }
 
-}  // namespace performance_manager
+}  // namespace blink

content/renderer/performance_manager/v8_per_frame_memory_reporter_impl.h → third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.h

@@ -2,23 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_
-#define CONTENT_RENDERER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_
+#ifndef THIRD_PARTY_BLINK_RENDERER_CONTROLLER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_
+#define THIRD_PARTY_BLINK_RENDERER_CONTROLLER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_
 
-#include "content/public/common/performance_manager/v8_per_frame_memory.mojom.h"
+#include "third_party/blink/public/mojom/performance_manager/v8_per_frame_memory.mojom-blink.h"
 
-namespace performance_manager {
+namespace blink {
 
 // Exposes V8 per-frame associated memory metrics to the browser.
-class V8PerFrameMemoryReporterImpl : public mojom::V8PerFrameMemoryReporter {
+class V8PerFrameMemoryReporterImpl
+    : public mojom::blink::V8PerFrameMemoryReporter {
  public:
   static void Create(
-      mojo::PendingReceiver<mojom::V8PerFrameMemoryReporter> receiver);
+      mojo::PendingReceiver<mojom::blink::V8PerFrameMemoryReporter> receiver);
 
   void GetPerFrameV8MemoryUsageData(
       GetPerFrameV8MemoryUsageDataCallback callback) override;
 };
 
-}  // namespace performance_manager
+}  // namespace blink
 
-#endif  // CONTENT_RENDERER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_
+#endif  // THIRD_PARTY_BLINK_CONTROLLER_PERFORMANCE_MANAGER_V8_PER_FRAME_MEMORY_REPORTER_IMPL_H_