[PPAPI][MediaStream] Support configure for video input.

ppapi/proxy/media_stream_video_track_resource.cc

 // 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/media_stream_video_track_resource.h"
 
 #include "base/logging.h"
+#include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/video_frame_resource.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
+#include "ppapi/shared_impl/media_stream_video_track_shared.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
 MediaStreamVideoTrackResource::MediaStreamVideoTrackResource(
     Connection connection,
     PP_Instance instance,
     int pending_renderer_id,
     const std::string& id)
@@ skipping 12 matching lines @@
 }
 
 PP_Var MediaStreamVideoTrackResource::GetId() {
   return StringVar::StringToPPVar(id());
 }
 
 PP_Bool MediaStreamVideoTrackResource::HasEnded() {
   return PP_FromBool(has_ended());
 }
 
-
 int32_t MediaStreamVideoTrackResource::Configure(
     const int32_t attrib_list[],

[jschuh, 2014/02/14 22:21:25]

So, are you saying attrib_list is always static data from the caller, and will
never be from an untrusted source? Also, this just seems like an unnecessarily
opaque and confusing implementation. Am I missing something, or would this make
more sense as a vector of structures?

[Peng, 2014/02/16 15:48:13]

1. The arguments are from plugin. I think it is not from trusted source.
2. Because this interface is used by plugin. So we have to use c type, we can
not use std::vector.
3. We do not use structure is because we want to make this API extendible. It
will support more attributes in future. We would like to support more attributes
in future and without break the API.

WDYT?

     scoped_refptr<TrackedCallback> callback) {
-  // TODO(penghuang): redesign and implement Configure() to support format,
-  // size, etc.
-  return PP_ERROR_NOTSUPPORTED;
+  if (has_ended())
+    return PP_ERROR_FAILED;
+
+  if (TrackedCallback::IsPending(configure_callback_) ||
+      TrackedCallback::IsPending(get_frame_callback_)) {
+    return PP_ERROR_INPROGRESS;
+  }
+
+  // Do not support configure, if frames are hold by plugin.
+  if (!frames_.empty())
+    return PP_ERROR_INPROGRESS;
+
+  MediaStreamVideoTrackShared::Attributes attributes;
+  int i = 0;
+  for (;attrib_list[i] != PP_MEDIASTREAMVIDEOTRACK_ATTRIB_NONE; i += 2) {
+    switch (attrib_list[i]) {
+    case PP_MEDIASTREAMVIDEOTRACK_ATTRIB_BUFFERED_FRAMES:
+      attributes.mask |= MediaStreamVideoTrackShared::Attributes::MASK_BUFFERS;
+      attributes.buffers = attrib_list[i + 1];
+      break;
+    case PP_MEDIASTREAMVIDEOTRACK_ATTRIB_WIDTH:
+      attributes.mask |= MediaStreamVideoTrackShared::Attributes::MASK_WIDTH;
+      attributes.width = attrib_list[i + 1];
+      break;
+    case PP_MEDIASTREAMVIDEOTRACK_ATTRIB_HEIGHT:
+      attributes.mask |= MediaStreamVideoTrackShared::Attributes::MASK_HEIGHT;
+      attributes.height = attrib_list[i + 1];
+      break;
+    case PP_MEDIASTREAMVIDEOTRACK_ATTRIB_FORMAT:
+      attributes.mask |= MediaStreamVideoTrackShared::Attributes::MASK_FORMAT;
+      attributes.format = static_cast<PP_VideoFrame_Format>(attrib_list[i + 1]);
+      break;
+    default:
+      return PP_ERROR_BADARGUMENT;
+    }
+  }
+
+  if (!MediaStreamVideoTrackShared::VerifyAttributes(attributes)) {
+    return PP_ERROR_BADARGUMENT;
+  }
+
+  if (!attributes.mask) {
+    return PP_OK;
+  }
+
+  configure_callback_ = callback;
+  Call<PpapiPluginMsg_MediaStreamVideoTrack_ConfigureReply>(
+      RENDERER,
+      PpapiHostMsg_MediaStreamVideoTrack_Configure(attributes),
+      base::Bind(&MediaStreamVideoTrackResource::OnPluginMsgConfigureReply,
+                 base::Unretained(this)),
+      callback);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t MediaStreamVideoTrackResource::GetAttrib(
     PP_MediaStreamVideoTrack_Attrib attrib,
     int32_t* value) {
   // TODO(penghuang): implement this function.
   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_))
+  if (TrackedCallback::IsPending(configure_callback_) ||
+      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;
 }
 
@@ skipping 61 matching lines @@
 void MediaStreamVideoTrackResource::ReleaseFrames() {
   FrameMap::iterator it = frames_.begin();
   while (it != frames_.end()) {
     // Just invalidate and release VideoFrameResorce, but keep PP_Resource.
     // So plugin can still use |RecycleFrame()|.
     it->second->Invalidate();
     it->second = NULL;
   }
 }
 
+void MediaStreamVideoTrackResource::OnPluginMsgConfigureReply(
+    const ResourceMessageReplyParams& params) {
+  if (TrackedCallback::IsPending(configure_callback_)) {
+    scoped_refptr<TrackedCallback> callback;
+    callback.swap(configure_callback_);
+    callback->Run(params.result());
+  }
+}
+
 }  // namespace proxy
 }  // namespace ppapi