[PPAPI] Implement media stream video track API

ppapi/proxy/media_stream_video_track_resource.cc

+// Copyright (c) 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 "ppapi/proxy/media_stream_video_track_resource.h"
+
+#include "ppapi/proxy/video_frame_resource.h"
+#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/thunk/enter.h"
+
+namespace ppapi {
+namespace proxy {
+
+MediaStreamVideoTrackResource::MediaStreamVideoTrackResource(
+    Connection connection,
+    PP_Instance instance,
+    int pending_renderer_id,
+    const std::string& id)
+    : MediaStreamTrackResourceBase(
+        connection, instance, pending_renderer_id, id),
+      get_frame_output_(NULL) {
+}
+
+MediaStreamVideoTrackResource::~MediaStreamVideoTrackResource() {
+  Close();
+}
+
+thunk::PPB_MediaStreamVideoTrack_API*
+MediaStreamVideoTrackResource::AsPPB_MediaStreamVideoTrack_API() {
+  return this;
+}
+
+PP_Var MediaStreamVideoTrackResource::GetId() {
+  return StringVar::StringToPPVar(id());
+}
+
+PP_Bool MediaStreamVideoTrackResource::HasEnded() {
+  return PP_FromBool(has_ended());
+}
+
+int32_t MediaStreamVideoTrackResource::Configure(uint32_t max_buffered_frames) {
+  // TODO(penghuang): redesign and implement Configure() to support format,
+  // size, etc.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t MediaStreamVideoTrackResource::GetFrame(
+    PP_Resource* frame,
+    scoped_refptr<TrackedCallback> callback) {
+  if (has_ended())
+    return PP_ERROR_FAILED;
+
+  if (TrackedCallback::IsPending(get_frame_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  *frame = GetVideoFrame();
+  if (*frame)
+    return PP_OK;
+
+  get_frame_output_ = frame;
+  get_frame_callback_ = callback;
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t MediaStreamVideoTrackResource::RecycleFrame(PP_Resource frame) {
+  FrameMap::iterator it = frames_.find(frame);
+  if (it == frames_.end())
+    return PP_ERROR_BADRESOURCE;
+
+  scoped_refptr<VideoFrameResource> frame_resource = it->second;
+  frames_.erase(it);
+
+  if (has_ended())
+    return PP_OK;
+
+  thunk::EnterResourceNoLock<thunk::PPB_VideoFrame_API> enter(frame, false);

[bbudge, 2014/01/14 20:52:11]

You can avoid the EnterResource stuff and reference the VideoFrameResource
directly, via the scoped_refptr. You'd have to make all of the
PPB_VideoFrame_API methods public on the class.

That shouldn't be a problem. The thunk API stuff was needed before we switched
to the new resource system. The APIs were needed because there were multiple
implementors. Now, only the resource class implements the API, so it's mainly
useful to show what methods are intended to be callable by the internal proxy
code. The API doesn't need to correspond to the resource API that the plugin
sees.

[Peng, 2014/01/14 21:31:35]

Done. I like use scoped_refptr<VideoFrameResource> directly. :)

On 2014/01/14 20:52:11, bbudge wrote:

+  DCHECK(enter.succeeded());
+  DCHECK(enter.object()->GetFrameBufferIndex() >= 0);
+
+  SendEnqueueFrameMessageToHost(enter.object()->GetFrameBufferIndex());
+  enter.object()->Invalidate();
+  return PP_OK;
+}
+
+void MediaStreamVideoTrackResource::Close() {
+  if (has_ended())
+    return;
+
+  if (TrackedCallback::IsPending(get_frame_callback_)) {
+    *get_frame_output_ = 0;
+    get_frame_callback_->PostAbort();
+    get_frame_callback_ = NULL;
+    get_frame_output_ = 0;
+  }
+
+  ReleaseFrames();
+  MediaStreamTrackResourceBase::CloseInternal();
+}
+
+void MediaStreamVideoTrackResource::OnNewFrameEnqueued() {
+  if (TrackedCallback::IsPending(get_frame_callback_)) {
+    *get_frame_output_ = GetVideoFrame();
+    get_frame_callback_->PostRun(PP_OK);

[yzshen1, 2014/01/14 20:47:29]

This is called by a message handler, plugin code is not on the stack. Therefore,
I think it is sufficient to Run() instead of PostRun(), we won't reenter the
plugin code. But we do need to clean |get_frame_callback_| and
|get_frame_output_| first in case the plugin reenters us.

(On the contrary, the PostAbort() on line 92 is necessary, using Abort() may
re-enter the plugin code.)

[Peng, 2014/01/14 21:31:35]

Thanks for detailed explanation. Now understand when need PostRun().

Done.

+    get_frame_callback_ = NULL;
+    get_frame_output_ = 0;
+  }
+}
+
+PP_Resource MediaStreamVideoTrackResource::GetVideoFrame() {
+  int32_t index = frame_buffer()->DequeueFrame();
+  if (index < 0)
+    return 0;
+  MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index);
+  scoped_refptr<VideoFrameResource> resource =
+      new VideoFrameResource(pp_instance(), index, frame);
+  frames_.insert(FrameMap::value_type(resource->GetReference(), resource));

[yzshen1, 2014/01/14 20:47:29]

The current code looks like |frames_| owns a ref to the PP_Resource (because of
the GetReference() call), and the return value doesn't (because of
pp_resource()).

It seems better to add comment saying that the ref is returned to the plugin
instead of owned by |frames_|.

[Peng, 2014/01/14 21:31:35]

I changed the code to use pp_resource() at map.insert()

and GetReference() at return.

Done

+  return resource->pp_resource();
+}
+
+void MediaStreamVideoTrackResource::ReleaseFrames() {
+  FrameMap::iterator it = frames_.begin();
+  while (it != frames_.end()) {

[bbudge, 2014/01/14 20:52:11]

Again, just use the VideoFrameResource directly via the scoped_refptr now, i.e.
it->second->Invalidate().

[Peng, 2014/01/14 21:31:35]

Done.

+    thunk::EnterResourceNoLock<thunk::PPB_VideoFrame_API> enter(it->first,
+                                                                false);
+    DCHECK(enter.succeeded());
+    // Just invalidate and release VideoFrameResorce, but keep PP_Resource.
+    // So plugin can still use |RecycleFrame()|.
+    enter.object()->Invalidate();
+    it->second = NULL;
+  }
+}
+
+}  // namespace proxy
+}  // namespace ppapi