[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[],
     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_FAILED;
+  }
+
+  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) {
+  DCHECK(TrackedCallback::IsPending(configure_callback_));
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(configure_callback_);
+  callback->Run(params.result());
+}
+
 }  // namespace proxy
 }  // namespace ppapi