Reland r212023 "Rename VideoDecoder::ReadCB to VideoDecoder::DecodeCB."

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 <list>
 #include <map>
 #include <set>
@@ skipping 24 matching lines @@
       public VideoDecodeAccelerator::Client {
  public:
   // The message loop of |factories| will be saved to |gvd_loop_proxy_|.
   explicit GpuVideoDecoder(
       const scoped_refptr<GpuVideoDecoderFactories>& factories);
 
   // VideoDecoder implementation.
   virtual void Initialize(const VideoDecoderConfig& config,
                           const PipelineStatusCB& status_cb) OVERRIDE;
   virtual void Decode(const scoped_refptr<DecoderBuffer>& buffer,
-                      const ReadCB& read_cb) OVERRIDE;
+                      const DecodeCB& decode_cb) OVERRIDE;
   virtual void Reset(const base::Closure& closure) OVERRIDE;
   virtual void Stop(const base::Closure& closure) OVERRIDE;
   virtual bool HasAlpha() const OVERRIDE;
   virtual bool NeedsBitstreamConversion() const OVERRIDE;
   virtual bool CanReadWithoutStalling() const OVERRIDE;
 
   // VideoDecodeAccelerator::Client implementation.
   virtual void NotifyInitializeDone() OVERRIDE;
   virtual void ProvidePictureBuffers(uint32 count,
                                      const gfx::Size& size,
@@ skipping 62 matching lines @@
   base::WeakPtr<GpuVideoDecoder> weak_this_;
 
   scoped_refptr<GpuVideoDecoderFactories> factories_;
 
   // Populated during Initialize() (on success) and unchanged until an error
   // occurs.
   scoped_ptr<VideoDecodeAccelerator> vda_;
 
   // Callbacks that are !is_null() only during their respective operation being
   // asynchronously executed.
-  ReadCB pending_read_cb_;
+  DecodeCB pending_decode_cb_;
   base::Closure pending_reset_cb_;
 
   State state_;
 
   VideoDecoderConfig config_;
 
-  // Is a demuxer read in flight?
-  bool demuxer_read_in_progress_;
-
   // Shared-memory buffer pool.  Since allocating SHM segments requires a
   // round-trip to the browser process, we keep allocation out of the
   // steady-state of the decoder.
   std::vector<SHMBuffer*> available_shm_segments_;
 
   // Book-keeping variables.
   struct BufferPair {
     BufferPair(SHMBuffer* s, const scoped_refptr<DecoderBuffer>& b);
     ~BufferPair();
     SHMBuffer* shm_buffer;
     scoped_refptr<DecoderBuffer> buffer;
   };
   std::map<int32, BufferPair> bitstream_buffers_in_decoder_;
   std::map<int32, PictureBuffer> assigned_picture_buffers_;
   std::map<int32, PictureBuffer> dismissed_picture_buffers_;
   // PictureBuffers given to us by VDA via PictureReady, which we sent forward
-  // as VideoFrames to be rendered via read_cb_, and which will be returned
+  // as VideoFrames to be rendered via decode_cb_, and which will be returned
   // to us via ReusePictureBuffer.
   std::set<int32> picture_buffers_at_display_;
 
   // The texture target used for decoded pictures.
   uint32 decoder_texture_target_;
 
   struct BufferData {
     BufferData(int32 bbid, base::TimeDelta ts, const gfx::Rect& visible_rect,
                const gfx::Size& natural_size);
     ~BufferData();
     int32 bitstream_buffer_id;
     base::TimeDelta timestamp;
     gfx::Rect visible_rect;
     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.
+  // frames that have been decoded but haven't been requested by a Decode() yet.
   std::list<scoped_refptr<VideoFrame> > ready_video_frames_;
   int32 next_picture_buffer_id_;
   int32 next_bitstream_buffer_id_;
 
   // Set during ProvidePictureBuffers(), used for checking and implementing
   // HasAvailableOutputFrames().
   int available_pictures_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuVideoDecoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_GPU_VIDEO_DECODER_H_