MediaService: Implement GetChannelToken IPC

media/gpu/ipc/service/media_channel.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/gpu/ipc/service/media_channel.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"
 #include "media/gpu/ipc/service/gpu_video_encode_accelerator.h"
 
 namespace media {
 
 namespace {
 
 void SendCreateJpegDecoderResult(
     std::unique_ptr<IPC::Message> reply_message,
@@ skipping 30 matching lines @@
                             IPC::Message* reply_message) {
     channel_->OnCreateVideoEncoder(routing_id_, params, reply_message);
   }
 
  private:
   MediaChannel* const channel_;
   const int32_t routing_id_;
   DISALLOW_COPY_AND_ASSIGN(MediaChannelDispatchHelper);
 };
 
-MediaChannel::MediaChannel(gpu::GpuChannel* channel) : channel_(channel) {}
+// Filter to respond to GetChannelToken on the IO thread.
+class MediaChannelFilter : public IPC::MessageFilter {
+ public:
+  explicit MediaChannelFilter(base::UnguessableToken channel_token)

[tguilbert, 2016/09/19 22:32:23]

I think the official guidance danakj gave us is to use const ref (they had
tested the performance difference with gfx::size in a micro benchmark, and found
that it was still better to use a const ref for anything other than a built-in
type).

[sandersd (OOO until July 31), 2016/09/19 22:40:33]

Very well then.

+      : channel_token_(channel_token) {}
+
+  void OnFilterAdded(IPC::Channel* channel) override { channel_ = channel; }
+  bool Send(IPC::Message* msg) { return channel_->Send(msg); }
+
+  bool OnMessageReceived(const IPC::Message& msg) override {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(MediaChannelFilter, 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);
+  }
+
+ private:
+  ~MediaChannelFilter() override {}
+
+  IPC::Channel* channel_;
+  base::UnguessableToken channel_token_;
+};
+
+MediaChannel::MediaChannel(gpu::GpuChannel* channel) : channel_(channel) {
+  channel_->AddFilter(new MediaChannelFilter(base::UnguessableToken::Create()));
+}
 
 MediaChannel::~MediaChannel() {}
 
 bool MediaChannel::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 bool MediaChannel::OnMessageReceived(const IPC::Message& message) {
   MediaChannelDispatchHelper helper(this, message.routing_id());
   bool handled = true;
@@ skipping 66 matching lines @@
                           params.output_profile, params.initial_bitrate);
   GpuCommandBufferMsg_CreateVideoEncoder::WriteReplyParams(reply_message,
                                                            succeeded);
   Send(reply_message);
 
   // encoder is registered as a DestructionObserver of this stub and will
   // self-delete during destruction of this stub.
 }
 
 }  // namespace media