Add an additional VDA::Flush() mode to return all allocated buffers.

content/common/gpu/media/v4l2_slice_video_decode_accelerator.h

 // Copyright 2015 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 CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <linux/videodev2.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 32 matching lines @@
       const base::Callback<bool(void)>& make_context_current,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   ~V4L2SliceVideoDecodeAccelerator() override;
 
   // media::VideoDecodeAccelerator implementation.
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
-  void Flush() override;
+  void Flush(bool return_buffers) override;
   void Reset() override;
   void Destroy() override;
   bool CanDecodeOnIOThread() override;
 
   static media::VideoDecodeAccelerator::SupportedProfiles
       GetSupportedProfiles();
 
  private:
   class V4L2H264Accelerator;
   class V4L2VP8Accelerator;
@@ skipping 112 matching lines @@
 
   // Sets the state to kError and notifies client if needed.
   void SetErrorState(Error error);
 
   // Flush flow when requested by client.
   // When Flush() is called, it posts a FlushTask, which checks the input queue.
   // If nothing is pending for decode on decoder_input_queue_, we call
   // InitiateFlush() directly. Otherwise, we push a dummy BitstreamBufferRef
   // onto the decoder_input_queue_ to schedule a flush. When we reach it later
   // on, we call InitiateFlush() to perform it at the correct time.
-  void FlushTask();
+  void FlushTask(bool return_buffers);
   // Tell the decoder to flush all frames, reset it and mark us as scheduled
   // for flush, so that we can finish it once all pending decodes are finished.
   void InitiateFlush();
   // To be called if decoder_flushing_ is true. If not all pending frames are
   // decoded, return false, requesting the caller to try again later.
   // Otherwise perform flush by sending all pending pictures to the client,
   // notify it that flush is finished and return true, informing the caller
   // that further progress can be made.
   bool FinishFlush();
 
@@ skipping 168 matching lines @@
   // Decoder state.
   State state_;
 
   // If any of these are true, we are waiting for the device to finish decoding
   // all previously-queued frames, so we can finish the flush/reset/surface
   // change flows. These can stack.
   bool decoder_flushing_;
   bool decoder_resetting_;
   bool surface_set_change_pending_;
 
+  // When flushing, if true, indicates that we were requested to return all
+  // output buffers, not only those containing pictures produced during flush.
+  bool flush_return_all_buffers_;
+
   // Hardware accelerators.
   // TODO(posciak): Try to have a superclass here if possible.
   scoped_ptr<V4L2H264Accelerator> h264_accelerator_;
   scoped_ptr<V4L2VP8Accelerator> vp8_accelerator_;
 
   // Codec-specific software decoder in use.
   scoped_ptr<AcceleratedVideoDecoder> decoder_;
 
   // Surfaces queued to device to keep references to them while decoded.
   using V4L2DecodeSurfaceByOutputId =
@@ skipping 25 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(V4L2SliceVideoDecodeAccelerator);
 };
 
 class V4L2H264Picture;
 class V4L2VP8Picture;
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_