Pass in media message loop to VideoRendererBase and enforce calling on the right thread.

media/filters/video_renderer_base.h

 // Copyright (c) 2012 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 MEDIA_FILTERS_VIDEO_RENDERER_BASE_H_
 #define MEDIA_FILTERS_VIDEO_RENDERER_BASE_H_
 
 #include <deque>
 
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_renderer.h"
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 
 // VideoRendererBase creates its own thread for the sole purpose of timing frame
 // presentation.  It handles reading from the decoder and stores the results in
 // a queue of decoded frames and executing a callback when a frame is ready for
 // rendering.
 class MEDIA_EXPORT VideoRendererBase
     : public VideoRenderer,
       public base::PlatformThread::Delegate {
  public:
@@ skipping 11 matching lines @@
   // Implementors should avoid doing any sort of heavy work in this method and
   // instead post a task to a common/worker thread to handle rendering.  Slowing
   // down the video thread may result in losing synchronization with audio.
   //
   // Setting |drop_frames_| to true causes the renderer to drop expired frames.
   //
   // TODO(scherkus): pass the VideoFrame* to this callback and remove
   // Get/PutCurrentFrame() http://crbug.com/108435
   VideoRendererBase(const base::Closure& paint_cb,
                     const SetOpaqueCB& set_opaque_cb,
-                    bool drop_frames);
+                    bool drop_frames,
+                    const scoped_refptr<base::MessageLoopProxy>& message_loop);

[Ami GONE FROM CHROMIUM, 2012/11/29 23:34:23]

could alternatively let the decoder tell the renderer what loop it lives on.

[scherkus (not reviewing), 2012/11/29 23:45:56]

I'm mulling over this one

the "caller has to know the right msg loop" model requires that the caller is
given a handle at some point. either it's provided up front (this PS) or as you
suggest the decoder can expose it

my gut tells me the latter is less optimal for some reason -- perhaps because we
have everything running on the same thread today so it seems unnecessary in the
long run i.e., VRB should be fixed to run on message_loop_

 
   // VideoRenderer implementation.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
                           const VideoDecoderList& decoders,
                           const PipelineStatusCB& init_cb,
                           const StatisticsCB& statistics_cb,
                           const TimeCB& max_time_cb,
                           const NaturalSizeChangedCB& size_changed_cb,
                           const base::Closure& ended_cb,
                           const PipelineStatusCB& error_cb,
@@ skipping 180 matching lines @@
   // Embedder callback for notifying a new frame is available for painting.
   base::Closure paint_cb_;
 
   // Callback to execute to inform the player if the video decoder's output is
   // opaque.
   SetOpaqueCB set_opaque_cb_;
 
   // The last natural size |size_changed_cb_| was called with.
   gfx::Size last_natural_size_;
 
+  scoped_refptr<base::MessageLoopProxy> decoder_message_loop_;
+
   DISALLOW_COPY_AND_ASSIGN(VideoRendererBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VIDEO_RENDERER_BASE_H_