Return from |Configure()| asynchronously, and allow |InitBuffers()| to return errors.

content/renderer/pepper/pepper_media_stream_audio_track_host.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 "content/renderer/pepper/pepper_media_stream_audio_track_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_math.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio_buffer.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
+#include "ppapi/host/ppapi_host.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"
 
 using media::AudioParameters;
 using ppapi::host::HostMessageContext;
 using ppapi::MediaStreamAudioTrackShared;
 
 namespace {
 
@@ skipping 52 matching lines @@
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueBuffer(int32_t index) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
   DCHECK_GE(index, 0);
   DCHECK_LT(index, host_->buffer_manager()->number_of_buffers());
   base::AutoLock lock(lock_);
   buffers_.push_back(index);
 }
 
-void PepperMediaStreamAudioTrackHost::AudioSink::Configure(
-    int32_t number_of_buffers, int32_t duration) {
+int32_t PepperMediaStreamAudioTrackHost::AudioSink::Configure(
+    int32_t number_of_buffers, int32_t duration,
+    const ppapi::host::ReplyMessageContext& context) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
+
+  if (pending_configure_reply_.is_valid()) {
+    return PP_ERROR_INPROGRESS;
+  }
+  pending_configure_reply_ = context;
+
   bool changed = false;
   if (number_of_buffers != number_of_buffers_)
     changed = true;
   if (duration != 0 && duration != user_buffer_duration_) {
     user_buffer_duration_ = duration;
     changed = true;
   }
   number_of_buffers_ = number_of_buffers;
 
-  // Initialize later in OnSetFormat if bytes_per_second_ is not know yet.
-  if (changed && bytes_per_second_ > 0 && bytes_per_frame_ > 0)
-    InitBuffers();
+  if (changed) {
+    // Initialize later in OnSetFormat if bytes_per_second_ is not known yet.
+    if (bytes_per_second_ > 0 && bytes_per_frame_ > 0)
+      InitBuffers();
+  } else {
+    SendConfigureReply(PP_OK);
+  }
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::SendConfigureReply(
+    int32_t result) {
+  if (pending_configure_reply_.is_valid()) {
+    pending_configure_reply_.params.set_result(result);
+    host_->host()->SendReply(
+        pending_configure_reply_,
+        PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply());
+    pending_configure_reply_ = ppapi::host::ReplyMessageContext();
+  }
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::SetFormatOnMainThread(
     int bytes_per_second, int bytes_per_frame) {
   bytes_per_second_ = bytes_per_second;
   bytes_per_frame_ = bytes_per_frame;
   InitBuffers();
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffers() {
@@ skipping 17 matching lines @@
   base::CheckedNumeric<int32_t> buffer_size = buffer_audio_size;
   buffer_size += sizeof(ppapi::MediaStreamBuffer::Audio);
   DCHECK_GT(buffer_size.ValueOrDie(), 0);
 
   // We don't need to hold |lock_| during |host->InitBuffers()| call, because
   // we just cleared |buffers_| , so the audio thread will drop all incoming
   // audio data, and not use buffers in |host_|.
   bool result = host_->InitBuffers(number_of_buffers_,
                                    buffer_size.ValueOrDie(),
                                    kRead);
-  // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin.
-  CHECK(result);
+  if (!result) {
+    SendConfigureReply(PP_ERROR_NOMEMORY);
+    return;
+  }
 
   // Fill the |buffers_|, so the audio thread can continue receiving audio data.
   base::AutoLock lock(lock_);
   output_buffer_size_ = buffer_audio_size.ValueOrDie();
   for (int32_t i = 0; i < number_of_buffers_; ++i) {
     int32_t index = host_->buffer_manager()->DequeueBuffer();
     DCHECK_GE(index, 0);
     buffers_.push_back(index);
   }
+
+  SendConfigureReply(PP_OK);
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::
     SendEnqueueBufferMessageOnMainThread(int32_t index,
                                          int32_t buffers_generation) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
   // If |InitBuffers()| is called after this task being posted from the audio
   // thread, the buffer should become invalid already. We should ignore it.
   // And because only the main thread modifies the |buffers_generation_|,
   // so we don't need to lock |lock_| here (main thread).
@@ skipping 149 matching lines @@
 
 int32_t PepperMediaStreamAudioTrackHost::OnHostMsgConfigure(
     HostMessageContext* context,
     const MediaStreamAudioTrackShared::Attributes& attributes) {
   if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes))
     return PP_ERROR_BADARGUMENT;
 
   int32_t buffers = attributes.buffers
                         ? std::min(kMaxNumberOfBuffers, attributes.buffers)
                         : kDefaultNumberOfBuffers;
-  audio_sink_.Configure(buffers, attributes.duration);
-
-  context->reply_msg = PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply();
-  return PP_OK;
+  return audio_sink_.Configure(buffers, attributes.duration,
+                               context->MakeReplyMessageContext());
 }
 
 void PepperMediaStreamAudioTrackHost::OnClose() {
   if (connected_) {
     MediaStreamAudioSink::RemoveFromAudioTrack(&audio_sink_, track_);
     connected_ = false;
   }
+  audio_sink_.SendConfigureReply(PP_ERROR_ABORTED);
 }
 
 void PepperMediaStreamAudioTrackHost::OnNewBufferEnqueued() {
   int32_t index = buffer_manager()->DequeueBuffer();
   DCHECK_GE(index, 0);
   audio_sink_.EnqueueBuffer(index);
 }
 
 void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
   if (!connected_) {
     MediaStreamAudioSink::AddToAudioTrack(&audio_sink_, track_);
     connected_ = true;
   }
 }
 
 }  // namespace content