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

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 307 matching lines @@
   // |delete_decoder_state| indicates when the underlying decoder should be
   // Destroy()'d and deleted and can take values: N<0: delete after -N Decode()
   // calls have been made, N>=0 means interpret as ClientState.
   // Both |reset_after_frame_num| & |delete_decoder_state| apply only to the
   // last play-through (governed by |num_play_throughs|).
   // |suppress_rendering| indicates GL rendering is supressed or not.
   // After |delay_reuse_after_frame_num| frame has been delivered, the client
   // will start delaying the call to ReusePictureBuffer() for kReuseDelay.
   // |decode_calls_per_second| is the number of VDA::Decode calls per second.
   // If |decode_calls_per_second| > 0, |num_in_flight_decodes| must be 1.
+  // When |test_full_flush| is true, request the VDA to return all buffers it
+  // owns on Flush(), and verify that.
   GLRenderingVDAClient(size_t window_id,
                        RenderingHelper* rendering_helper,
                        ClientStateNotification<ClientState>* note,
                        const std::string& encoded_data,
                        int num_in_flight_decodes,
                        int num_play_throughs,
                        int reset_after_frame_num,
                        int delete_decoder_state,
                        int frame_width,
                        int frame_height,
                        media::VideoCodecProfile profile,
                        int fake_decoder,
                        bool suppress_rendering,
                        int delay_reuse_after_frame_num,
                        int decode_calls_per_second,
-                       bool render_as_thumbnails);
+                       bool render_as_thumbnails,
+                       bool test_full_flush);
   ~GLRenderingVDAClient() override;
   void CreateAndStartDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   void ProvidePictureBuffers(uint32_t requested_num_of_buffers,
                              uint32_t textures_per_buffer,
                              const gfx::Size& dimensions,
                              uint32_t texture_target) override;
   void DismissPictureBuffer(int32_t picture_buffer_id) override;
@@ skipping 14 matching lines @@
   double frames_per_second();
   // Return the median of the decode time of all decoded frames.
   base::TimeDelta decode_time_median();
   bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int32_t, scoped_refptr<TextureRef>> TextureRefMap;
 
   void SetState(ClientState new_state);
   void FinishInitialization();
+  void ReturnTexture(int32_t picture_buffer_id);
   void ReturnPicture(int32_t picture_buffer_id);
+  void CallReusePicture(int32_t picture_buffer_id);
+  void FinishFlush();
 
   // Delete the associated decoder helper.
   void DeleteDecoder();
 
   // Compute & return the first encoded bytes (including a start frame) to send
   // to the decoder, starting at |start_pos| and returning one fragment. Skips
   // to the first decodable position.
   std::string GetBytesForFirstFragment(size_t start_pos, size_t* end_pos);
   // Compute & return the encoded bytes of next fragment to send to the decoder
   // (based on |start_pos|).
@@ skipping 21 matching lines @@
       weak_vda_ptr_factory_;
   std::unique_ptr<GpuVideoDecodeAcceleratorFactoryImpl> vda_factory_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_skipped_fragments_;
   int num_queued_fragments_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
+  int num_pictures_at_decoder_;
   base::TimeTicks initialize_done_ticks_;
   media::VideoCodecProfile profile_;
   int fake_decoder_;
   GLenum texture_target_;
   bool suppress_rendering_;
   std::vector<base::TimeTicks> frame_delivery_times_;
   int delay_reuse_after_frame_num_;
   // A map from bitstream buffer id to the decode start time of the buffer.
   std::map<int, base::TimeTicks> decode_start_time_;
   // The decode time of all decoded frames.
   std::vector<base::TimeDelta> decode_time_;
   // The number of VDA::Decode calls per second. This is to simulate webrtc.
   int decode_calls_per_second_;
   bool render_as_thumbnails_;
+  bool test_full_flush_;
 
   // A map of the textures that are currently active for the decoder, i.e.,
   // have been created via AssignPictureBuffers() and not dismissed via
   // DismissPictureBuffer(). The keys in the map are the IDs of the
   // corresponding picture buffers, and the values are TextureRefs to the
   // textures.
   TextureRefMap active_textures_;
 
   // A map of the textures that are still pending in the renderer.
   // We check this to ensure all frames are rendered before entering the
@@ skipping 28 matching lines @@
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
     int frame_width,
     int frame_height,
     media::VideoCodecProfile profile,
     int fake_decoder,
     bool suppress_rendering,
     int delay_reuse_after_frame_num,
     int decode_calls_per_second,
-    bool render_as_thumbnails)
+    bool render_as_thumbnails,
+    bool test_full_flush)
     : window_id_(window_id),
       rendering_helper_(rendering_helper),
       frame_size_(frame_width, frame_height),
       encoded_data_(encoded_data),
       num_in_flight_decodes_(num_in_flight_decodes),
       outstanding_decodes_(0),
       encoded_data_next_pos_to_decode_(0),
       next_bitstream_buffer_id_(0),
       note_(note),
       remaining_play_throughs_(num_play_throughs),
       reset_after_frame_num_(reset_after_frame_num),
       delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_skipped_fragments_(0),
       num_queued_fragments_(0),
       num_decoded_frames_(0),
       num_done_bitstream_buffers_(0),
+      num_pictures_at_decoder_(0),
       fake_decoder_(fake_decoder),
       texture_target_(0),
       suppress_rendering_(suppress_rendering),
       delay_reuse_after_frame_num_(delay_reuse_after_frame_num),
       decode_calls_per_second_(decode_calls_per_second),
       render_as_thumbnails_(render_as_thumbnails),
+      test_full_flush_(test_full_flush),
       next_picture_buffer_id_(1),
       weak_this_factory_(this) {
   LOG_ASSERT(num_in_flight_decodes > 0);
   LOG_ASSERT(num_play_throughs > 0);
   // |num_in_flight_decodes_| is unsupported if |decode_calls_per_second_| > 0.
   if (decode_calls_per_second_ > 0)
     LOG_ASSERT(1 == num_in_flight_decodes_);
 
   // Default to H264 baseline if no profile provided.
   profile_ = (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN
                   ? profile
                   : media::H264PROFILE_BASELINE);
 
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 GLRenderingVDAClient::~GLRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   LOG_ASSERT(decoder_deleted());
   SetState(CS_DESTROYED);
 }
 
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   LOG_ASSERT(decoder_deleted());
   LOG_ASSERT(!decoder_.get());
 
+  VideoDecodeAccelerator::Config config(profile_);
+  config.output_mode =
+      (g_test_import
+           ? media::VideoDecodeAccelerator::Config::OutputMode::IMPORT
+           : media::VideoDecodeAccelerator::Config::OutputMode::ALLOCATE);
+  config.flush_mode =
+      (test_full_flush_ ? media::VideoDecodeAccelerator::Config::FlushMode::
+                              RETURN_OUTPUT_BUFFERS
+                        : media::VideoDecodeAccelerator::Config::FlushMode::
+                              KEEP_OUTPUT_BUFFERS);
   if (fake_decoder_) {
     decoder_.reset(new FakeVideoDecodeAccelerator(
         frame_size_, base::Bind(&DoNothingReturnTrue)));
-    LOG_ASSERT(decoder_->Initialize(profile_, this));
+    LOG_ASSERT(decoder_->Initialize(config, this));
   } else {
     if (!vda_factory_) {
       vda_factory_ = GpuVideoDecodeAcceleratorFactoryImpl::Create(
           base::Bind(&RenderingHelper::GetGLContext,
                      base::Unretained(rendering_helper_)),
           base::Bind(&DoNothingReturnTrue), base::Bind(&DummyBindImage));
       LOG_ASSERT(vda_factory_);
     }
 
-    VideoDecodeAccelerator::Config config(profile_);
-    if (g_test_import) {
-      config.output_mode =
-          media::VideoDecodeAccelerator::Config::OutputMode::IMPORT;
-    }
     gpu::GpuPreferences gpu_preferences;
     decoder_ = vda_factory_->CreateVDA(this, config, gpu_preferences);
   }
 
   LOG_ASSERT(decoder_) << "Failed creating a VDA";
+  weak_vda_ptr_factory_.reset(
+      new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
+  weak_vda_ = weak_vda_ptr_factory_->GetWeakPtr();
 
   decoder_->TryToSetupDecodeOnSeparateThread(
       weak_this_, base::ThreadTaskRunnerHandle::Get());
 
   SetState(CS_DECODER_SET);
   FinishInitialization();
 }
 
 namespace {
 gfx::BufferFormat VideoPixelFormatToGfxBufferFormat(
@@ skipping 73 matching lines @@
       int duped_fd = HANDLE_EINTR(dup(pixmap->GetDmaBufFd()));
       ASSERT_NE(duped_fd, -1);
       gfx::GpuMemoryBufferHandle handle;
       handle.type = gfx::OZONE_NATIVE_PIXMAP;
       handle.native_pixmap_handle.fd = base::FileDescriptor(duped_fd, true);
       std::vector<gfx::GpuMemoryBufferHandle> handles;
       handles.push_back(handle);
       decoder_->ImportBufferForPicture(buffer.id(), handles);
     }
   }
+
+  num_pictures_at_decoder_ = buffers.size();
 }
 
 void GLRenderingVDAClient::DismissPictureBuffer(int32_t picture_buffer_id) {
   LOG_ASSERT(1U == active_textures_.erase(picture_buffer_id));
+  EXPECT_GT(num_pictures_at_decoder_, 0);
+  --num_pictures_at_decoder_;
 }
 
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   LOG_ASSERT(state_ < CS_RESET);
 
   if (decoder_deleted())
     return;
 
+  EXPECT_GT(num_pictures_at_decoder_, 0);
+  --num_pictures_at_decoder_;
+
+  if (picture.bitstream_buffer_id() == -1) {
+    // The picture does not contain any decoded data, reuse it immediately.
+    ReturnPicture(picture.picture_buffer_id());
+    return;
+  }
+
   base::TimeTicks now = base::TimeTicks::Now();
 
   frame_delivery_times_.push_back(now);
 
   // Save the decode time of this picture.
   std::map<int, base::TimeTicks>::iterator it =
       decode_start_time_.find(picture.bitstream_buffer_id());
   ASSERT_NE(decode_start_time_.end(), it);
   decode_time_.push_back(now - it->second);
   decode_start_time_.erase(it);
@@ skipping 11 matching lines @@
     // know how to find I-frames and so on in this test.
     encoded_data_next_pos_to_decode_ = 0;
   }
 
   TextureRefMap::iterator texture_it =
       active_textures_.find(picture.picture_buffer_id());
   ASSERT_NE(active_textures_.end(), texture_it);
 
   scoped_refptr<VideoFrameTexture> video_frame = new VideoFrameTexture(
       texture_target_, texture_it->second->texture_id(),
-      base::Bind(&GLRenderingVDAClient::ReturnPicture, AsWeakPtr(),
+      base::Bind(&GLRenderingVDAClient::ReturnTexture, AsWeakPtr(),
                  picture.picture_buffer_id()));
   ASSERT_TRUE(pending_textures_.insert(*texture_it).second);
 
   if (render_as_thumbnails_) {
     rendering_helper_->RenderThumbnail(video_frame->texture_target(),
                                        video_frame->texture_id());
   } else if (!suppress_rendering_) {
     rendering_helper_->QueueVideoFrame(window_id_, video_frame);
   }
 }
 
-void GLRenderingVDAClient::ReturnPicture(int32_t picture_buffer_id) {
+void GLRenderingVDAClient::ReturnTexture(int32_t picture_buffer_id) {
   if (decoder_deleted())
     return;
+
   LOG_ASSERT(1U == pending_textures_.erase(picture_buffer_id));
 
   if (pending_textures_.empty() && state_ == CS_RESETTING) {
     SetState(CS_RESET);
     DeleteDecoder();
     return;
   }
 
+  ReturnPicture(picture_buffer_id);
+}
+
+void GLRenderingVDAClient::CallReusePicture(int32_t picture_buffer_id) {
+  if (state_ == CS_FLUSHED && test_full_flush_) {
+    // If we just got a notification from the VDA that it's flushed and are
+    // testing full flush, we want to have a chance to test that VDA really
+    // returned all buffers before NotifyFlushDone(). Delay returning the buffer
+    // so that we have a chance in FinishFlush() to test we got all the buffers.
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&GLRenderingVDAClient::CallReusePicture,
+                              weak_this_, picture_buffer_id));
+    return;
+  }
+
+  if (weak_vda_)
+    weak_vda_->ReusePictureBuffer(picture_buffer_id);
+  ++num_pictures_at_decoder_;
+}
+
+void GLRenderingVDAClient::ReturnPicture(int32_t picture_buffer_id) {
   if (num_decoded_frames_ > delay_reuse_after_frame_num_) {
     base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
-                              weak_vda_, picture_buffer_id),
+        FROM_HERE, base::Bind(&GLRenderingVDAClient::CallReusePicture,
+                              weak_this_, picture_buffer_id),
         kReuseDelay);
   } else {
-    decoder_->ReusePictureBuffer(picture_buffer_id);
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&GLRenderingVDAClient::CallReusePicture,
+                              weak_this_, picture_buffer_id));
   }
 }
 
 void GLRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32_t bitstream_buffer_id) {
   // TODO(fischman): this test currently relies on this notification to make
   // forward progress during a Reset().  But the VDA::Reset() API doesn't
   // guarantee this, so stop relying on it (and remove the notifications from
   // VaapiVideoDecodeAccelerator::FinishReset()).
   ++num_done_bitstream_buffers_;
   --outstanding_decodes_;
 
   // Flush decoder after all BitstreamBuffers are processed.
   if (encoded_data_next_pos_to_decode_ == encoded_data_.size()) {
     // TODO(owenlin): We should not have to check the number of
     // |outstanding_decodes_|. |decoder_| should be able to accept Flush()
     // before it's done with outstanding decodes. (crbug.com/528183)
     if (outstanding_decodes_ == 0) {
       decoder_->Flush();
       SetState(CS_FLUSHING);
     }
   } else if (decode_calls_per_second_ == 0) {
     DecodeNextFragment();
   }
 }
 
-void GLRenderingVDAClient::NotifyFlushDone() {
-  if (decoder_deleted())
-    return;
+void GLRenderingVDAClient::FinishFlush() {
+  ASSERT_EQ(CS_FLUSHED, state_);
+  if (test_full_flush_)
+    EXPECT_EQ(0, num_pictures_at_decoder_);
 
-  SetState(CS_FLUSHED);
   --remaining_play_throughs_;
   DCHECK_GE(remaining_play_throughs_, 0);
   if (decoder_deleted())
     return;
   decoder_->Reset();
   SetState(CS_RESETTING);
 }
 
+void GLRenderingVDAClient::NotifyFlushDone() {
+  if (decoder_deleted())
+    return;
+
+  ASSERT_EQ(CS_FLUSHING, state_);
+  SetState(CS_FLUSHED);
+
+  // We may have already posted some ReusePictureBuffer() calls before we got
+  // here. If we are testing RETURN_OUTPUT_BUFFERS flush mode, make sure we
+  // don't execute them returning the buffers to VDA until we have a chance
+  // to verify the VDA really returned all the buffers before finishing flush.
+  // Otherwise, we don't care and can continue without holding off any pending
+  // ReusePictureBuffer() calls
+  if (test_full_flush_) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&GLRenderingVDAClient::FinishFlush, weak_this_));
+  } else {
+    FinishFlush();
+  }
+}
+
 void GLRenderingVDAClient::NotifyResetDone() {
   if (decoder_deleted())
     return;
 
   if (reset_after_frame_num_ == MID_STREAM_RESET) {
     reset_after_frame_num_ = END_OF_STREAM_RESET;
     DecodeNextFragment();
     return;
   } else if (reset_after_frame_num_ == START_OF_STREAM_RESET) {
     reset_after_frame_num_ = END_OF_STREAM_RESET;
@@ skipping 414 matching lines @@
 // Test parameters:
 // - Number of concurrent decoders. The value takes effect when there is only
 //   one input stream; otherwise, one decoder per input stream will be
 //   instantiated.
 // - Number of concurrent in-flight Decode() calls per decoder.
 // - Number of play-throughs.
 // - reset_after_frame_num: see GLRenderingVDAClient ctor.
 // - delete_decoder_phase: see GLRenderingVDAClient ctor.
 // - whether to test slow rendering by delaying ReusePictureBuffer().
 // - whether the video frames are rendered as thumbnails.
+// - whether to test VDA::Flush(true)
 class VideoDecodeAcceleratorParamTest
     : public VideoDecodeAcceleratorTest,
       public ::testing::WithParamInterface<
-        base::Tuple<int, int, int, ResetPoint, ClientState, bool, bool> > {
+          base::
+              Tuple<int, int, int, ResetPoint, ClientState, bool, bool, bool>> {
 };
 
 // Wait for |note| to report a state and if it's not |expected_state| then
 // assert |client| has deleted its decoder.
 static void AssertWaitForStateOrDeleted(
     ClientStateNotification<ClientState>* note,
     GLRenderingVDAClient* client,
     ClientState expected_state) {
   ClientState state = note->Wait();
   if (state == expected_state) return;
@@ skipping 10 matching lines @@
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(VideoDecodeAcceleratorParamTest, TestSimpleDecode) {
   size_t num_concurrent_decoders = base::get<0>(GetParam());
   const size_t num_in_flight_decodes = base::get<1>(GetParam());
   int num_play_throughs = base::get<2>(GetParam());
   const int reset_point = base::get<3>(GetParam());
   const int delete_decoder_state = base::get<4>(GetParam());
   bool test_reuse_delay = base::get<5>(GetParam());
   const bool render_as_thumbnails = base::get<6>(GetParam());
+  const bool test_full_flush = base::get<7>(GetParam());
 
   if (test_video_files_.size() > 1)
     num_concurrent_decoders = test_video_files_.size();
 
   if (g_num_play_throughs > 0)
     num_play_throughs = g_num_play_throughs;
 
   UpdateTestVideoFileParams(
       num_concurrent_decoders, reset_point, &test_video_files_);
 
@@ skipping 38 matching lines @@
                                  num_play_throughs,
                                  video_file->reset_after_frame_num,
                                  delete_decoder_state,
                                  video_file->width,
                                  video_file->height,
                                  video_file->profile,
                                  g_fake_decoder,
                                  suppress_rendering,
                                  delay_after_frame_num,
                                  0,
-                                 render_as_thumbnails);
+                                 render_as_thumbnails,
+                                 test_full_flush);
 
     clients[index] = client;
     helper_params.window_sizes.push_back(
         render_as_thumbnails
             ? kThumbnailsPageSize
             : gfx::Size(video_file->width, video_file->height));
   }
 
   InitializeRenderingHelper(helper_params);
 
@@ skipping 134 matching lines @@
       base::Bind(&STLDeleteElements<
                      std::vector<ClientStateNotification<ClientState>*>>,
                  &notes));
   WaitUntilIdle();
 };
 
 // Test that replay after EOS works fine.
 INSTANTIATE_TEST_CASE_P(
     ReplayAfterEOS, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 4, END_OF_STREAM_RESET, CS_RESET, false, false)));
+        MakeTuple(1, 1, 4, END_OF_STREAM_RESET, CS_RESET, false, false,
+                  false)));
 
 // Test that Reset() before the first Decode() works fine.
 INSTANTIATE_TEST_CASE_P(
     ResetBeforeDecode, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, START_OF_STREAM_RESET, CS_RESET, false, false)));
+        MakeTuple(1, 1, 1, START_OF_STREAM_RESET, CS_RESET, false, false,
+                  false)));
 
 // Test Reset() immediately after Decode() containing config info.
 INSTANTIATE_TEST_CASE_P(
     ResetAfterFirstConfigInfo, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(
-            1, 1, 1, RESET_AFTER_FIRST_CONFIG_INFO, CS_RESET, false, false)));
+        MakeTuple(1, 1, 1, RESET_AFTER_FIRST_CONFIG_INFO, CS_RESET, false,
+                  false, false)));
 
 // Test that Reset() mid-stream works fine and doesn't affect decoding even when
 // Decode() calls are made during the reset.
 INSTANTIATE_TEST_CASE_P(
     MidStreamReset, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false)));
+        MakeTuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false, false)));
+
+// Test that the VDA returns all buffers to us on Flush(true).
+INSTANTIATE_TEST_CASE_P(
+    FullFlush, VideoDecodeAcceleratorParamTest,
+    ::testing::Values(
+        MakeTuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false, true)));
+
 
 INSTANTIATE_TEST_CASE_P(
     SlowRendering, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, true, false)));
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, true, false, false)));
 
 // Test that Destroy() mid-stream works fine (primarily this is testing that no
 // crashes occur).
 INSTANTIATE_TEST_CASE_P(
     TearDownTiming, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_DECODER_SET, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_INITIALIZED, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHING, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_DECODER_SET, false, false,
+                  false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_INITIALIZED, false, false,
+                  false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHING, false, false,
+                  false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED, false, false,
+                  false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING, false, false,
+                  false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false, false),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-1), false, false),
+                  static_cast<ClientState>(-1), false, false, false),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-10), false, false),
+                  static_cast<ClientState>(-10), false, false, false),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-100), false, false)));
+                  static_cast<ClientState>(-100), false, false, false)));
 
 // Test that decoding various variation works with multiple in-flight decodes.
 INSTANTIATE_TEST_CASE_P(
     DecodeVariations, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
-        MakeTuple(1, 10, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false, false),
+        MakeTuple(1, 10, 1, END_OF_STREAM_RESET, CS_RESET, false, false, false),
         // Tests queuing.
-        MakeTuple(1, 15, 1, END_OF_STREAM_RESET, CS_RESET, false, false)));
+        MakeTuple(1, 15, 1, END_OF_STREAM_RESET, CS_RESET, false, false,
+                  false)));
 
 // Find out how many concurrent decoders can go before we exhaust system
 // resources.
 INSTANTIATE_TEST_CASE_P(
     ResourceExhaustion, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         // +0 hack below to promote enum to int.
         MakeTuple(kMinSupportedNumConcurrentDecoders + 0, 1, 1,
-                  END_OF_STREAM_RESET, CS_RESET, false, false),
+                  END_OF_STREAM_RESET, CS_RESET, false, false, false),
         MakeTuple(kMinSupportedNumConcurrentDecoders + 1, 1, 1,
-                  END_OF_STREAM_RESET, CS_RESET, false, false)));
+                  END_OF_STREAM_RESET, CS_RESET, false, false, false)));
 
 // Thumbnailing test
 INSTANTIATE_TEST_CASE_P(
     Thumbnail, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true, false)));
 
 // Measure the median of the decode time when VDA::Decode is called 30 times per
 // second.
 TEST_F(VideoDecodeAcceleratorTest, TestDecodeTimeMedian) {
   RenderingHelperParams helper_params;
 
   // Disable rendering by setting the rendering_fps = 0.
   helper_params.rendering_fps = 0;
   helper_params.warm_up_iterations = 0;
   helper_params.render_as_thumbnails = false;
 
   ClientStateNotification<ClientState>* note =
       new ClientStateNotification<ClientState>();
   GLRenderingVDAClient* client =
       new GLRenderingVDAClient(0,
                                &rendering_helper_,
                                note,
                                test_video_files_[0]->data_str,
                                1,
                                1,
                                test_video_files_[0]->reset_after_frame_num,
                                CS_RESET,
                                test_video_files_[0]->width,
                                test_video_files_[0]->height,
                                test_video_files_[0]->profile,
                                g_fake_decoder,
                                true,
                                std::numeric_limits<int>::max(),
                                kWebRtcDecodeCallsPerSecond,
-                               false /* render_as_thumbnail */);
+                               false /* render_as_thumbnail */,
+                               false /* test_full_flush */);
   helper_params.window_sizes.push_back(
       gfx::Size(test_video_files_[0]->width, test_video_files_[0]->height));
   InitializeRenderingHelper(helper_params);
   CreateAndStartDecoder(client, note);
   WaitUntilDecodeFinish(note);
 
   base::TimeDelta decode_time_median = client->decode_time_median();
   std::string output_string =
       base::StringPrintf("Decode time median: %" PRId64 " us",
                          decode_time_median.InMicroseconds());
@@ skipping 97 matching lines @@
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }