Convert perfetto_service.mojom to new Mojo types (7/n)

This CL converts,
- |Binding<TracingSessionHost>| to |Receiver<TracingSessionHost>|
- |Binding<TracingSessionClient>| to |Receiver<TracingSessionClient>|
- |TracingSessionHostPtr| to |Remote<TracingSessionHost>|
- |ProducerClientRequest| to |PendingReceiver<ProducerClient>|

Bug: 955171, 978694
Change-Id: I52566c7c7561149f73df2a5aa7ecd494eafdd489
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1843993Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Cr-Commit-Position: refs/heads/master@{#706391}

services/tracing/perfetto/consumer_host.cc

@@ -120,18 +120,18 @@ class ConsumerHost::StreamWriter {
 ConsumerHost::TracingSession::TracingSession(
     ConsumerHost* host,
     mojo::PendingReceiver<mojom::TracingSessionHost> tracing_session_host,
-    mojo::Remote<mojom::TracingSessionClient> tracing_session_client,
+    mojo::PendingRemote<mojom::TracingSessionClient> tracing_session_client,
     const perfetto::TraceConfig& trace_config,
     mojom::TracingClientPriority priority)
     : host_(host),
       tracing_session_client_(std::move(tracing_session_client)),
-      binding_(this, std::move(tracing_session_host)),
+      receiver_(this, std::move(tracing_session_host)),
       tracing_priority_(priority) {
   host_->service()->RegisterTracingSession(this);
 
   tracing_session_client_.set_disconnect_handler(base::BindOnce(
       &ConsumerHost::DestructTracingSession, base::Unretained(host)));
-  binding_.set_connection_error_handler(base::BindOnce(
+  receiver_.set_disconnect_handler(base::BindOnce(
       &ConsumerHost::DestructTracingSession, base::Unretained(host)));
 
   privacy_filtering_enabled_ = false;
@@ -527,14 +527,12 @@ void ConsumerHost::EnableTracing(
                       if (!weak_this) {
                         return;
                       }
-                      mojo::Remote<mojom::TracingSessionClient>
-                          tracing_session_client_remote(
-                              std::move(tracing_session_client));
+
                       weak_this->tracing_session_ =
                           std::make_unique<TracingSession>(
                               weak_this.get(), std::move(tracing_session_host),
-                              std::move(tracing_session_client_remote),
-                              trace_config, priority);
+                              std::move(tracing_session_client), trace_config,
+                              priority);
                     },
                     weak_factory_.GetWeakPtr(), std::move(tracing_session_host),
                     std::move(tracing_session_client), trace_config, priority));

services/tracing/perfetto/consumer_host.h

@@ -51,7 +51,7 @@ class ConsumerHost : public perfetto::Consumer, public mojom::ConsumerHost {
     TracingSession(
         ConsumerHost* host,
         mojo::PendingReceiver<mojom::TracingSessionHost> tracing_session_host,
-        mojo::Remote<mojom::TracingSessionClient> tracing_session_client,
+        mojo::PendingRemote<mojom::TracingSessionClient> tracing_session_client,
         const perfetto::TraceConfig& trace_config,
         mojom::TracingClientPriority priority);
     ~TracingSession() override;
@@ -98,7 +98,7 @@ class ConsumerHost : public perfetto::Consumer, public mojom::ConsumerHost {
 
     ConsumerHost* const host_;
     mojo::Remote<mojom::TracingSessionClient> tracing_session_client_;
-    mojo::Binding<mojom::TracingSessionHost> binding_;
+    mojo::Receiver<mojom::TracingSessionHost> receiver_;
     bool privacy_filtering_enabled_ = false;
     base::SequenceBound<StreamWriter> read_buffers_stream_writer_;
     RequestBufferUsageCallback request_buffer_usage_callback_;

services/tracing/perfetto/consumer_host_unittest.cc

@@ -19,7 +19,7 @@
 #include "base/task/post_task.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/public/cpp/system/data_pipe_drainer.h"
 #include "services/tracing/perfetto/perfetto_service.h"
@@ -48,6 +48,8 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
              base::WithBaseSyncPrimitives(),
              base::TaskPriority::BEST_EFFORT})) {
     perfetto_service_ = std::make_unique<PerfettoService>(task_runner_);
+    tracing_session_host_ =
+        std::make_unique<mojo::Remote<mojom::TracingSessionHost>>();
     base::RunLoop wait_for_construct;
     task_runner_->PostTaskAndReply(
         FROM_HERE,
@@ -58,8 +60,8 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
   }
 
   ~ThreadedPerfettoService() override {
-    if (binding_) {
-      task_runner_->DeleteSoon(FROM_HERE, std::move(binding_));
+    if (receiver_) {
+      task_runner_->DeleteSoon(FROM_HERE, std::move(receiver_));
     }
 
     task_runner_->DeleteSoon(FROM_HERE, std::move(producer_));
@@ -67,6 +69,9 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
       task_runner_->DeleteSoon(FROM_HERE, std::move(consumer_));
     }
 
+    if (tracing_session_host_)
+      task_runner_->DeleteSoon(FROM_HERE, std::move(tracing_session_host_));
+
     {
       base::RunLoop wait_for_destruction;
       task_runner_->PostTaskAndReply(FROM_HERE, base::DoNothing(),
@@ -145,11 +150,11 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
   void EnableTracingOnSequence(const perfetto::TraceConfig& config) {
     mojo::PendingRemote<tracing::mojom::TracingSessionClient>
         tracing_session_client;
-    binding_ = std::make_unique<mojo::Binding<mojom::TracingSessionClient>>(
+    receiver_ = std::make_unique<mojo::Receiver<mojom::TracingSessionClient>>(
         this, tracing_session_client.InitWithNewPipeAndPassReceiver());
 
     consumer_->EnableTracing(
-        mojo::MakeRequest(&tracing_session_host_),
+        tracing_session_host_->BindNewPipeAndPassReceiver(),
         std::move(tracing_session_client), std::move(config),
         tracing::mojom::TracingClientPriority::kUserInitiated);
   }
@@ -164,8 +169,6 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
             std::move(stream), std::move(callback)));
   }
 
-  void FreeBuffers() { tracing_session_host_.reset(); }
-
   void DisableTracing() {
     base::RunLoop wait_for_call;
     task_runner_->PostTaskAndReply(
@@ -290,8 +293,9 @@ class ThreadedPerfettoService : public mojom::TracingSessionClient {
   std::unique_ptr<PerfettoService> perfetto_service_;
   std::unique_ptr<ConsumerHost> consumer_;
   std::unique_ptr<MockProducer> producer_;
-  std::unique_ptr<mojo::Binding<mojom::TracingSessionClient>> binding_;
-  tracing::mojom::TracingSessionHostPtr tracing_session_host_;
+  std::unique_ptr<mojo::Receiver<mojom::TracingSessionClient>> receiver_;
+  std::unique_ptr<mojo::Remote<tracing::mojom::TracingSessionHost>>
+      tracing_session_host_;
   bool tracing_enabled_ = false;
 };
 
@@ -503,8 +507,6 @@ TEST_F(TracingConsumerTest, FlushProducers) {
   wait_for_packets.Run();
 
   EXPECT_EQ(10u, matching_packet_count());
-
-  threaded_perfetto_service()->FreeBuffers();
 }
 
 TEST_F(TracingConsumerTest, LargeDataSize) {
@@ -675,15 +677,15 @@ class MockConsumerHost : public mojom::TracingSessionClient {
                      mojom::TracingClientPriority priority) {
     mojo::PendingRemote<tracing::mojom::TracingSessionClient>
         tracing_session_client;
-    binding_.Bind(tracing_session_client.InitWithNewPipeAndPassReceiver());
+    receiver_.Bind(tracing_session_client.InitWithNewPipeAndPassReceiver());
 
-    binding_.set_connection_error_handler(base::BindOnce(
+    receiver_.set_disconnect_handler(base::BindOnce(
         &MockConsumerHost::OnConnectionLost, base::Unretained(this)));
 
-    consumer_host_->EnableTracing(mojo::MakeRequest(&tracing_session_host_),
-                                  std::move(tracing_session_client), config,
-                                  priority);
-    tracing_session_host_.set_connection_error_handler(base::BindOnce(
+    consumer_host_->EnableTracing(
+        tracing_session_host_.BindNewPipeAndPassReceiver(),
+        std::move(tracing_session_client), config, priority);
+    tracing_session_host_.set_disconnect_handler(base::BindOnce(
         &MockConsumerHost::OnConnectionLost, base::Unretained(this)));
   }
 
@@ -696,7 +698,7 @@ class MockConsumerHost : public mojom::TracingSessionClient {
 
   void CloseTracingSession() {
     tracing_session_host_.reset();
-    binding_.Close();
+    receiver_.reset();
   }
 
   // mojom::TracingSessionClient implementation:
@@ -711,8 +713,8 @@ class MockConsumerHost : public mojom::TracingSessionClient {
   void WaitForTracingDisabled() { wait_for_tracing_disabled_.Run(); }
 
  private:
-  tracing::mojom::TracingSessionHostPtr tracing_session_host_;
-  mojo::Binding<mojom::TracingSessionClient> binding_{this};
+  mojo::Remote<tracing::mojom::TracingSessionHost> tracing_session_host_;
+  mojo::Receiver<mojom::TracingSessionClient> receiver_{this};
   std::unique_ptr<ConsumerHost> consumer_host_;
   base::RunLoop wait_for_connection_lost_;
   base::RunLoop wait_for_tracing_enabled_;

services/tracing/public/cpp/perfetto/producer_client.h

@@ -17,6 +17,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
 #include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_producer.h"
 #include "services/tracing/public/cpp/perfetto/task_runner.h"
 #include "services/tracing/public/mojom/perfetto_service.mojom.h"
@@ -106,7 +107,7 @@ class COMPONENT_EXPORT(TRACING_CPP) ProducerClient
 
   uint32_t data_sources_tracing_ = 0;
   std::unique_ptr<mojo::Receiver<mojom::ProducerClient>> receiver_;
-  mojom::ProducerHostPtr producer_host_;
+  mojo::Remote<mojom::ProducerHost> producer_host_;
   std::unique_ptr<MojoSharedMemory> shared_memory_;
   std::unique_ptr<perfetto::SharedMemoryArbiter> shared_memory_arbiter_;
   perfetto::SharedMemoryArbiter* in_process_arbiter_ = nullptr;