vda_unittest - Move the fps control from ThrottleVDAClient to RenderingHelper.

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 81 matching lines @@
 const base::FilePath::CharType* g_test_video_data =
     // FILE_PATH_LITERAL("test-25fps.vp8:320:240:250:250:50:175:11");
     FILE_PATH_LITERAL("test-25fps.h264:320:240:250:258:50:175:1");
 
 // The file path of the test output log. This is used to communicate the test
 // results to CrOS autotests. We can enable the log and specify the filename by
 // the "--output_log" switch.
 const base::FilePath::CharType* g_output_log = NULL;
 
 // The value is set by the switch "--rendering_fps".
-double g_rendering_fps = 0;
-
-// Disable rendering, the value is set by the switch "--disable_rendering".
-bool g_disable_rendering = false;
+double g_rendering_fps = 60;
 
 // Magic constants for differentiating the reasons for NotifyResetDone being
 // called.
 enum ResetPoint {
   // Reset() just after calling Decode() with a fragment containing config info.
   RESET_AFTER_FIRST_CONFIG_INFO = -4,
   START_OF_STREAM_RESET = -3,
   MID_STREAM_RESET = -2,
   END_OF_STREAM_RESET = -1
 };
@@ skipping 22 matching lines @@
   int height;
   int num_frames;
   int num_fragments;
   int min_fps_render;
   int min_fps_no_render;
   media::VideoCodecProfile profile;
   int reset_after_frame_num;
   std::string data_str;
 };
 
-// Presumed minimal display size.
-// We subtract one pixel from the width because some ARM chromebooks do not
-// support two fullscreen app running at the same time. See crbug.com/270064.
-const gfx::Size kThumbnailsDisplaySize(1366 - 1, 768);
+const gfx::Size kThumbnailsDisplaySize(1366, 768);
 const gfx::Size kThumbnailsPageSize(1600, 1200);
 const gfx::Size kThumbnailSize(160, 120);
 const int kMD5StringLength = 32;
 
 // Read in golden MD5s for the thumbnailed rendering of this video
 void ReadGoldenThumbnailMD5s(const TestVideoFile* video_file,
                              std::vector<std::string>* md5_strings) {
   base::FilePath filepath(video_file->file_name);
   filepath = filepath.AddExtension(FILE_PATH_LITERAL(".md5"));
   std::string all_md5s;
@@ skipping 27 matching lines @@
   CS_INITIALIZED = 2,
   CS_FLUSHING = 3,
   CS_FLUSHED = 4,
   CS_RESETTING = 5,
   CS_RESET = 6,
   CS_ERROR = 7,
   CS_DESTROYED = 8,
   CS_MAX,  // Must be last entry.
 };
 
-// A wrapper client that throttles the PictureReady callbacks to a given rate.
-// It may drops or queues frame to deliver them on time.
-class ThrottlingVDAClient : public VideoDecodeAccelerator::Client,
-                            public base::SupportsWeakPtr<ThrottlingVDAClient> {
- public:
-  // Callback invoked whan the picture is dropped and should be reused for
-  // the decoder again.
-  typedef base::Callback<void(int32 picture_buffer_id)> ReusePictureCB;
-
-  ThrottlingVDAClient(VideoDecodeAccelerator::Client* client,
-                      double fps,
-                      ReusePictureCB reuse_picture_cb);
-  virtual ~ThrottlingVDAClient();
-
-  // VideoDecodeAccelerator::Client implementation
-  virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
-                                     const gfx::Size& dimensions,
-                                     uint32 texture_target) OVERRIDE;
-  virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
-  virtual void PictureReady(const media::Picture& picture) OVERRIDE;
-  virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
-  virtual void NotifyFlushDone() OVERRIDE;
-  virtual void NotifyResetDone() OVERRIDE;
-  virtual void NotifyError(VideoDecodeAccelerator::Error error) OVERRIDE;
-
-  int num_decoded_frames() { return num_decoded_frames_; }
-
- private:
-
-  void CallClientPictureReady(int version);
-
-  VideoDecodeAccelerator::Client* client_;
-  ReusePictureCB reuse_picture_cb_;
-  base::TimeTicks next_frame_delivered_time_;
-  base::TimeDelta frame_duration_;
-
-  int num_decoded_frames_;
-  int stream_version_;
-  std::deque<media::Picture> pending_pictures_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ThrottlingVDAClient);
-};
-
-ThrottlingVDAClient::ThrottlingVDAClient(VideoDecodeAccelerator::Client* client,
-                                         double fps,
-                                         ReusePictureCB reuse_picture_cb)
-    : client_(client),
-      reuse_picture_cb_(reuse_picture_cb),
-      num_decoded_frames_(0),
-      stream_version_(0) {
-  CHECK(client_);
-  CHECK_GT(fps, 0);
-  frame_duration_ = base::TimeDelta::FromSeconds(1) / fps;
-}
-
-ThrottlingVDAClient::~ThrottlingVDAClient() {}
-
-void ThrottlingVDAClient::ProvidePictureBuffers(uint32 requested_num_of_buffers,
-                                                const gfx::Size& dimensions,
-                                                uint32 texture_target) {
-  client_->ProvidePictureBuffers(
-      requested_num_of_buffers, dimensions, texture_target);
-}
-
-void ThrottlingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
-  client_->DismissPictureBuffer(picture_buffer_id);
-}
-
-void ThrottlingVDAClient::PictureReady(const media::Picture& picture) {
-  ++num_decoded_frames_;
-
-  if (pending_pictures_.empty()) {
-    base::TimeDelta delay =
-        next_frame_delivered_time_.is_null()
-            ? base::TimeDelta()
-            : next_frame_delivered_time_ - base::TimeTicks::Now();
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ThrottlingVDAClient::CallClientPictureReady,
-                   AsWeakPtr(),
-                   stream_version_),
-        delay);
-  }
-  pending_pictures_.push_back(picture);
-}
-
-void ThrottlingVDAClient::CallClientPictureReady(int version) {
-  // Just return if we have reset the decoder
-  if (version != stream_version_)
-    return;
-
-  base::TimeTicks now = base::TimeTicks::Now();
-
-  if (next_frame_delivered_time_.is_null())
-    next_frame_delivered_time_ = now;
-
-  if (next_frame_delivered_time_ + frame_duration_ < now) {
-    // Too late, drop the frame
-    reuse_picture_cb_.Run(pending_pictures_.front().picture_buffer_id());
-  } else {
-    client_->PictureReady(pending_pictures_.front());
-  }
-
-  pending_pictures_.pop_front();
-  next_frame_delivered_time_ += frame_duration_;
-  if (!pending_pictures_.empty()) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ThrottlingVDAClient::CallClientPictureReady,
-                   AsWeakPtr(),
-                   stream_version_),
-        next_frame_delivered_time_ - base::TimeTicks::Now());
-  }
-}
-
-void ThrottlingVDAClient::NotifyEndOfBitstreamBuffer(
-    int32 bitstream_buffer_id) {
-  client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
-}
-
-void ThrottlingVDAClient::NotifyFlushDone() {
-  if (!pending_pictures_.empty()) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ThrottlingVDAClient::NotifyFlushDone,
-                   base::Unretained(this)),
-        next_frame_delivered_time_ - base::TimeTicks::Now());
-    return;
-  }
-  client_->NotifyFlushDone();
-}
-
-void ThrottlingVDAClient::NotifyResetDone() {
-  ++stream_version_;
-  while (!pending_pictures_.empty()) {
-    reuse_picture_cb_.Run(pending_pictures_.front().picture_buffer_id());
-    pending_pictures_.pop_front();
-  }
-  next_frame_delivered_time_ = base::TimeTicks();
-  client_->NotifyResetDone();
-}
-
-void ThrottlingVDAClient::NotifyError(VideoDecodeAccelerator::Error error) {
-  client_->NotifyError(error);
-}
-
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class GLRenderingVDAClient
     : public VideoDecodeAccelerator::Client,
+      public RenderingHelper::Client,
       public base::SupportsWeakPtr<GLRenderingVDAClient> {
  public:
   // Doesn't take ownership of |rendering_helper| or |note|, which must outlive
   // |*this|.
   // |num_play_throughs| indicates how many times to play through the video.
   // |reset_after_frame_num| can be a frame number >=0 indicating a mid-stream
   // Reset() should be done after that frame number is delivered, or
   // END_OF_STREAM_RESET to indicate no mid-stream Reset().
   // |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|).
-  // |rendering_fps| indicates the target rendering fps. 0 means no target fps
-  // and it would render as fast as possible.
-  // |suppress_rendering| indicates GL rendering is suppressed or not.
+  // |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.
   GLRenderingVDAClient(RenderingHelper* rendering_helper,
                        int rendering_window_id,
                        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,
-                       double rendering_fps,
                        bool suppress_rendering,
                        int delay_reuse_after_frame_num,
-                       int decode_calls_per_second);
+                       int decode_calls_per_second,
+                       bool render_as_thumbnails);
   virtual ~GLRenderingVDAClient();
   void CreateAndStartDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
                                      const gfx::Size& dimensions,
                                      uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   // Simple state changes.
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
   virtual void NotifyFlushDone() OVERRIDE;
   virtual void NotifyResetDone() OVERRIDE;
   virtual void NotifyError(VideoDecodeAccelerator::Error error) OVERRIDE;
 
+  // RenderingHelper::Client implementation.
+  virtual void RenderContent(RenderingHelper*) OVERRIDE;
+
   void OutputFrameDeliveryTimes(base::File* output);
 
   void NotifyFrameDropped(int32 picture_buffer_id);
 
   // Simple getters for inspecting the state of the Client.
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_skipped_fragments() { return num_skipped_fragments_; }
   int num_queued_fragments() { return num_queued_fragments_; }
-  int num_decoded_frames();
+  int num_decoded_frames() { return num_decoded_frames_; }
   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<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
   void FinishInitialization();
+  void ReturnPicture(int32 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
   // (based on |start_pos|).
@@ skipping 26 matching lines @@
   int num_queued_fragments_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   media::VideoCodecProfile profile_;
   GLenum texture_target_;
   bool suppress_rendering_;
   std::vector<base::TimeTicks> frame_delivery_times_;
   int delay_reuse_after_frame_num_;
-  scoped_ptr<ThrottlingVDAClient> throttling_client_;
   // 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_;
-  // The id of the picture which is being hold for displayed.
-  int on_hold_picture_buffer_id_;
+  bool render_as_thumbnails_;
+  bool pending_picture_updated_;
+  std::deque<int32> pending_picture_buffer_ids_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(GLRenderingVDAClient);
 };
 
 GLRenderingVDAClient::GLRenderingVDAClient(
     RenderingHelper* rendering_helper,
     int rendering_window_id,
     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,
-    double rendering_fps,
     bool suppress_rendering,
     int delay_reuse_after_frame_num,
-    int decode_calls_per_second)
+    int decode_calls_per_second,
+    bool render_as_thumbnails)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
       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),
       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),
-      on_hold_picture_buffer_id_(-1) {
+      render_as_thumbnails_(render_as_thumbnails),
+      pending_picture_updated_(true) {
   CHECK_GT(num_in_flight_decodes, 0);
   CHECK_GT(num_play_throughs, 0);
-  CHECK_GE(rendering_fps, 0);
   // |num_in_flight_decodes_| is unsupported if |decode_calls_per_second_| > 0.
   if (decode_calls_per_second_ > 0)
     CHECK_EQ(1, num_in_flight_decodes_);
 
   // Default to H264 baseline if no profile provided.
   profile_ = (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN
                   ? profile
                   : media::H264PROFILE_BASELINE);
-
-  if (rendering_fps > 0)
-    throttling_client_.reset(new ThrottlingVDAClient(
-        this,
-        rendering_fps,
-        base::Bind(&GLRenderingVDAClient::NotifyFrameDropped,
-                   base::Unretained(this))));
 }
 
 GLRenderingVDAClient::~GLRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
 }
 
 static bool DoNothingReturnTrue() { return true; }
 
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   CHECK(decoder_deleted());
   CHECK(!decoder_.get());
 
   VideoDecodeAccelerator::Client* client = this;
   base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
-  if (throttling_client_) {
-    client = throttling_client_.get();
-    weak_client = throttling_client_->AsWeakPtr();
-  }
 #if defined(OS_WIN)
   decoder_.reset(
       new DXVAVideoDecodeAccelerator(base::Bind(&DoNothingReturnTrue)));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
 
   scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device.get()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
@@ skipping 50 matching lines @@
 void GLRenderingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
   PictureBufferById::iterator it =
       picture_buffers_by_id_.find(picture_buffer_id);
   CHECK(it != picture_buffers_by_id_.end());
   CHECK_EQ(outstanding_texture_ids_.erase(it->second->texture_id()), 1U);
   rendering_helper_->DeleteTexture(it->second->texture_id());
   delete it->second;
   picture_buffers_by_id_.erase(it);
 }
 
+void GLRenderingVDAClient::RenderContent(RenderingHelper*) {
+  CHECK(!render_as_thumbnails_);
+
+  // No decoded texture for rendering yet, just skip.
+  if (pending_picture_buffer_ids_.size() == 0)
+    return;
+
+  int32 buffer_id = pending_picture_buffer_ids_.front();
+  media::PictureBuffer* picture_buffer = picture_buffers_by_id_[buffer_id];
+
+  CHECK(picture_buffer);
+  if (!pending_picture_updated_) {
+    // Frame dropped, just redraw the last texture.
+    rendering_helper_->RenderTexture(texture_target_,
+                                     picture_buffer->texture_id());
+    return;
+  }
+
+  base::TimeTicks now = base::TimeTicks::Now();
+  frame_delivery_times_.push_back(now);
+
+  rendering_helper_->RenderTexture(texture_target_,
+                                   picture_buffer->texture_id());
+
+  if (pending_picture_buffer_ids_.size() == 1) {
+    pending_picture_updated_ = false;
+  } else {
+    pending_picture_buffer_ids_.pop_front();
+    ReturnPicture(buffer_id);
+  }
+}
+
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   CHECK_LT(state_, CS_RESET);
 
   if (decoder_deleted())
     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);
 
   CHECK_LE(picture.bitstream_buffer_id(), next_bitstream_buffer_id_);
   ++num_decoded_frames_;
 
   // Mid-stream reset applies only to the last play-through per constructor
   // comment.
   if (remaining_play_throughs_ == 1 &&
-      reset_after_frame_num_ == num_decoded_frames()) {
+      reset_after_frame_num_ == num_decoded_frames_) {
     reset_after_frame_num_ = MID_STREAM_RESET;
     decoder_->Reset();
     // Re-start decoding from the beginning of the stream to avoid needing to
     // know how to find I-frames and so on in this test.
     encoded_data_next_pos_to_decode_ = 0;
   }
 
-  media::PictureBuffer* picture_buffer =
-      picture_buffers_by_id_[picture.picture_buffer_id()];
-  CHECK(picture_buffer);
+  if (render_as_thumbnails_) {
+    frame_delivery_times_.push_back(now);
+    media::PictureBuffer* picture_buffer =
+        picture_buffers_by_id_[picture.picture_buffer_id()];
+    CHECK(picture_buffer);
+    rendering_helper_->RenderThumbnail(texture_target_,
+                                       picture_buffer->texture_id());
+    ReturnPicture(picture.picture_buffer_id());
+  } else if (!suppress_rendering_) {
+    // Keep the picture for rendering.
+    pending_picture_buffer_ids_.push_back(picture.picture_buffer_id());
+    if (pending_picture_buffer_ids_.size() > 1 && !pending_picture_updated_) {
+      ReturnPicture(pending_picture_buffer_ids_.front());
+      pending_picture_buffer_ids_.pop_front();
+      pending_picture_updated_ = true;
+    }
+  } else {
+    frame_delivery_times_.push_back(now);
+    ReturnPicture(picture.picture_buffer_id());
+  }
+}
 
-  int released_picture_buffer_id = picture.picture_buffer_id();
-  if (!suppress_rendering_) {
-    // Replace with the last holding picture buffer.
-    std::swap(released_picture_buffer_id, on_hold_picture_buffer_id_);
-    rendering_helper_->RenderTexture(texture_target_,
-                                     picture_buffer->texture_id());
-  }
-
-  if (released_picture_buffer_id < 0)
+void GLRenderingVDAClient::ReturnPicture(int32 picture_buffer_id) {
+  if (decoder_deleted())
     return;
-
-  if ((num_decoded_frames() > delay_reuse_after_frame_num_)) {
+  if (num_decoded_frames_ > delay_reuse_after_frame_num_) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
                    weak_decoder_factory_->GetWeakPtr(),
-                   released_picture_buffer_id),
+                   picture_buffer_id),
         kReuseDelay);
   } else {
-    decoder_->ReusePictureBuffer(released_picture_buffer_id);
+    decoder_->ReusePictureBuffer(picture_buffer_id);
   }
 }
 
 void GLRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 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_;
@@ skipping 11 matching lines @@
   DCHECK_GE(remaining_play_throughs_, 0);
   if (decoder_deleted())
     return;
   decoder_->Reset();
   SetState(CS_RESETTING);
 }
 
 void GLRenderingVDAClient::NotifyResetDone() {
   if (decoder_deleted())
     return;
+
+  // Clear pending_pictures and reuse them.
+  while (!pending_picture_buffer_ids_.empty()) {
+    decoder_->ReusePictureBuffer(pending_picture_buffer_ids_.front());
+    pending_picture_buffer_ids_.pop_front();
+  }
+  pending_picture_updated_ = true;
+
   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;
     for (int i = 0; i < num_in_flight_decodes_; ++i)
       DecodeNextFragment();
     return;
   }
@@ skipping 222 matching lines @@
   }
 
   if (decode_calls_per_second_ > 0) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&GLRenderingVDAClient::DecodeNextFragment, AsWeakPtr()),
         base::TimeDelta::FromSeconds(1) / decode_calls_per_second_);
   }
 }
 
-int GLRenderingVDAClient::num_decoded_frames() {
-  return throttling_client_ ? throttling_client_->num_decoded_frames()
-                            : num_decoded_frames_;
-}
-
 double GLRenderingVDAClient::frames_per_second() {
   base::TimeDelta delta = frame_delivery_times_.back() - initialize_done_ticks_;
-  return num_decoded_frames() / delta.InSecondsF();
+  return num_decoded_frames_ / delta.InSecondsF();
 }
 
 base::TimeDelta GLRenderingVDAClient::decode_time_median() {
   if (decode_time_.size() == 0)
     return base::TimeDelta();
   std::sort(decode_time_.begin(), decode_time_.end());
   int index = decode_time_.size() / 2;
   if (decode_time_.size() % 2 != 0)
     return decode_time_[index];
 
@@ skipping 233 matching lines @@
   const size_t num_in_flight_decodes = GetParam().b;
   const int num_play_throughs = GetParam().c;
   const int reset_point = GetParam().d;
   const int delete_decoder_state = GetParam().e;
   bool test_reuse_delay = GetParam().f;
   const bool render_as_thumbnails = GetParam().g;
 
   UpdateTestVideoFileParams(
       num_concurrent_decoders, reset_point, &test_video_files_);
 
-  // Suppress GL rendering for all tests when the "--disable_rendering" is set.
-  const bool suppress_rendering = g_disable_rendering;
+  // Suppress GL rendering for all tests when the "--rendering_fps" is 0.
+  const bool suppress_rendering = g_rendering_fps == 0;
 
   std::vector<ClientStateNotification<ClientState>*>
       notes(num_concurrent_decoders, NULL);
   std::vector<GLRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   RenderingHelperParams helper_params;
+  helper_params.rendering_fps = g_rendering_fps;
   helper_params.num_windows = num_concurrent_decoders;
   helper_params.render_as_thumbnails = render_as_thumbnails;
   if (render_as_thumbnails) {
     // Only one decoder is supported with thumbnail rendering
     CHECK_EQ(num_concurrent_decoders, 1U);
     gfx::Size frame_size(test_video_files_[0]->width,
                          test_video_files_[0]->height);
     helper_params.frame_dimensions.push_back(frame_size);
     helper_params.window_dimensions.push_back(kThumbnailsDisplaySize);
     helper_params.thumbnails_page_size = kThumbnailsPageSize;
     helper_params.thumbnail_size = kThumbnailSize;
   } else {
     for (size_t index = 0; index < test_video_files_.size(); ++index) {
       gfx::Size frame_size(test_video_files_[index]->width,
                            test_video_files_[index]->height);
       helper_params.frame_dimensions.push_back(frame_size);
       helper_params.window_dimensions.push_back(frame_size);
     }
   }
-  InitializeRenderingHelper(helper_params);
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     TestVideoFile* video_file =
         test_video_files_[index % test_video_files_.size()];
     ClientStateNotification<ClientState>* note =
         new ClientStateNotification<ClientState>();
     notes[index] = note;
 
     int delay_after_frame_num = std::numeric_limits<int>::max();
     if (test_reuse_delay &&
         kMaxFramesToDelayReuse * 2 < video_file->num_frames) {
       delay_after_frame_num = video_file->num_frames - kMaxFramesToDelayReuse;
     }
 
     GLRenderingVDAClient* client =
         new GLRenderingVDAClient(&rendering_helper_,
                                  index,
                                  note,
                                  video_file->data_str,
                                  num_in_flight_decodes,
                                  num_play_throughs,
                                  video_file->reset_after_frame_num,
                                  delete_decoder_state,
                                  video_file->width,
                                  video_file->height,
                                  video_file->profile,
-                                 g_rendering_fps,
                                  suppress_rendering,
                                  delay_after_frame_num,
-                                 0);
+                                 0,
+                                 render_as_thumbnails);
+
     clients[index] = client;
+    helper_params.clients.push_back(client->AsWeakPtr());
+  }
 
-    CreateAndStartDecoder(client, note);
+  InitializeRenderingHelper(helper_params);
+
+  for (size_t index = 0; index < num_concurrent_decoders; ++index) {
+    CreateAndStartDecoder(clients[index], notes[index]);
   }
+
   // Then wait for all the decodes to finish.
   // Only check performance & correctness later if we play through only once.
   bool skip_performance_and_correctness_checks = num_play_throughs > 1;
   for (size_t i = 0; i < num_concurrent_decoders; ++i) {
     ClientStateNotification<ClientState>* note = notes[i];
     ClientState state = note->Wait();
     if (state != CS_INITIALIZED) {
       skip_performance_and_correctness_checks = true;
       // We expect initialization to fail only when more than the supported
       // number of decoders is instantiated.  Assert here that something else
@@ skipping 196 matching lines @@
 // Thumbnailing test
 INSTANTIATE_TEST_CASE_P(
     Thumbnail, VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
 
 // 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.num_windows = 1;
   helper_params.render_as_thumbnails = false;
   gfx::Size frame_size(test_video_files_[0]->width,
                        test_video_files_[0]->height);
   helper_params.frame_dimensions.push_back(frame_size);
   helper_params.window_dimensions.push_back(frame_size);
-  InitializeRenderingHelper(helper_params);
 
   ClientStateNotification<ClientState>* note =
       new ClientStateNotification<ClientState>();
   GLRenderingVDAClient* client =
       new GLRenderingVDAClient(&rendering_helper_,
                                0,
                                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_rendering_fps,
                                true,
                                std::numeric_limits<int>::max(),
-                               kWebRtcDecodeCallsPerSecond);
+                               kWebRtcDecodeCallsPerSecond,
+                               false /* render_as_thumbnail */);
+  helper_params.clients.push_back(client->AsWeakPtr());
+  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());
   LOG(INFO) << output_string;
 
   if (g_output_log != NULL)
@@ skipping 37 matching lines @@
       content::g_output_log = it->second.c_str();
       continue;
     }
     if (it->first == "rendering_fps") {
       // On Windows, CommandLine::StringType is wstring. We need to convert
       // it to std::string first
       std::string input(it->second.begin(), it->second.end());
       CHECK(base::StringToDouble(input, &content::g_rendering_fps));
       continue;
     }
+    // TODO(owenlin): Remove this flag once it is not used in autotest.
     if (it->first == "disable_rendering") {
-      content::g_disable_rendering = true;
+      content::g_rendering_fps = 0;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 
   return RUN_ALL_TESTS();
 }