Revert of MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/pepper/pepper_media_stream_video_track_host.cc

 // Copyright 2014 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 "content/renderer/pepper/pepper_media_stream_video_track_host.h"
 
 #include <stddef.h>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_media_stream_video_track.h"
 #include "ppapi/c/ppb_video_frame.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 203 matching lines @@
     PP_Instance instance,
     PP_Resource resource,
     const blink::WebMediaStreamTrack& track)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       track_(track),
       number_of_buffers_(kDefaultNumberOfBuffers),
       source_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       plugin_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       frame_data_size_(0),
       type_(kRead),
+      output_started_(false),
       weak_factory_(this) {
   DCHECK(!track_.isNull());
 }
 
 PepperMediaStreamVideoTrackHost::PepperMediaStreamVideoTrackHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       number_of_buffers_(kDefaultNumberOfBuffers),
       source_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       plugin_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       frame_data_size_(0),
       type_(kWrite),
+      output_started_(false),
       weak_factory_(this) {
   InitBlinkTrack();
   DCHECK(!track_.isNull());
 }
 
 PepperMediaStreamVideoTrackHost::~PepperMediaStreamVideoTrackHost() {
   OnClose();
 }
 
 bool PepperMediaStreamVideoTrackHost::IsMediaStreamVideoTrackHost() {
@@ skipping 52 matching lines @@
     return PepperMediaStreamTrackHostBase::OnHostMsgEnqueueBuffer(context,
                                                                   index);
   } else {
     return SendFrameToTrack(index);
   }
 }
 
 int32_t PepperMediaStreamVideoTrackHost::SendFrameToTrack(int32_t index) {
   DCHECK_EQ(type_, kWrite);
 
-  if (frame_deliverer_) {
+  if (output_started_) {
     // Sends the frame to blink video track.
     ppapi::MediaStreamBuffer::Video* pp_frame =
         &(buffer_manager()->GetBufferPointer(index)->video);
 
     int32_t y_stride = plugin_frame_size_.width();
     int32_t uv_stride = (plugin_frame_size_.width() + 1) / 2;
     uint8_t* y_data = static_cast<uint8_t*>(pp_frame->data);
     // Default to I420
     uint8_t* u_data = y_data + plugin_frame_size_.GetArea();
     uint8_t* v_data = y_data + (plugin_frame_size_.GetArea() * 5 / 4);
@@ skipping 67 matching lines @@
   buffer->timestamp = frame->timestamp().InSecondsF();
   buffer->format = ppformat;
   buffer->size.width = size.width();
   buffer->size.height = size.height();
   buffer->data_size = frame_data_size_;
   ConvertFromMediaVideoFrame(frame, ppformat, size, buffer->data);
 
   SendEnqueueBufferMessageToPlugin(index);
 }
 
-class PepperMediaStreamVideoTrackHost::VideoSource final
-    : public MediaStreamVideoSource {
- public:
-  explicit VideoSource(base::WeakPtr<PepperMediaStreamVideoTrackHost> host)
-      : host_(std::move(host)) {}
-
-  ~VideoSource() final { StopSourceImpl(); }
-
-  void GetCurrentSupportedFormats(
-      int max_requested_width, int max_requested_height,
-      double max_requested_frame_rate,
-      const VideoCaptureDeviceFormatsCB& callback) final {
-    media::VideoCaptureFormats formats;
-    if (host_) {
-      formats.push_back(media::VideoCaptureFormat(
-          host_->plugin_frame_size_,
-          kDefaultOutputFrameRate,
-          ToPixelFormat(host_->plugin_frame_format_)));
-    }
-    callback.Run(formats);
+void PepperMediaStreamVideoTrackHost::GetCurrentSupportedFormats(
+    int max_requested_width, int max_requested_height,
+    double max_requested_frame_rate,
+    const VideoCaptureDeviceFormatsCB& callback) {
+  if (type_ != kWrite) {
+    DVLOG(1) << "GetCurrentSupportedFormats is only supported in output mode.";
+    callback.Run(media::VideoCaptureFormats());
+    return;
   }
 
-  void StartSourceImpl(
-      const media::VideoCaptureFormat& format,
-      const blink::WebMediaConstraints& constraints,
-      const VideoCaptureDeliverFrameCB& frame_callback) final {
-    if (host_) {
-      host_->frame_deliverer_ =
-          new FrameDeliverer(io_task_runner(), frame_callback);
-    }
-  }
+  media::VideoCaptureFormats formats;
+  formats.push_back(
+      media::VideoCaptureFormat(plugin_frame_size_,
+                                kDefaultOutputFrameRate,
+                                ToPixelFormat(plugin_frame_format_)));
+  callback.Run(formats);
+}
 
-  void StopSourceImpl() final {
-    if (host_)
-      host_->frame_deliverer_ = nullptr;
-  }
+void PepperMediaStreamVideoTrackHost::StartSourceImpl(
+    const media::VideoCaptureFormat& format,
+    const blink::WebMediaConstraints& constraints,
+    const VideoCaptureDeliverFrameCB& frame_callback) {
+  output_started_ = true;
+  frame_deliverer_ = new FrameDeliverer(io_task_runner(), frame_callback);
+}
 
- private:
-  const base::WeakPtr<PepperMediaStreamVideoTrackHost> host_;
-
-  DISALLOW_COPY_AND_ASSIGN(VideoSource);
-};
+void PepperMediaStreamVideoTrackHost::StopSourceImpl() {
+  output_started_ = false;
+  frame_deliverer_ = NULL;
+}
 
 void PepperMediaStreamVideoTrackHost::DidConnectPendingHostToResource() {
   if (!MediaStreamVideoSink::connected_track().isNull())
     return;
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       media::BindToCurrentLoop(
           base::Bind(
               &PepperMediaStreamVideoTrackHost::OnVideoFrame,
               weak_factory_.GetWeakPtr())));
@@ skipping 51 matching lines @@
 }
 
 void PepperMediaStreamVideoTrackHost::InitBlinkTrack() {
   std::string source_id;
   base::Base64Encode(base::RandBytesAsString(64), &source_id);
   blink::WebMediaStreamSource webkit_source;
   webkit_source.initialize(base::UTF8ToUTF16(source_id),
                            blink::WebMediaStreamSource::TypeVideo,
                            base::UTF8ToUTF16(kPepperVideoSourceName),
                            false /* remote */);
-  MediaStreamVideoSource* const source =
-      new VideoSource(weak_factory_.GetWeakPtr());
-  webkit_source.setExtraData(source);  // Takes ownership of |source|.
+  webkit_source.setExtraData(this);
 
   const bool enabled = true;
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   track_ = MediaStreamVideoTrack::CreateVideoTrack(
-       source, constraints,
+       this, constraints,
        base::Bind(
            &PepperMediaStreamVideoTrackHost::OnTrackStarted,
            base::Unretained(this)),
        enabled);
-  // Note: The call to CreateVideoTrack() returned a track that holds a
-  // ref-counted reference to |webkit_source| (and, implicitly, |source|).
 }
 
 void PepperMediaStreamVideoTrackHost::OnTrackStarted(
     MediaStreamSource* source,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DVLOG(3) << "OnTrackStarted result: " << result;
 }
 
 }  // namespace content