gpu: Move GetChannelToken IPC to GpuChannel

GpuCommandBufferMsg_GetChannelToken is defined and exclusively used by
the Media stack to identify GpuChannel endpoints within messages on
non-GpuChannel interfaces targeting the GPU process.

Since this concept can easily be rationalized as a general feature of
the GpuChannel, and because layering Media interfaces on the GpuChannel
would require substantially more complexity for just this one IPC, this
change integrates the concept of a "channel token" into GpuChannel
itself.

The token is assigned at construction time by GpuServiceImpl and can be
retrieved directly from the GpuChannel via a new synchronous
gpu.mojom.GpuChannel.GetChannelToken message. The legacy IPC message
is removed.

Bug: 1196476, 993189
Change-Id: I1f114d6a1ea32ba6da62dbb4023018be4467c293
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2956388
Reviewed-by: Sean Topping <seantopping@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Reviewed-by: Sunny Sachanandani <sunnyps@chromium.org>
Commit-Queue: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#891766}

chromecast/media/gpu/cast_gpu_factory_impl.cc

@@ -298,8 +298,8 @@ void CastGpuFactoryImpl::SetupContext() {
   }
 
   // Get the channel token for the current connection.
-  context_provider_->GetCommandBufferProxy()->channel()->Send(
-      new GpuCommandBufferMsg_GetChannelToken(&channel_token_));
+  context_provider_->GetCommandBufferProxy()->GetGpuChannel().GetChannelToken(
+      &channel_token_);
 
   gpu_->CreateVideoEncodeAcceleratorProvider(
       vea_provider_.BindNewPipeAndPassReceiver());

components/viz/service/gl/gpu_service_impl.cc

@@ -17,6 +17,7 @@
 #include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
 #include "components/viz/common/features.h"
@@ -979,8 +980,10 @@ void GpuServiceImpl::EstablishGpuChannel(int32_t client_id,
     return;
   }
 
+  auto channel_token = base::UnguessableToken::Create();
   gpu::GpuChannel* gpu_channel = gpu_channel_manager_->EstablishChannel(
-      client_id, client_tracing_id, is_gpu_host, cache_shaders_on_disk);
+      channel_token, client_id, client_tracing_id, is_gpu_host,
+      cache_shaders_on_disk);
 
   if (!gpu_channel) {
     // This returns a null handle, which is treated by the client as a failure
@@ -992,7 +995,7 @@ void GpuServiceImpl::EstablishGpuChannel(int32_t client_id,
   mojo::MessagePipe pipe;
   gpu_channel->Init(pipe.handle0.release(), shutdown_event_);
 
-  media_gpu_channel_manager_->AddChannel(client_id);
+  media_gpu_channel_manager_->AddChannel(client_id, channel_token);
 
   std::move(callback).Run(std::move(pipe.handle1), gpu_info_,
                           gpu_feature_info_);

content/browser/media/android/browser_gpu_video_accelerator_factories.cc

@@ -88,8 +88,8 @@ bool BrowserGpuVideoAcceleratorFactories::IsGpuVideoAcceleratorEnabled() {
 
 base::UnguessableToken BrowserGpuVideoAcceleratorFactories::GetChannelToken() {
   if (channel_token_.is_empty()) {
-    context_provider_->GetCommandBufferProxy()->channel()->Send(
-        new GpuCommandBufferMsg_GetChannelToken(&channel_token_));
+    context_provider_->GetCommandBufferProxy()->GetGpuChannel().GetChannelToken(
+        &channel_token_);
   }
 
   return channel_token_;

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.cc

@@ -286,8 +286,8 @@ base::UnguessableToken GpuVideoAcceleratorFactoriesImpl::GetChannelToken() {
     return base::UnguessableToken();
 
   if (channel_token_.is_empty()) {
-    context_provider_->GetCommandBufferProxy()->channel()->Send(
-        new GpuCommandBufferMsg_GetChannelToken(&channel_token_));
+    context_provider_->GetCommandBufferProxy()->GetGpuChannel().GetChannelToken(
+        &channel_token_);
   }
 
   return channel_token_;

gpu/ipc/client/command_buffer_proxy_impl.h

@@ -35,6 +35,7 @@
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/command_buffer/common/scheduling_priority.h"
 #include "gpu/gpu_export.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/ipc/common/gpu_channel.mojom.h"
 #include "gpu/ipc/common/surface_handle.h"
 #include "ipc/ipc_listener.h"
@@ -157,6 +158,10 @@ class GPU_EXPORT CommandBufferProxyImpl : public gpu::CommandBuffer,
 
   const scoped_refptr<GpuChannelHost>& channel() const { return channel_; }
 
+  mojom::GpuChannel& GetGpuChannel() const {
+    return channel()->GetGpuChannel();
+  }
+
   const base::UnsafeSharedMemoryRegion& GetSharedStateRegion() const {
     return shared_state_shm_;
   }

gpu/ipc/common/gpu_channel.mojom

@@ -140,6 +140,10 @@ interface GpuChannel {
   // intentionally terminated with an exit code of 0.
   TerminateForTesting();
 
+  // Returns a globally unique token which can be used by other interfaces to
+  // securely identify this GpuChannel endpoint within the GPU process.
+  [Sync] GetChannelToken() => (mojo_base.mojom.UnguessableToken token);
+
   // A simple no-op message used as a fence to ensure all previously sent
   // messages have been received.
   //

gpu/ipc/common/mock_gpu_channel.h

@@ -19,6 +19,7 @@ class MockGpuChannel : public mojom::GpuChannel {
   // mojom::GpuChannel:
   MOCK_METHOD0(CrashForTesting, void());
   MOCK_METHOD0(TerminateForTesting, void());
+  MOCK_METHOD1(GetChannelToken, void(GetChannelTokenCallback));
   MOCK_METHOD0(Flush, bool());
   MOCK_METHOD1(Flush, void(FlushCallback));
   MOCK_METHOD6(CreateCommandBuffer,
@@ -44,22 +45,13 @@ class MockGpuChannel : public mojom::GpuChannel {
   MOCK_METHOD1(FlushDeferredRequests,
                void(std::vector<mojom::DeferredRequestPtr>));
 #if defined(OS_ANDROID)
-  MOCK_METHOD3(CreateStreamTexture,
-               bool(int32_t,
-                    mojo::PendingAssociatedReceiver<mojom::StreamTexture>,
-                    bool*));
   MOCK_METHOD3(CreateStreamTexture,
                void(int32_t,
                     mojo::PendingAssociatedReceiver<mojom::StreamTexture>,
                     CreateStreamTextureCallback));
 #endif  // defined(OS_ANDROID)
-  MOCK_METHOD4(WaitForTokenInRange,
-               bool(int32_t, int32_t, int32_t, CommandBuffer::State*));
   MOCK_METHOD4(WaitForTokenInRange,
                void(int32_t, int32_t, int32_t, WaitForTokenInRangeCallback));
-  MOCK_METHOD5(
-      WaitForGetOffsetInRange,
-      bool(int32_t, uint32_t, int32_t, int32_t, CommandBuffer::State*));
   MOCK_METHOD5(WaitForGetOffsetInRange,
                void(int32_t,
                     uint32_t,

gpu/ipc/service/gpu_channel.cc

@@ -34,6 +34,7 @@
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/service/image_factory.h"
@@ -105,6 +106,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelMessageFilter
  public:
   GpuChannelMessageFilter(
       gpu::GpuChannel* gpu_channel,
+      const base::UnguessableToken& channel_token,
       Scheduler* scheduler,
       ImageDecodeAcceleratorWorker* image_decode_accelerator_worker,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
@@ -147,6 +149,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelMessageFilter
   // mojom::GpuChannel:
   void CrashForTesting() override;
   void TerminateForTesting() override;
+  void GetChannelToken(GetChannelTokenCallback callback) override;
   void Flush(FlushCallback callback) override;
   void CreateCommandBuffer(
       mojom::CreateCommandBufferParamsPtr config,
@@ -222,6 +225,11 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelMessageFilter
   // before dereferencing.
   gpu::GpuChannel* gpu_channel_ GUARDED_BY(gpu_channel_lock_) = nullptr;
 
+  // A token which can be retrieved by GetChannelToken to uniquely identify this
+  // channel. Assigned at construction time by the GpuChannelManager, where the
+  // token-to-GpuChannel mapping lives.
+  const base::UnguessableToken channel_token_;
+
   Scheduler* scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
@@ -237,10 +245,12 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelMessageFilter
 
 GpuChannelMessageFilter::GpuChannelMessageFilter(
     gpu::GpuChannel* gpu_channel,
+    const base::UnguessableToken& channel_token,
     Scheduler* scheduler,
     ImageDecodeAcceleratorWorker* image_decode_accelerator_worker,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : gpu_channel_(gpu_channel),
+      channel_token_(channel_token),
       scheduler_(scheduler),
       main_task_runner_(std::move(main_task_runner)),
       image_decode_accelerator_stub_(
@@ -444,6 +454,11 @@ void GpuChannelMessageFilter::TerminateForTesting() {
   receiver_.ReportBadMessage("TerminateForTesting is a test-only API");
 }
 
+void GpuChannelMessageFilter::GetChannelToken(
+    GetChannelTokenCallback callback) {
+  std::move(callback).Run(channel_token_);
+}
+
 void GpuChannelMessageFilter::Flush(FlushCallback callback) {
   std::move(callback).Run();
 }
@@ -552,6 +567,7 @@ void GpuChannelMessageFilter::WaitForGetOffsetInRange(
 
 GpuChannel::GpuChannel(
     GpuChannelManager* gpu_channel_manager,
+    const base::UnguessableToken& channel_token,
     Scheduler* scheduler,
     SyncPointManager* sync_point_manager,
     scoped_refptr<gl::GLShareGroup> share_group,
@@ -573,8 +589,9 @@ GpuChannel::GpuChannel(
       is_gpu_host_(is_gpu_host) {
   DCHECK(gpu_channel_manager_);
   DCHECK(client_id_);
-  filter_ = new GpuChannelMessageFilter(
-      this, scheduler, image_decode_accelerator_worker, task_runner);
+  filter_ =
+      new GpuChannelMessageFilter(this, channel_token, scheduler,
+                                  image_decode_accelerator_worker, task_runner);
 }
 
 GpuChannel::~GpuChannel() {
@@ -598,6 +615,7 @@ GpuChannel::~GpuChannel() {
 
 std::unique_ptr<GpuChannel> GpuChannel::Create(
     GpuChannelManager* gpu_channel_manager,
+    const base::UnguessableToken& channel_token,
     Scheduler* scheduler,
     SyncPointManager* sync_point_manager,
     scoped_refptr<gl::GLShareGroup> share_group,
@@ -607,11 +625,11 @@ std::unique_ptr<GpuChannel> GpuChannel::Create(
     uint64_t client_tracing_id,
     bool is_gpu_host,
     ImageDecodeAcceleratorWorker* image_decode_accelerator_worker) {
-  auto gpu_channel = base::WrapUnique(
-      new GpuChannel(gpu_channel_manager, scheduler, sync_point_manager,
-                     std::move(share_group), std::move(task_runner),
-                     std::move(io_task_runner), client_id, client_tracing_id,
-                     is_gpu_host, image_decode_accelerator_worker));
+  auto gpu_channel = base::WrapUnique(new GpuChannel(
+      gpu_channel_manager, channel_token, scheduler, sync_point_manager,
+      std::move(share_group), std::move(task_runner), std::move(io_task_runner),
+      client_id, client_tracing_id, is_gpu_host,
+      image_decode_accelerator_worker));
 
   if (!gpu_channel->CreateSharedImageStub()) {
     LOG(ERROR) << "GpuChannel: Failed to create SharedImageStub";

gpu/ipc/service/gpu_channel.h

@@ -20,6 +20,7 @@
 #include "base/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/memory_dump_provider.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/capabilities.h"
 #include "gpu/command_buffer/common/context_result.h"
@@ -63,6 +64,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannel : public IPC::Listener,
 
   static std::unique_ptr<GpuChannel> Create(
       GpuChannelManager* gpu_channel_manager,
+      const base::UnguessableToken& channel_token,
       Scheduler* scheduler,
       SyncPointManager* sync_point_manager,
       scoped_refptr<gl::GLShareGroup> share_group,
@@ -213,6 +215,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannel : public IPC::Listener,
  private:
   // Takes ownership of the renderer process handle.
   GpuChannel(GpuChannelManager* gpu_channel_manager,
+             const base::UnguessableToken& channel_token,
              Scheduler* scheduler,
              SyncPointManager* sync_point_manager,
              scoped_refptr<gl::GLShareGroup> share_group,

gpu/ipc/service/gpu_channel_manager.cc

@@ -419,18 +419,20 @@ GpuChannel* GpuChannelManager::LookupChannel(int32_t client_id) const {
   return it != gpu_channels_.end() ? it->second.get() : nullptr;
 }
 
-GpuChannel* GpuChannelManager::EstablishChannel(int client_id,
-                                                uint64_t client_tracing_id,
-                                                bool is_gpu_host,
-                                                bool cache_shaders_on_disk) {
+GpuChannel* GpuChannelManager::EstablishChannel(
+    const base::UnguessableToken& channel_token,
+    int client_id,
+    uint64_t client_tracing_id,
+    bool is_gpu_host,
+    bool cache_shaders_on_disk) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (gr_shader_cache_ && cache_shaders_on_disk)
     gr_shader_cache_->CacheClientIdOnDisk(client_id);
 
   std::unique_ptr<GpuChannel> gpu_channel = GpuChannel::Create(
-      this, scheduler_, sync_point_manager_, share_group_, task_runner_,
-      io_task_runner_, client_id, client_tracing_id, is_gpu_host,
+      this, channel_token, scheduler_, sync_point_manager_, share_group_,
+      task_runner_, io_task_runner_, client_id, client_tracing_id, is_gpu_host,
       image_decode_accelerator_worker_);
 
   if (!gpu_channel)

gpu/ipc/service/gpu_channel_manager.h

@@ -18,6 +18,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_checker.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/activity_flags.h"
 #include "gpu/command_buffer/common/constants.h"
@@ -98,7 +99,8 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelManager
   GpuChannelManagerDelegate* delegate() const { return delegate_; }
   GpuWatchdogThread* watchdog() const { return watchdog_; }
 
-  GpuChannel* EstablishChannel(int client_id,
+  GpuChannel* EstablishChannel(const base::UnguessableToken& channel_token,
+                               int client_id,
                                uint64_t client_tracing_id,
                                bool is_gpu_host,
                                bool cache_shaders_on_disk);

gpu/ipc/service/gpu_channel_manager_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/trace_event/trace_event_filter.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "base/trace_event/trace_log.h"
+#include "base/unguessable_token.h"
 #include "gpu/command_buffer/common/capabilities.h"
 #include "gpu/command_buffer/common/context_result.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
@@ -179,7 +180,8 @@ TEST_F(GpuChannelManagerTest, EstablishChannel) {
 
   ASSERT_TRUE(channel_manager());
   GpuChannel* channel = channel_manager()->EstablishChannel(
-      kClientId, kClientTracingId, false, true);
+      base::UnguessableToken::Create(), kClientId, kClientTracingId, false,
+      true);
   EXPECT_TRUE(channel);
   EXPECT_EQ(channel_manager()->LookupChannel(kClientId), channel);
 }

gpu/ipc/service/gpu_channel_test_common.cc

@@ -12,6 +12,7 @@
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
+#include "base/unguessable_token.h"
 #include "gpu/command_buffer/common/activity_flags.h"
 #include "gpu/command_buffer/service/scheduler.h"
 #include "gpu/command_buffer/service/shared_image_manager.h"
@@ -112,7 +113,8 @@ GpuChannel* GpuChannelTestCommon::CreateChannel(int32_t client_id,
                                                 bool is_gpu_host) {
   uint64_t kClientTracingId = 1;
   GpuChannel* channel = channel_manager()->EstablishChannel(
-      client_id, kClientTracingId, is_gpu_host, true);
+      base::UnguessableToken::Create(), client_id, kClientTracingId,
+      is_gpu_host, true);
   channel->InitForTesting(&sink_);
   base::ProcessId kProcessId = 1;
   channel->OnChannelConnected(kProcessId);

media/gpu/ipc/common/media_messages.h

@@ -33,15 +33,6 @@ IPC_STRUCT_BEGIN(AcceleratedVideoDecoderHostMsg_PictureReady_Params)
   IPC_STRUCT_MEMBER(bool, wants_promotion_hint)
 IPC_STRUCT_END()
 
-//------------------------------------------------------------------------------
-// Utility Messages
-
-// Sent from Renderer to GPU process to request a token identifying the channel.
-// These tokens can be used to prove ownership of the channel. The intended use
-// case is to share the command buffer with MojoMediaApplication.
-IPC_SYNC_MESSAGE_CONTROL0_1(GpuCommandBufferMsg_GetChannelToken,
-                            base::UnguessableToken /* channel_token */)
-
 //------------------------------------------------------------------------------
 // Accelerated Video Decoder Messages
 // These messages are sent from Renderer process to GPU process.

media/gpu/ipc/service/media_gpu_channel.cc

@@ -5,9 +5,7 @@
 #include "media/gpu/ipc/service/media_gpu_channel.h"
 
 #include "base/single_thread_task_runner.h"
-#include "base/unguessable_token.h"
 #include "gpu/ipc/service/gpu_channel.h"
-#include "ipc/message_filter.h"
 #include "media/gpu/ipc/common/media_messages.h"
 #include "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 
@@ -33,54 +31,10 @@ class MediaGpuChannelDispatchHelper {
   DISALLOW_COPY_AND_ASSIGN(MediaGpuChannelDispatchHelper);
 };
 
-// Filter to respond to GetChannelToken on the IO thread.
-class MediaGpuChannelFilter : public IPC::MessageFilter {
- public:
-  explicit MediaGpuChannelFilter(const base::UnguessableToken& channel_token)
-      : channel_token_(channel_token) {}
-
-  void OnFilterAdded(IPC::Channel* channel) override { channel_ = channel; }
-
-  void OnFilterRemoved() override { channel_ = nullptr; }
-
-  bool OnMessageReceived(const IPC::Message& msg) override {
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(MediaGpuChannelFilter, msg)
-      IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetChannelToken,
-                                      OnGetChannelToken)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-  }
-
-  void OnGetChannelToken(IPC::Message* reply_message) {
-    GpuCommandBufferMsg_GetChannelToken::WriteReplyParams(reply_message,
-                                                          channel_token_);
-    Send(reply_message);
-  }
-
-  bool Send(IPC::Message* msg) {
-    if (channel_)
-      return channel_->Send(msg);
-    return false;
-  }
-
- private:
-  ~MediaGpuChannelFilter() override = default;
-
-  IPC::Channel* channel_;
-  base::UnguessableToken channel_token_;
-};
-
 MediaGpuChannel::MediaGpuChannel(
     gpu::GpuChannel* channel,
-    const base::UnguessableToken& channel_token,
     const AndroidOverlayMojoFactoryCB& overlay_factory_cb)
-    : channel_(channel),
-      filter_(new MediaGpuChannelFilter(channel_token)),
-      overlay_factory_cb_(overlay_factory_cb) {
-  channel_->AddFilter(filter_.get());
-}
+    : channel_(channel), overlay_factory_cb_(overlay_factory_cb) {}
 
 MediaGpuChannel::~MediaGpuChannel() = default;
 

media/gpu/ipc/service/media_gpu_channel.h

@@ -18,12 +18,10 @@ class GpuChannel;
 namespace media {
 
 class MediaGpuChannelDispatchHelper;
-class MediaGpuChannelFilter;
 
 class MediaGpuChannel : public IPC::Listener, public IPC::Sender {
  public:
   MediaGpuChannel(gpu::GpuChannel* channel,
-                  const base::UnguessableToken& channel_token,
                   const AndroidOverlayMojoFactoryCB& overlay_factory_cb);
   ~MediaGpuChannel() override;
 
@@ -43,7 +41,6 @@ class MediaGpuChannel : public IPC::Listener, public IPC::Sender {
                             IPC::Message* reply_message);
 
   gpu::GpuChannel* const channel_;
-  scoped_refptr<MediaGpuChannelFilter> filter_;
   AndroidOverlayMojoFactoryCB overlay_factory_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaGpuChannel);

media/gpu/ipc/service/media_gpu_channel_manager.cc

@@ -22,12 +22,13 @@ MediaGpuChannelManager::MediaGpuChannelManager(
 
 MediaGpuChannelManager::~MediaGpuChannelManager() = default;
 
-void MediaGpuChannelManager::AddChannel(int32_t client_id) {
+void MediaGpuChannelManager::AddChannel(
+    int32_t client_id,
+    const base::UnguessableToken& channel_token) {
   gpu::GpuChannel* gpu_channel = channel_manager_->LookupChannel(client_id);
   DCHECK(gpu_channel);
-  base::UnguessableToken channel_token = base::UnguessableToken::Create();
-  std::unique_ptr<MediaGpuChannel> media_gpu_channel(
-      new MediaGpuChannel(gpu_channel, channel_token, overlay_factory_cb_));
+  auto media_gpu_channel =
+      std::make_unique<MediaGpuChannel>(gpu_channel, overlay_factory_cb_);
   gpu_channel->SetUnhandledMessageListener(media_gpu_channel.get());
   media_gpu_channels_[client_id] = std::move(media_gpu_channel);
   channel_to_token_[client_id] = channel_token;

media/gpu/ipc/service/media_gpu_channel_manager.h

@@ -33,7 +33,8 @@ class MediaGpuChannelManager
   explicit MediaGpuChannelManager(gpu::GpuChannelManager* channel_manager);
   ~MediaGpuChannelManager();
 
-  void AddChannel(int32_t client_id);
+  void AddChannel(int32_t client_id,
+                  const base::UnguessableToken& channel_token);
   void RemoveChannel(int32_t client_id);
   void DestroyAllChannels();