[PPAPI] Implement media stream video track API

ppapi/proxy/media_stream_video_track_resource.cc

Index: ppapi/proxy/media_stream_video_track_resource.cc
diff --git a/ppapi/proxy/media_stream_video_track_resource.cc b/ppapi/proxy/media_stream_video_track_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0ea50b0bf383edc125ad4dca1c980ec36f25043e
--- /dev/null
+++ b/ppapi/proxy/media_stream_video_track_resource.cc
@@ -0,0 +1,139 @@
+// 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) {
+  if (has_ended())
+    return PP_ERROR_FAILED;
+
+  std::map<PP_Resource, scoped_refptr<VideoFrameResource> >::iterator it =
+      frames_.find(frame);
+
+  if (it == frames_.end())
+    return PP_ERROR_BADRESOURCE;
+
+  scoped_refptr<VideoFrameResource> frame_resource = it->second;
+  frames_.erase(it);
+
+  DCHECK(frame_resource->index() >= 0);
+
+  HostEnqueueFrame(frame_resource->index());
+  frame_resource->invalidate();
+  PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(

[yzshen1, 2014/01/10 23:59:43]

I see that you take one ref to the keys of |frames_| (which are PP_Resources),
you don't have to do that. A PP_Resource is assigned to a VideoFrameResource
object, and it won't change or be assigned to others during the lifetime of
VideoFrameResource. So you can use the PP_Resource as the key without holding a
ref to it.

[Peng, 2014/01/11 00:30:55]

I though holding a ref in frames_ can avoid the VideoFrameResource being
destroyed. Is it necessary? Is holding scoped_refptr of the VideoFrameResource
in |frames_| enough?

[Peng, 2014/01/12 14:24:31]

Done.

+      frame_resource->pp_resource());
+
+  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);
+    get_frame_callback_ = NULL;
+    get_frame_output_ = 0;
+  }
+}
+
+PP_Resource MediaStreamVideoTrackResource::GetVideoFrame() {
+  int32_t index = frame_buffer()->DequeueFrame();
+  if (index < 0)
+    return 0;
+  MediaStreamFrame::Video* frame =
+      &(frame_buffer()->GetFramePointer(index)->video);
+  scoped_refptr<VideoFrameResource> resource =
+      new VideoFrameResource(pp_instance(), index, frame);
+  frames_.insert(std::pair<PP_Resource, scoped_refptr<VideoFrameResource> >(
+          resource->GetReference(), resource));

[yzshen1, 2014/01/10 23:59:43]

The indent of this line is a bit weird.

[Peng, 2014/01/12 14:24:31]

Done.

+  return resource->GetReference();
+}
+
+void MediaStreamVideoTrackResource::ReleaseFrames() {
+  ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
+  std::map<PP_Resource, scoped_refptr<VideoFrameResource> >::iterator it =
+      frames_.begin();
+  while (it != frames_.end()) {
+    scoped_refptr<VideoFrameResource> frame_resource = it->second;
+    frame_resource->invalidate();
+    tracker->ReleaseResource(frame_resource->pp_resource());
+  }
+  frames_.clear();
+}
+
+}  // namespace proxy
+}  // namespace ppapi