gpu: Remove gpu channel filter and queue from header.

media/gpu/ipc/service/media_gpu_channel.cc

Index: media/gpu/ipc/service/media_gpu_channel.cc
diff --git a/media/gpu/ipc/service/media_gpu_channel.cc b/media/gpu/ipc/service/media_gpu_channel.cc
index 288598ca75b34e5ab39970002ae404c8484b53d5..e7e35440ad9c5b1129c2c453c03febb774c51b53 100644
--- a/media/gpu/ipc/service/media_gpu_channel.cc
+++ b/media/gpu/ipc/service/media_gpu_channel.cc
@@ -13,25 +13,6 @@
 
 namespace media {
 
-namespace {
-
-void SendCreateJpegDecoderResult(
-    std::unique_ptr<IPC::Message> reply_message,
-    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    base::WeakPtr<gpu::GpuChannel> channel,
-    scoped_refptr<gpu::GpuChannelMessageFilter> filter,
-    bool result) {
-  GpuChannelMsg_CreateJpegDecoder::WriteReplyParams(reply_message.get(),
-                                                    result);
-  if (io_task_runner->BelongsToCurrentThread()) {
-    filter->Send(reply_message.release());
-  } else if (channel) {
-    channel->Send(reply_message.release());
-  }
-}
-
-}  // namespace
-
 class MediaGpuChannelDispatchHelper {
  public:
   MediaGpuChannelDispatchHelper(MediaGpuChannel* channel, int32_t routing_id)
@@ -64,7 +45,8 @@ class MediaGpuChannelFilter : public IPC::MessageFilter {
       : channel_token_(channel_token) {}
 
   void OnFilterAdded(IPC::Channel* channel) override { channel_ = channel; }
-  bool Send(IPC::Message* msg) { return channel_->Send(msg); }
+
+  void OnFilterRemoved() override { channel_ = nullptr; }
 
   bool OnMessageReceived(const IPC::Message& msg) override {
     bool handled = true;
@@ -82,6 +64,12 @@ class MediaGpuChannelFilter : public IPC::MessageFilter {
     Send(reply_message);
   }
 
+  bool Send(IPC::Message* msg) {
+    if (channel_)
+      return channel_->Send(msg);
+    return false;
+  }
+
  private:
   ~MediaGpuChannelFilter() override {}
 
@@ -93,8 +81,10 @@ MediaGpuChannel::MediaGpuChannel(
     gpu::GpuChannel* channel,
     const base::UnguessableToken& channel_token,
     const AndroidOverlayMojoFactoryCB& overlay_factory_cb)
-    : channel_(channel), overlay_factory_cb_(overlay_factory_cb) {
-  channel_->AddFilter(new MediaGpuChannelFilter(channel_token));
+    : channel_(channel),
+      filter_(new MediaGpuChannelFilter(channel_token)),
+      overlay_factory_cb_(overlay_factory_cb) {
+  channel_->AddFilter(filter_.get());
 }
 
 MediaGpuChannel::~MediaGpuChannel() {}
@@ -120,6 +110,25 @@ bool MediaGpuChannel::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
+namespace {
+
+void SendCreateJpegDecoderResult(
+    std::unique_ptr<IPC::Message> reply_message,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    base::WeakPtr<IPC::Sender> channel,
+    scoped_refptr<MediaGpuChannelFilter> filter,
+    bool result) {
+  GpuChannelMsg_CreateJpegDecoder::WriteReplyParams(reply_message.get(),
+                                                    result);
+  if (io_task_runner->BelongsToCurrentThread()) {
+    filter->Send(reply_message.release());
+  } else if (channel) {
+    channel->Send(reply_message.release());
+  }
+}
+
+}  // namespace
+
 void MediaGpuChannel::OnCreateJpegDecoder(int32_t route_id,
                                           IPC::Message* reply_msg) {
   std::unique_ptr<IPC::Message> msg(reply_msg);
@@ -132,9 +141,9 @@ void MediaGpuChannel::OnCreateJpegDecoder(int32_t route_id,
         new GpuJpegDecodeAccelerator(channel_, channel_->io_task_runner()));
   }
   jpeg_decoder_->AddClient(
-      route_id, base::Bind(&SendCreateJpegDecoderResult, base::Passed(&msg),
-                           channel_->io_task_runner(), channel_->AsWeakPtr(),
-                           channel_->filter()));
+      route_id,
+      base::Bind(&SendCreateJpegDecoderResult, base::Passed(&msg),
+                 channel_->io_task_runner(), channel_->AsWeakPtr(), filter_));
 }
 
 void MediaGpuChannel::OnCreateVideoDecoder(