Remove VideoDecoder::natural_size() & added VideoFrame::natural_size().

media/filters/gpu_video_decoder.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_GPU_VIDEO_DECODER_H_
 #define MEDIA_FILTERS_GPU_VIDEO_DECODER_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 49 matching lines @@
                   MessageLoop* vda_loop,
                   const scoped_refptr<Factories>& factories);
 
   // VideoDecoder implementation.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
                           const PipelineStatusCB& status_cb,
                           const StatisticsCB& statistics_cb) OVERRIDE;
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual void Reset(const base::Closure& closure) OVERRIDE;
   virtual void Stop(const base::Closure& closure) OVERRIDE;
-  virtual const gfx::Size& natural_size() OVERRIDE;
   virtual bool HasAlpha() const OVERRIDE;
   virtual void PrepareForShutdownHack() OVERRIDE;
 
   // VideoDecodeAccelerator::Client implementation.
   virtual void NotifyInitializeDone() OVERRIDE;
   virtual void ProvidePictureBuffers(uint32 count,
                                      const gfx::Size& size,
                                      uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
@@ skipping 29 matching lines @@
   // vda->Reset() is in progress) and trigger out-of-line delivery of the oldest
   // ready frame to the client if there is a pending read.  A NULL |frame|
   // merely triggers delivery, and requires the ready_video_frames_ queue not be
   // empty.
   void EnqueueFrameAndTriggerFrameDelivery(
       const scoped_refptr<VideoFrame>& frame);
 
   // Indicate the picturebuffer can be reused by the decoder.
   void ReusePictureBuffer(int64 picture_buffer_id);
 
-  void RecordBufferTimeData(
+  void RecordBufferData(
       const BitstreamBuffer& bitstream_buffer, const Buffer& buffer);
-  base::TimeDelta GetBufferTimestamp(int32 id);
+  void GetBufferData(int32 id, base::TimeDelta* timetamp,
+                     gfx::Size* natural_size);
 
   // Set |vda_| and |weak_vda_| on the VDA thread (in practice the render
   // thread).
   void SetVDA(VideoDecodeAccelerator* vda);
 
   // A shared memory segment and its allocated size.
   struct SHMBuffer {
     SHMBuffer(base::SharedMemory* m, size_t s);
     ~SHMBuffer();
     base::SharedMemory* shm;
     size_t size;
   };
 
   // Request a shared-memory segment of at least |min_size| bytes.  Will
   // allocate as necessary.  Caller does not own returned pointer.
   SHMBuffer* GetSHM(size_t min_size);
 
   // Return a shared-memory segment to the available pool.
   void PutSHM(SHMBuffer* shm_buffer);
 
   StatisticsCB statistics_cb_;
 
-  // TODO(scherkus): I think this should be calculated by VideoRenderers based
-  // on information provided by VideoDecoders (i.e., aspect ratio).
-  gfx::Size natural_size_;
-
   // Pointer to the demuxer stream that will feed us compressed buffers.
   scoped_refptr<DemuxerStream> demuxer_stream_;
 
   // MessageLoop on which to fire callbacks and trampoline calls to this class
   // if they arrive on other loops.
   scoped_refptr<base::MessageLoopProxy> gvd_loop_proxy_;
 
   // Message loop on which to makes all calls to vda_.  (beware this loop may be
   // paused during the Pause/Flush/Stop dance PipelineImpl::Stop() goes
   // through).
@@ skipping 28 matching lines @@
     ~BufferPair();
     SHMBuffer* shm_buffer;
     scoped_refptr<DecoderBuffer> buffer;
   };
   std::map<int32, BufferPair> bitstream_buffers_in_decoder_;
   std::map<int32, PictureBuffer> picture_buffers_in_decoder_;
 
   // The texture target used for decoded pictures.
   uint32 decoder_texture_target_;
 
-  // Maintains bitstream buffer ID to timestamp mappings.
-  typedef std::pair<int32, base::TimeDelta> BufferTimeData;
-  std::list<BufferTimeData> input_buffer_time_data_;
+  struct BufferData {
+    BufferData(int32 bbid, base::TimeDelta ts,
+               const gfx::Size& natural_size);
+    ~BufferData();
+    int32 bitstream_buffer_id;
+    base::TimeDelta timestamp;
+    gfx::Size natural_size;
+  };
+  std::list<BufferData> input_buffer_data_;
 
   // picture_buffer_id and the frame wrapping the corresponding Picture, for
   // frames that have been decoded but haven't been requested by a Read() yet.
   std::list<scoped_refptr<VideoFrame> > ready_video_frames_;
   int64 next_picture_buffer_id_;
   int64 next_bitstream_buffer_id_;
 
   // Indicates PrepareForShutdownHack()'s been called.  Makes further calls to
   // this class not require the render thread's loop to be processing.
   bool shutting_down_;
 
   // Indicates decoding error occurred.
   bool error_occured_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuVideoDecoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_GPU_VIDEO_DECODER_H_