create a separate WebMediaPlayer for URL derived from media stream

content/renderer/media/local_video_capture.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 "content/renderer/media/local_video_capture.h"
+
+#include "content/renderer/media/video_capture_impl_manager.h"
+#include "media/base/video_util.h"
+#include "media/video/capture/video_capture_proxy.h"
+
+using media::CopyYPlane;
+using media::CopyUPlane;
+using media::CopyVPlane;
+
+LocalVideoCapture::LocalVideoCapture(
+    media::VideoCaptureSessionId video_stream_id,
+    VideoCaptureImplManager* vc_manager,
+    const media::VideoCaptureCapability& capability,
+    const base::Closure& error_cb,
+    const webkit_media::RepaintCB& repaint_cb)
+    : video_stream_id_(video_stream_id),
+      vc_manager_(vc_manager),
+      capability_(capability),
+      error_cb_(error_cb),
+      repaint_cb_(repaint_cb),
+      capture_engine_(NULL),
+      message_loop_proxy_(base::MessageLoopProxy::current()),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          handler_proxy_(new media::VideoCaptureHandlerProxy(
+              this, message_loop_proxy_))),
+      state_(video_capture::kStopped) {
+  DVLOG(3) << "LocalVideoCapture::ctor";
+  DCHECK(vc_manager);
+}
+
+LocalVideoCapture::~LocalVideoCapture() {
+  DVLOG(3) << "LocalVideoCapture::dtor";
+}
+
+void LocalVideoCapture::Start() {
+  DVLOG(3) << "LocalVideoCapture::Start";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(state_, video_capture::kStopped);
+
+  capture_engine_ = vc_manager_->AddDevice(video_stream_id_, this);
+  state_ = video_capture::kStarted;
+  AddRef();  // Will be balanced in OnRemoved().
+  capture_engine_->StartCapture(handler_proxy_.get(), capability_);
+}
+
+void LocalVideoCapture::Stop() {
+  DVLOG(3) << "LocalVideoCapture::Stop";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  if (capture_engine_) {
+    state_ = video_capture::kStopping;
+    capture_engine_->StopCapture(handler_proxy_.get());
+    capture_engine_ = NULL;
+  }
+}
+
+void LocalVideoCapture::Play() {
+  DVLOG(3) << "LocalVideoCapture::Play";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  if (capture_engine_ && state_ == video_capture::kPaused) {
+    state_ = video_capture::kStarted;
+  }
+}
+
+void LocalVideoCapture::Pause() {
+  DVLOG(3) << "LocalVideoCapture::Pause";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  if (capture_engine_ && state_ == video_capture::kStarted) {
+    state_ = video_capture::kPaused;
+  }
+}
+
+void LocalVideoCapture::OnStarted(media::VideoCapture* capture) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  NOTIMPLEMENTED();
+}
+
+void LocalVideoCapture::OnStopped(media::VideoCapture* capture) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  NOTIMPLEMENTED();
+}
+
+void LocalVideoCapture::OnPaused(media::VideoCapture* capture) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  NOTIMPLEMENTED();
+}
+
+void LocalVideoCapture::OnError(media::VideoCapture* capture,
+                                int error_code) {
+  DVLOG(3) << "LocalVideoCapture::OnError, " << error_code;
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  error_cb_.Run();
+}
+
+void LocalVideoCapture::OnRemoved(media::VideoCapture* capture) {
+  DVLOG(3) << "LocalVideoCapture::OnRemoved";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  vc_manager_->RemoveDevice(video_stream_id_, this);
+  Release();  // Balance the AddRef() in StartCapture().
+}
+
+void LocalVideoCapture::OnDeviceInfoReceived(
+    media::VideoCapture* capture,
+    const media::VideoCaptureParams& device_info) {
+  DVLOG(3) << "LocalVideoCapture::OnDeviceInfoReceived";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+}
+
+void LocalVideoCapture::OnBufferReady(
+    media::VideoCapture* capture,
+    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
+  DVLOG(3) << "LocalVideoCapture::OnBufferReady, state:" << state_;
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(buf);
+
+  if (state_ != video_capture::kStarted) {
+    capture->FeedBuffer(buf);
+    return;
+  }
+
+  gfx::Size natural_size(buf->width, buf->height);
+  scoped_refptr<media::VideoFrame> current_frame =
+      media::VideoFrame::CreateFrame(media::VideoFrame::YV12,
+                                     natural_size, natural_size,
+                                     buf->timestamp - base::Time());
+  uint8* buffer = buf->memory_pointer;
+
+  // Assume YV12 format.

[scherkus (not reviewing), 2012/09/07 11:44:03]

that seems like a scary assumption!

in release mode this DCHECK isn't present and we'll certainly be susceptible to
memory overwrites/reads

[wjia(left Chromium), 2012/09/13 01:22:07]

hrmm, for now, the media::VideoCapture::VideoFrameBuffer is fixed for color
media::VideoCaptureCapability::kI420. This |buf| is created in
VideoCaptureController::OnIncomingCapturedFrame in
content/browser/renderer_host/media/video_capture_controller.cc.

For the assumption of YV12 format, that's for output, i.e., the format needed by
WebMediaPlayer. That's a safe bet.

Could you elaborate if anything else is needed here to prevent memory
overwrites/reads?

+  DCHECK_EQ(capability_.color, media::VideoCaptureCapability::kI420);
+  int y_width = buf->width;
+  int y_height = buf->height;
+  int uv_width = buf->width / 2;
+  int uv_height = buf->height / 2;
+  CopyYPlane(buffer, y_width, y_height, current_frame);
+  buffer += y_width * y_height;
+  CopyUPlane(buffer, uv_width, uv_height, current_frame);
+  buffer += uv_width * uv_height;
+  CopyVPlane(buffer, uv_width, uv_height, current_frame);
+
+  capture->FeedBuffer(buf);
+  repaint_cb_.Run(current_frame);
+}