[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..59b0fab62ca2776aae2e08df33a0b67c460fc48d
--- /dev/null
+++ b/ppapi/proxy/media_stream_video_track_resource.cc
@@ -0,0 +1,130 @@
+// 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;

[dmichael (off chromium), 2014/01/13 21:26:47]

This seems a little strange to me. I think you're trying to account for the fact
that when the track is closed, you invalidate all the frames and clear your map.
But why should the plugin have to care? It seems like we could happily just say
"PP_OK" if they try to recycle a frame after end/close. One way to accomplish
that would be to *not* clear the map, but only invalidate all the resources it
refers to. You could even release the pointer and leave the PP_Resource in the
map with a null pointer value. What do you think?

On a related note...  you appear not to ever look for an end_of_stream frame. So
maybe you actually need two distinct states for this: closed and ended...  I'm
not sure if there are noticeable problems with the way you have it, but it's a
little confusing that has_ended doesn't necessarily mean that we reached the end
of the track.

[Peng, 2014/01/14 15:55:55]

Done.
Add a TODO in Host. will support close the track from host side.

+
+  FrameMap::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);
+
+  SendEnqueueFrameMessageToHost(frame_resource->index());
+  frame_resource->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);
+    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(FrameMap::value_type(resource->GetReference(), resource));
+  return resource->pp_resource();
+}
+
+void MediaStreamVideoTrackResource::ReleaseFrames() {
+  FrameMap::iterator it = frames_.begin();
+  while (it != frames_.end()) {
+    scoped_refptr<VideoFrameResource> frame_resource = it->second;
+    frame_resource->invalidate();
+  }
+  frames_.clear();
+}
+
+}  // namespace proxy
+}  // namespace ppapi