[WIP][PPAPI] Implement MediaStreamVideoTrackResource.

ppapi/proxy/media_stream_video_track_resource.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 "ppapi/proxy/media_stream_video_track_resource.h"
+
+#include "ppapi/proxy/io_stream_resource.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/video_frame_resource.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/shared_impl/video_frame.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)
+    : IOStreamResource(connection, instance, pending_renderer_id, true),
+      id_(id),
+      current_frame_(NULL),
+      get_frame_output_(NULL) {
+}
+
+MediaStreamVideoTrackResource::~MediaStreamVideoTrackResource() {
+  ppapi::ProxyLock::AssertAcquiredDebugOnly();
+}
+
+thunk::PPB_MediaStreamVideoTrack_API*
+MediaStreamVideoTrackResource::AsPPB_MediaStreamVideoTrack_API() {
+  return this;
+}
+
+PP_Var MediaStreamVideoTrackResource::GetId() {
+  return StringVar::StringToPPVar(id_);
+}
+
+PP_Bool MediaStreamVideoTrackResource::HasEnded() {
+  return PP_FALSE;
+}
+
+int32_t MediaStreamVideoTrackResource::Configure(uint32_t max_buffered_frames) {
+  return PP_OK;
+}
+
+int32_t MediaStreamVideoTrackResource::GetFrame(
+    PP_Resource* frame,
+    const scoped_refptr<ppapi::TrackedCallback>& callback) {
+  if (TrackedCallback::IsPending(get_frame_callback_))
+    return PP_ERROR_INPROGRESS;
+  int32_t result = CreateCurrentFrame();
+  if (result == PP_OK) {
+    *frame = current_frame_->GetReference();
+  } else if (result == PP_OK_COMPLETIONPENDING) {
+    get_frame_output_ = frame;
+    get_frame_callback_ = callback;
+  }
+  return result;
+}
+
+int32_t MediaStreamVideoTrackResource::RecycleFrame(PP_Resource frame) {
+  if (!frame)
+    return PP_ERROR_BADRESOURCE;
+  if (!current_frame_)
+    return PP_ERROR_FAILED;
+  if (current_frame_->pp_resource() != frame)
+    return PP_ERROR_BADARGUMENT;
+
+  Unlock(current_frame_->video_frame());
+  current_frame_->set_video_frame(NULL);
+  PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(
+      current_frame_->pp_resource());
+  current_frame_ = NULL;
+  return PP_OK;
+}
+
+int32_t MediaStreamVideoTrackResource::Close() {
+  return PP_OK;
+}
+
+void MediaStreamVideoTrackResource::OnReplyReceived(
+    const proxy::ResourceMessageReplyParams& params, const IPC::Message& msg) {
+  IPC_BEGIN_MESSAGE_MAP(MediaStreamVideoTrackResource, msg)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
+        IOStreamResource::OnReplyReceived(params, msg))
+  IPC_END_MESSAGE_MAP()
+}
+
+void MediaStreamVideoTrackResource::OnMoreBufferAvailable() {
+  int32_t result = PP_ERROR_FAILED;
+  if (TrackedCallback::IsPending(get_frame_callback_))
+    result = CreateCurrentFrame();
+  if (result == PP_OK) {
+    *get_frame_output_ = current_frame_->GetReference();
+    get_frame_callback_->PostRun(PP_OK);
+    get_frame_output_ = 0;
+    get_frame_callback_ = NULL;
+  }
+}
+
+int32_t MediaStreamVideoTrackResource::CreateCurrentFrame() {
+  if (current_frame_)
+    return PP_ERROR_INPROGRESS;
+  if (!remaining())
+    return PP_OK_COMPLETIONPENDING;
+  VideoFrame* frame = NULL;
+  CHECK(Lock(reinterpret_cast<void **>(&frame), sizeof(VideoFrame)) == PP_OK);
+  CHECK(Relock(frame, sizeof(VideoFrame) + frame->data_size) == PP_OK);
+  current_frame_ = new VideoFrameResource(pp_instance(), frame);
+  current_frame_->GetReference();
+  return PP_OK;
+}
+
+}  // namespace proxy
+}  // namespace ppapi