Refactor GpuVideoDecoder::Factories out of GpuVideoDecoder.

media/filters/gpu_video_decoder.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.
 
 #include "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
 
 // Proxies calls to a VideoDecodeAccelerator::Client from the calling thread to
 // the client's thread.
 //
-// TODO(scherkus): VDAClientProxy should hold onto GpuVideoDecoder::Factories
+// TODO(scherkus): VDAClientProxy should hold onto GpuVideoDecoderFactories
 // and take care of some of the work that GpuVideoDecoder does to minimize
 // thread hopping. See following for discussion:
 //
 // https://codereview.chromium.org/12989009/diff/27035/media/filters/gpu_video_decoder.cc#newcode23
 class VDAClientProxy
     : public base::RefCountedThreadSafe<VDAClientProxy>,
       public VideoDecodeAccelerator::Client {
  public:
   explicit VDAClientProxy(VideoDecodeAccelerator::Client* client);
 
@@ skipping 87 matching lines @@
   client_loop_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Client::NotifyError, weak_client_, error));
 }
 
 
 // Maximum number of concurrent VDA::Decode() operations GVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 enum { kMaxInFlightDecodes = 4 };
 
-GpuVideoDecoder::Factories::~Factories() {}
-
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
 static const size_t kSharedMemorySegmentBytes = 100 << 10;
 
 GpuVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* m, size_t s)
     : shm(m), size(s) {
 }
 
 GpuVideoDecoder::SHMBuffer::~SHMBuffer() {}
 
 GpuVideoDecoder::BufferPair::BufferPair(
     SHMBuffer* s, const scoped_refptr<DecoderBuffer>& b)
     : shm_buffer(s), buffer(b) {
 }
 
 GpuVideoDecoder::BufferPair::~BufferPair() {}
 
 GpuVideoDecoder::BufferData::BufferData(
     int32 bbid, base::TimeDelta ts, const gfx::Rect& vr, const gfx::Size& ns)
     : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
       natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
-    const scoped_refptr<Factories>& factories)
+    const scoped_refptr<GpuVideoDecoderFactories>& factories)
     : needs_bitstream_conversion_(false),
       gvd_loop_proxy_(message_loop),
       weak_factory_(this),
       vda_loop_proxy_(factories->GetMessageLoop()),
       factories_(factories),
       state_(kNormal),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(0) {
@@ skipping 366 matching lines @@
   const PictureBuffer& pb = it->second;
 
   // Update frame's timestamp.
   base::TimeDelta timestamp;
   gfx::Rect visible_rect;
   gfx::Size natural_size;
   GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect,
                 &natural_size);
   DCHECK(decoder_texture_target_);
 
-  scoped_refptr<VideoFrame> frame(
-      VideoFrame::WrapNativeTexture(
-          new VideoFrame::MailboxHolder(
-              pb.texture_mailbox(),
-              0,  // sync_point
-              BindToCurrentLoop(base::Bind(
-                  &GpuVideoDecoder::ReusePictureBuffer, weak_this_,
-                  picture.picture_buffer_id()))),
-          decoder_texture_target_,
-          pb.size(), visible_rect,
-          natural_size, timestamp,
-          base::Bind(&Factories::ReadPixels, factories_, pb.texture_id(),
-                     decoder_texture_target_,
-                     gfx::Size(visible_rect.width(), visible_rect.height())),
-          base::Closure()));
+  scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
+      new VideoFrame::MailboxHolder(
+          pb.texture_mailbox(),
+          0,  // sync_point
+          BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReusePictureBuffer,
+                                       weak_this_,
+                                       picture.picture_buffer_id()))),
+      decoder_texture_target_,
+      pb.size(),
+      visible_rect,
+      natural_size,
+      timestamp,
+      base::Bind(&GpuVideoDecoderFactories::ReadPixels,
+                 factories_,
+                 pb.texture_id(),
+                 decoder_texture_target_,
+                 gfx::Size(visible_rect.width(), visible_rect.height())),
+      base::Closure()));
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(picture.picture_buffer_id()).second;
   DCHECK(inserted);
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
@@ skipping 144 matching lines @@
 
   state_ = kError;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media