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 294 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,
                              const gfx::Size& dimensions,
                              uint32_t texture_target) override;
   void DismissPictureBuffer(int32_t picture_buffer_id) override;
   void PictureReady(const media::Picture& picture) override;
@@ skipping 23 matching lines @@
   scoped_ptr<media::VideoDecodeAccelerator> CreateV4L2VDA();
   scoped_ptr<media::VideoDecodeAccelerator> CreateV4L2SliceVDA();
   scoped_ptr<media::VideoDecodeAccelerator> CreateVaapiVDA();
 
   void BindImage(uint32_t client_texture_id,
                  uint32_t texture_target,
                  scoped_refptr<gl::GLImage> image);
 
   void SetState(ClientState new_state);
   void FinishInitialization();
+  void ReturnTexture(int32_t picture_buffer_id);
   void ReturnPicture(int32_t picture_buffer_id);
 
   // 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
@@ skipping 20 matching lines @@
   scoped_ptr<base::WeakPtrFactory<VideoDecodeAccelerator> >
       weak_decoder_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_client_;
   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_;
+  std::list<int> delayed_picture_buffer_ids_to_return_;
 
   // 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 14 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_client_(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) {
   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
@@ skipping 146 matching lines @@
               .second);
 
     buffers.push_back(
         media::PictureBuffer(picture_buffer_id, dimensions, texture_id));
   }
   decoder_->AssignPictureBuffers(buffers);
 }
 
 void GLRenderingVDAClient::DismissPictureBuffer(int32_t picture_buffer_id) {
   LOG_ASSERT(1U == active_textures_.erase(picture_buffer_id));
+  EXPECT_GT(num_pictures_at_client_, 0);
+  --num_pictures_at_client_;
 }
 
 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_client_, 0);
+  --num_pictures_at_client_;
+
+  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::ReturnPicture(int32_t picture_buffer_id) {
+  if (test_full_flush_ && state_ == CS_FLUSHING) {
+    delayed_picture_buffer_ids_to_return_.push_back(picture_buffer_id);
+    return;
+  }
+
   if (num_decoded_frames_ > delay_reuse_after_frame_num_) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
                    weak_decoder_factory_->GetWeakPtr(),
                    picture_buffer_id),
         kReuseDelay);
   } else {
     decoder_->ReusePictureBuffer(picture_buffer_id);
   }
+
+  ++num_pictures_at_client_;
 }
 
 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();
+      decoder_->Flush(test_full_flush_);
       SetState(CS_FLUSHING);
     }
   } else if (decode_calls_per_second_ == 0) {
     DecodeNextFragment();
   }
 }
 
 void GLRenderingVDAClient::NotifyFlushDone() {
   if (decoder_deleted())
     return;
 
   SetState(CS_FLUSHED);
+
+  if (test_full_flush_) {
+    EXPECT_EQ(num_pictures_at_client_, 0);

[kcwu, 2016/03/22 09:47:42]

EXPECT_EQ(0, num_pictures_at_client_);
expected first.

+    for (auto& picture_buffer_id : delayed_picture_buffer_ids_to_return_)
+      ReturnPicture(picture_buffer_id);
+    delayed_picture_buffer_ids_to_return_.clear();
+  }
+
   --remaining_play_throughs_;
   DCHECK_GE(remaining_play_throughs_, 0);
   if (decoder_deleted())
     return;
   decoder_->Reset();
   SetState(CS_RESETTING);
 }
 
 void GLRenderingVDAClient::NotifyResetDone() {
   if (decoder_deleted())
@@ skipping 422 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 131 matching lines @@
                  &clients));
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE,
       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)));
+INSTANTIATE_TEST_CASE_P(ReplayAfterEOS,
+                        VideoDecodeAcceleratorParamTest,
+                        ::testing::Values(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)));
+INSTANTIATE_TEST_CASE_P(ResetBeforeDecode,
+                        VideoDecodeAcceleratorParamTest,
+                        ::testing::Values(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)));
+    ResetAfterFirstConfigInfo,
+    VideoDecodeAcceleratorParamTest,
+    ::testing::Values(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,
+    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,
+    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,
+    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,
-                  static_cast<ClientState>(-1), false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-10), false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-100), 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,
+                  false),
+        MakeTuple(1,
+                  1,
+                  1,
+                  END_OF_STREAM_RESET,
+                  static_cast<ClientState>(-10),
+                  false,
+                  false,
+                  false),
+        MakeTuple(1,
+                  1,
+                  1,
+                  END_OF_STREAM_RESET,
+                  static_cast<ClientState>(-100),
+                  false,
+                  false,
+                  false)));
 
 // Test that decoding various variation works with multiple in-flight decodes.
 INSTANTIATE_TEST_CASE_P(
-    DecodeVariations, VideoDecodeAcceleratorParamTest,
+    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),
-        MakeTuple(kMinSupportedNumConcurrentDecoders + 1, 1, 1,
-                  END_OF_STREAM_RESET, CS_RESET, false, false)));
+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,
+                                      false),
+                            MakeTuple(kMinSupportedNumConcurrentDecoders + 1,
+                                      1,
+                                      1,
+                                      END_OF_STREAM_RESET,
+                                      CS_RESET,
+                                      false,
+                                      false,
+                                      false)));
 
 // Thumbnailing test
 INSTANTIATE_TEST_CASE_P(
-    Thumbnail, VideoDecodeAcceleratorParamTest,
+    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 93 matching lines @@
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }