Remove VideoDecoderConfig.frame_rate_xxx() & VideoFrame:Get/SetDuration()

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>
+#include <utility>
 
 #include "media/base/pipeline_status.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/video_decoder.h"
 #include "media/video/video_decode_accelerator.h"
 
 class MessageLoop;
 template <class T> class scoped_refptr;
 namespace base {
 class MessageLoopProxy;
@@ skipping 90 matching lines @@
   // 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(
       const BitstreamBuffer& bitstream_buffer, const Buffer& buffer);
-  void GetBufferTimeData(
-      int32 id, base::TimeDelta* timestamp, base::TimeDelta* duration);
+  base::TimeDelta GetBufferTimestamp(int32 id);
 
   // 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_;
 
-  // Frame duration specified in the video stream's configuration, or 0 if not
-  // present.
-  base::TimeDelta config_frame_duration_;
-
   // 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_;
 
-  struct BufferTimeData {
-    BufferTimeData(int32 bbid, base::TimeDelta ts, base::TimeDelta dur);
-    ~BufferTimeData();
-    int32 bitstream_buffer_id;
-    base::TimeDelta timestamp;
-    base::TimeDelta duration;
-  };
+  // Maintains bitstream buffer ID to timestamp mappings.
+  typedef std::pair<int32, base::TimeDelta> BufferTimeData;
   std::list<BufferTimeData> input_buffer_time_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_