Replace VideoDecoder::media_format() with significantly simpler width()/height() methods.

media/filters/video_renderer_base.h

 // Copyright (c) 2011 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.
 
 // 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, calling OnFrameAvailable() on subclasses to notify
 // when a frame is ready to display.
 //
 // The media filter methods Initialize(), Stop(), SetPlaybackRate() and Seek()
@@ skipping 18 matching lines @@
 
 // TODO(scherkus): to avoid subclasses, consider using a peer/delegate interface
 // and pass in a reference to the constructor.
 class VideoRendererBase
     : public VideoRenderer,
       public base::PlatformThread::Delegate {
  public:
   VideoRendererBase();
   virtual ~VideoRendererBase();
 
-  // Helper method to parse out video-related information from a MediaFormat.
-  // Returns true all the required parameters are existent in |media_format|.
-  // |surface_format_out|, |width_out|, |height_out| can be NULL where the
-  // result is not needed.
-  static bool ParseMediaFormat(
-      const MediaFormat& media_format,
-      VideoFrame::Format* surface_format_out,
-      int* width_out, int* height_out);
-
   // Filter implementation.
   virtual void Play(FilterCallback* callback);
   virtual void Pause(FilterCallback* callback);
   virtual void Flush(FilterCallback* callback);
   virtual void Stop(FilterCallback* callback);
   virtual void SetPlaybackRate(float playback_rate);
   virtual void Seek(base::TimeDelta time, const FilterStatusCB& cb);
 
   // VideoRenderer implementation.
   virtual void Initialize(VideoDecoder* decoder,
@@ skipping 11 matching lines @@
   // is NULL. This could happen when before pipeline is pre-rolled or during
   // pause/flush/seek.
   void GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out);
   void PutCurrentFrame(scoped_refptr<VideoFrame> frame);
 
  protected:
   // Subclass interface.  Called before any other initialization in the base
   // class takes place.
   //
   // Implementors typically use the media format of |decoder| to create their
-  // output surfaces.  Implementors should NOT call InitializationComplete().
+  // output surfaces.
   virtual bool OnInitialize(VideoDecoder* decoder) = 0;
 
   // Subclass interface.  Called after all other stopping actions take place.
   //
   // Implementors should perform any necessary cleanup before calling the
   // callback.
   virtual void OnStop(FilterCallback* callback) = 0;
 
   // Subclass interface.  Called when a new frame is ready for display, which
   // can be accessed via GetCurrentFrame().
   //
   // 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.
   //
   // IMPORTANT: This method is called on the video renderer thread, which is
   // different from the thread OnInitialize(), OnStop(), and the rest of the
   // class executes on.
   virtual void OnFrameAvailable() = 0;
 
-  virtual VideoDecoder* GetDecoder();
-
-  int width() { return width_; }
-  int height() { return height_; }
-  VideoFrame::Format surface_format() { return surface_format_; }
-
   void ReadInput(scoped_refptr<VideoFrame> frame);
 
  private:
   // Callback from video decoder to deliver decoded video frames and decrements
   // |pending_reads_|.
   void ConsumeVideoFrame(scoped_refptr<VideoFrame> frame);
 
   // Helper method that schedules an asynchronous read from the decoder and
   // increments |pending_reads_|.
   //
@@ skipping 18 matching lines @@
   void EnterErrorState_Locked(PipelineStatus status);
 
   // Helper function that flushes the buffers when a Stop() or error occurs.
   void DoStopOrErrorFlush_Locked();
 
   // Used for accessing data members.
   base::Lock lock_;
 
   scoped_refptr<VideoDecoder> decoder_;
 
-  int width_;
-  int height_;
-  VideoFrame::Format surface_format_;
-
   // Queue of incoming frames as well as the current frame since the last time
   // OnFrameAvailable() was called.
   typedef std::deque< scoped_refptr<VideoFrame> > VideoFrameQueue;
   VideoFrameQueue frames_queue_ready_;
   VideoFrameQueue frames_queue_done_;
   scoped_refptr<VideoFrame> current_frame_;
   scoped_refptr<VideoFrame> last_available_frame_;
 
   // Used to signal |thread_| as frames are added to |frames_|.  Rule of thumb:
   // always check |state_| to see if it was set to STOPPED after waking up!
@@ skipping 60 matching lines @@
   scoped_ptr<StatisticsCallback> statistics_callback_;
 
   base::TimeDelta seek_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VIDEO_RENDERER_BASE_H_