media: split GpuMemoryBufferVideoFramePool into GpuMemoryBufferVideoFrameCopier/Pool

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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.
 
 #include "media/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
-#include "media/video/gpu_memory_buffer_video_frame_pool.h"
+#include "media/video/gpu_memory_buffer_video_frame_copier.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
     GpuVideoAcceleratorFactories* gpu_factories,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(media_task_runner),
       sink_(sink),
       sink_started_(false),
       video_frame_stream_(new VideoFrameStream(media_task_runner,
                                                std::move(decoders),
                                                media_log)),
-      gpu_memory_buffer_pool_(nullptr),
+      gpu_memory_buffer_copier_(nullptr),
       media_log_(media_log),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       state_(kUninitialized),
       sequence_token_(0),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       frames_decoded_(0),
       frames_dropped_(0),
       tick_clock_(new base::DefaultTickClock()),
       was_background_rendering_(false),
       time_progressing_(false),
       render_first_frame_and_stop_(false),
       posted_maybe_stop_after_first_paint_(false),
       last_video_memory_usage_(0),
       weak_factory_(this) {
   if (gpu_factories &&
       gpu_factories->ShouldUseGpuMemoryBuffersForVideoFrames()) {
-    gpu_memory_buffer_pool_.reset(new GpuMemoryBufferVideoFramePool(
+    gpu_memory_buffer_copier_.reset(new GpuMemoryBufferVideoFrameCopier(
         media_task_runner, worker_task_runner, gpu_factories));
   }
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 
@@ skipping 200 matching lines @@
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void VideoRendererImpl::SetTickClockForTesting(
     scoped_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
 }
 
 void VideoRendererImpl::SetGpuMemoryBufferVideoForTesting(
-    scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool) {
-  gpu_memory_buffer_pool_.swap(gpu_memory_buffer_pool);
+    scoped_ptr<GpuMemoryBufferVideoFrameCopier> gpu_memory_buffer_copier) {
+  gpu_memory_buffer_copier_.swap(gpu_memory_buffer_copier);
 }
 
 void VideoRendererImpl::OnTimeStateChanged(bool time_progressing) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   time_progressing_ = time_progressing;
 
   // WARNING: Do not attempt to use |lock_| here as this may be a reentrant call
   // in response to callbacks firing above.
 
   if (sink_started_ == time_progressing_)
@@ skipping 11 matching lines @@
 
 void VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers(
     VideoFrameStream::Status status,
     const scoped_refptr<VideoFrame>& frame) {
   if (status != VideoFrameStream::OK || IsBeforeStartTime(frame->timestamp())) {
     VideoRendererImpl::FrameReady(sequence_token_, status, frame);
     return;
   }
 
   DCHECK(frame);
-  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+  gpu_memory_buffer_copier_->MaybeCreateHardwareFrame(
       frame, base::Bind(&VideoRendererImpl::FrameReady,
                         weak_factory_.GetWeakPtr(), sequence_token_, status));
 }
 
 void VideoRendererImpl::FrameReady(uint32_t sequence_token,
                                    VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   bool start_sink = false;
   {
@@ skipping 170 matching lines @@
 
   if (pending_read_ || received_end_of_stream_)
     return;
 
   if (HaveReachedBufferingCap())
     return;
 
   switch (state_) {
     case kPlaying:
       pending_read_ = true;
-      if (gpu_memory_buffer_pool_) {
+      if (gpu_memory_buffer_copier_) {
         video_frame_stream_->Read(base::Bind(
             &VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers,
             weak_factory_.GetWeakPtr()));
       } else {
         video_frame_stream_->Read(base::Bind(&VideoRendererImpl::FrameReady,
                                              weak_factory_.GetWeakPtr(),
                                              sequence_token_));
       }
       return;
     case kUninitialized:
@@ skipping 116 matching lines @@
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
 }  // namespace media