Remove all remaining traces of MessageLoopProxy.

content/renderer/media/gpu/rtc_video_decoder.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 25 matching lines @@
 class GpuVideoAcceleratorFactories;
 }
 
 namespace gpu {
 struct SyncToken;
 }
 
 namespace content {
 
 // This class uses hardware accelerated video decoder to decode video for
-// WebRTC. |vda_message_loop_| is the message loop proxy of the media thread,
-// which VDA::Client methods run on. webrtc::VideoDecoder methods run on WebRTC
-// DecodingThread or Chrome_libJingle_WorkerThread, which are trampolined to
-// |vda_message_loop_|. Decode() is non-blocking and queues the buffers. Decoded
-// frames are delivered to WebRTC on |vda_message_loop_|.
+// WebRTC. Lives on the media thread, where VDA::Client methods run on.
+// webrtc::VideoDecoder methods run on WebRTC DecodingThread or
+// Chrome_libJingle_WorkerThread, which are trampolined to the media thread.
+// Decode() is non-blocking and queues the buffers. Decoded frames are
+// delivered to WebRTC on the media task runner.
 class CONTENT_EXPORT RTCVideoDecoder
     : NON_EXPORTED_BASE(public webrtc::VideoDecoder),
       public media::VideoDecodeAccelerator::Client {
  public:
   ~RTCVideoDecoder() override;
 
   // Creates a RTCVideoDecoder on the message loop of |factories|. Returns NULL
   // if failed. The video decoder will run on the message loop of |factories|.
   static std::unique_ptr<RTCVideoDecoder> Create(
       webrtc::VideoCodecType type,
@@ skipping 95 matching lines @@
 
   // Static method is to allow it to run even after RVD is deleted.
   static void ReleaseMailbox(base::WeakPtr<RTCVideoDecoder> decoder,
                              media::GpuVideoAcceleratorFactories* factories,
                              int64_t picture_buffer_id,
                              uint32_t texture_id,
                              const gpu::SyncToken& release_sync_token);
   // Tells VDA that a picture buffer can be recycled.
   void ReusePictureBuffer(int64_t picture_buffer_id);
 
-  // Creates |vda_| on |vda_loop_proxy_|.
+  // Creates |vda_| on the media thread.
   void CreateVDA(media::VideoCodecProfile profile, base::WaitableEvent* waiter);
 
   void DestroyTextures();
   void DestroyVDA();
 
   // Gets a shared-memory segment of at least |min_size| bytes from
   // |available_shm_segments_|. Returns NULL if there is no buffer or the
   // buffer is not big enough.
   std::unique_ptr<base::SharedMemory> GetSHM_Locked(size_t min_size);
 
@@ skipping 110 matching lines @@
   int32_t next_bitstream_buffer_id_;
 
   // A buffer that has an id less than this should be dropped because Reset or
   // Release has been called. Guarded by |lock_|.
   int32_t reset_bitstream_buffer_id_;
 
   // Minimum and maximum supported resolutions for the current profile/VDA.
   gfx::Size min_resolution_;
   gfx::Size max_resolution_;
 
-  // Must be destroyed, or invalidated, on |vda_loop_proxy_|
+  // Must be destroyed, or invalidated, on the media thread.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_