Support configuring number of audio buffers in MediaStream Pepper API.

ppapi/proxy/media_stream_audio_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_audio_track_resource.h"
 
 #include "ppapi/proxy/audio_buffer_resource.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/media_stream_audio_track_shared.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
 MediaStreamAudioTrackResource::MediaStreamAudioTrackResource(
     Connection connection,
     PP_Instance instance,
     int pending_renderer_id,
@@ skipping 13 matching lines @@
 }
 
 PP_Var MediaStreamAudioTrackResource::GetId() {
   return StringVar::StringToPPVar(id());
 }
 
 PP_Bool MediaStreamAudioTrackResource::HasEnded() {
   return PP_FromBool(has_ended());
 }
 
 int32_t MediaStreamAudioTrackResource::Configure(

[Peng, 2014/05/26 14:48:49]

Add browser test please.
See ppapi/tests/test_media_stream* .

[thembrown, 2014/05/27 10:36:02]

Done.

     const int32_t attrib_list[],
     scoped_refptr<TrackedCallback> callback) {
-  // TODO(penghuang): Implement this function.
-  return PP_ERROR_NOTSUPPORTED;
+  if (has_ended())
+    return PP_ERROR_FAILED;
+
+  if (TrackedCallback::IsPending(configure_callback_) ||
+      TrackedCallback::IsPending(get_buffer_callback_)) {
+    return PP_ERROR_INPROGRESS;
+  }
+
+  // Do not support configure, if audio buffers are hold by plugin.
+  if (!buffers_.empty())
+    return PP_ERROR_INPROGRESS;
+
+  MediaStreamAudioTrackShared::Attributes attributes;
+  int i = 0;
+  for (; attrib_list[i] != PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE; i += 2) {
+    switch (attrib_list[i]) {
+    case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_BUFFERS:
+      attributes.buffers = attrib_list[i + 1];
+      break;
+    case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_RATE:
+    case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_SIZE:
+    case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_CHANNELS:
+    case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION:
+      return PP_ERROR_NOTSUPPORTED;
+    default:
+      return PP_ERROR_BADARGUMENT;
+    }
+  }
+
+  if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes))
+    return PP_ERROR_BADARGUMENT;
+
+  configure_callback_ = callback;
+  Call<PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply>(
+      RENDERER,
+      PpapiHostMsg_MediaStreamAudioTrack_Configure(attributes),
+      base::Bind(&MediaStreamAudioTrackResource::OnPluginMsgConfigureReply,
+                 base::Unretained(this)),
+      callback);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t MediaStreamAudioTrackResource::GetAttrib(
     PP_MediaStreamAudioTrack_Attrib attrib,
     int32_t* value) {
   // TODO(penghuang): Implement this function.
   return PP_ERROR_NOTSUPPORTED;
 }
 
 int32_t MediaStreamAudioTrackResource::GetBuffer(
     PP_Resource* buffer,
     scoped_refptr<TrackedCallback> callback) {
   if (has_ended())
     return PP_ERROR_FAILED;
 
-  if (TrackedCallback::IsPending(get_buffer_callback_))
+  if (TrackedCallback::IsPending(configure_callback_) ||
+      TrackedCallback::IsPending(get_buffer_callback_))
     return PP_ERROR_INPROGRESS;
 
   *buffer = GetAudioBuffer();
   if (*buffer)
     return PP_OK;
 
   // TODO(penghuang): Use the callback as hints to determine which thread will
   // use the resource, so we could deliver buffers to the target thread directly
   // for better performance.
   get_buffer_output_ = buffer;
@@ skipping 65 matching lines @@
 void MediaStreamAudioTrackResource::ReleaseBuffers() {
   BufferMap::iterator it = buffers_.begin();
   while (it != buffers_.end()) {
     // Just invalidate and release VideoBufferResorce, but keep PP_Resource.
     // So plugin can still use |RecycleBuffer()|.
     it->second->Invalidate();
     it->second = NULL;
   }
 }
 
+void MediaStreamAudioTrackResource::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