[PPAPI] Implement media stream video track API

ppapi/proxy/video_frame_resource.cc

Index: ppapi/proxy/video_frame_resource.cc
diff --git a/ppapi/proxy/video_frame_resource.cc b/ppapi/proxy/video_frame_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e52ce9819be1aaed5708a45f0328e3121d9aa5c9
--- /dev/null
+++ b/ppapi/proxy/video_frame_resource.cc
@@ -0,0 +1,79 @@
+// 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 "ppapi/proxy/video_frame_resource.h"
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/shared_impl/var.h"
+
+namespace ppapi {
+namespace proxy {
+
+VideoFrameResource::VideoFrameResource(PP_Instance instance,
+                                       int32_t index,
+                                       MediaStreamFrame::Video* frame)
+    : Resource(OBJECT_IS_PROXY, instance),
+      index_(index),
+      frame_(frame) {
+}
+
+VideoFrameResource::~VideoFrameResource() {
+  CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed.";

[yzshen1, 2014/01/10 21:05:17]

If I read the code correctly, currently the track resource doesn't keep a record
of what VideoFrameResource objects are given to the plugin. When it dies, it
doesn't notify all those unrecycled frames (if any) to invalidate.
Therefore, those unrecycled frames carry dangling pointers and crash in the
destructor.

To me, it seems nicer to let the track resource keeps a record of those
unrecycled frames, and invalidates them when the track dies. That way, even if
the plugin is still holding references to those unrecycled frames, at least they
don't have dangling pointers.

What do you think?

[Peng, 2014/01/10 22:46:58]

It is good idea.

+}
+
+thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() {
+  return this;
+}
+
+PP_TimeDelta VideoFrameResource::GetTimestamp() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return 0.0;
+  }
+  return frame_->timestamp;
+}
+
+void VideoFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return;
+  }
+  frame_->timestamp = timestamp;
+}
+
+PP_VideoFrame_Format VideoFrameResource::GetFormat() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return PP_VIDEOFRAME_FORMAT_UNKNOWN;
+  }
+  return frame_->format;
+}
+
+PP_Bool VideoFrameResource::GetSize(PP_Size* size) {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return PP_FALSE;
+  }
+  *size = frame_->size;
+  return PP_TRUE;
+}
+
+void* VideoFrameResource::GetDataBuffer() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return NULL;
+  }
+  return frame_->data;
+}
+
+uint32_t VideoFrameResource::GetDataBufferSize() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return 0;
+  }
+  return frame_->data_size;
+}
+
+}  // namespace proxy
+}  // namespace ppapi