Rewrite PPB_AudioInput_Dev to use the new-style host/resource.

ppapi/shared_impl/ppb_audio_input_shared.cc

Index: ppapi/shared_impl/ppb_audio_input_shared.cc
diff --git a/ppapi/shared_impl/ppb_audio_input_shared.cc b/ppapi/shared_impl/ppb_audio_input_shared.cc
deleted file mode 100644
index 0814883ea360f10b22767d83d39cee6e364382a6..0000000000000000000000000000000000000000
--- a/ppapi/shared_impl/ppb_audio_input_shared.cc
+++ /dev/null
@@ -1,278 +0,0 @@
-// 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/shared_impl/ppb_audio_input_shared.h"
-
-#include "base/logging.h"
-#include "media/audio/audio_parameters.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/shared_impl/ppapi_globals.h"
-#include "ppapi/shared_impl/ppb_device_ref_shared.h"
-#include "ppapi/shared_impl/resource_tracker.h"
-#include "ppapi/thunk/enter.h"
-#include "ppapi/thunk/ppb_audio_config_api.h"
-
-namespace ppapi {
-
-namespace {
-
-void IgnoredCompletionCallback(void* user_data, int32_t result) {
-  // Do nothing.
-}
-
-}  // namespace
-
-PPB_AudioInput_Shared::PPB_AudioInput_Shared(const HostResource& audio_input)
-    : Resource(OBJECT_IS_PROXY, audio_input),
-      open_state_(BEFORE_OPEN),
-      capturing_(false),
-      shared_memory_size_(0),
-      audio_input_callback_(NULL),
-      user_data_(NULL),
-      devices_(NULL),
-      resource_object_type_(OBJECT_IS_PROXY) {
-}
-
-PPB_AudioInput_Shared::PPB_AudioInput_Shared(PP_Instance instance)
-    : Resource(OBJECT_IS_IMPL, instance),
-      open_state_(BEFORE_OPEN),
-      capturing_(false),
-      shared_memory_size_(0),
-      audio_input_callback_(NULL),
-      user_data_(NULL),
-      devices_(NULL),
-      resource_object_type_(OBJECT_IS_IMPL) {
-}
-
-PPB_AudioInput_Shared::~PPB_AudioInput_Shared() {
-  DCHECK(open_state_ == CLOSED);
-}
-
-thunk::PPB_AudioInput_API* PPB_AudioInput_Shared::AsPPB_AudioInput_API() {
-  return this;
-}
-
-int32_t PPB_AudioInput_Shared::EnumerateDevices(
-    PP_Resource* devices,
-    scoped_refptr<TrackedCallback> callback) {
-  if (TrackedCallback::IsPending(enumerate_devices_callback_))
-    return PP_ERROR_INPROGRESS;
-
-  return InternalEnumerateDevices(devices, callback);
-}
-
-int32_t PPB_AudioInput_Shared::Open(
-    const std::string& device_id,
-    PP_Resource config,
-    PPB_AudioInput_Callback audio_input_callback,
-    void* user_data,
-    scoped_refptr<TrackedCallback> callback) {
-  if (!audio_input_callback)
-    return PP_ERROR_BADARGUMENT;
-
-  return CommonOpen(device_id, config, audio_input_callback, user_data,
-                    callback);
-}
-
-PP_Resource PPB_AudioInput_Shared::GetCurrentConfig() {
-  // AddRef for the caller.
-  if (config_.get())
-    PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(config_);
-  return config_;
-}
-
-PP_Bool PPB_AudioInput_Shared::StartCapture() {
-  if (open_state_ == CLOSED || (open_state_ == BEFORE_OPEN &&
-                                !TrackedCallback::IsPending(open_callback_))) {
-    return PP_FALSE;
-  }
-  if (capturing_)
-    return PP_TRUE;
-
-  // If the audio input device hasn't been opened, set |capturing_| to true and
-  // return directly. Capturing will be started once the open operation is
-  // completed.
-  if (open_state_ == BEFORE_OPEN) {
-    capturing_ = true;
-    return PP_TRUE;
-  }
-
-  return InternalStartCapture();
-}
-
-PP_Bool PPB_AudioInput_Shared::StopCapture() {
-  if (open_state_ == CLOSED)
-    return PP_FALSE;
-  if (!capturing_)
-    return PP_TRUE;
-
-  // If the audio input device hasn't been opened, set |capturing_| to false and
-  // return directly.
-  if (open_state_ == BEFORE_OPEN) {
-    capturing_ = false;
-    return PP_TRUE;
-  }
-
-  return InternalStopCapture();
-}
-
-void PPB_AudioInput_Shared::Close() {
-  if (open_state_ == CLOSED)
-    return;
-
-  open_state_ = CLOSED;
-  InternalClose();
-  StopThread();
-
-  if (TrackedCallback::IsPending(open_callback_))
-    open_callback_->PostAbort();
-}
-
-void PPB_AudioInput_Shared::OnEnumerateDevicesComplete(
-    int32_t result,
-    const std::vector<DeviceRefData>& devices) {
-  DCHECK(TrackedCallback::IsPending(enumerate_devices_callback_));
-
-  if (result == PP_OK && devices_) {
-    *devices_ = PPB_DeviceRef_Shared::CreateResourceArray(
-        resource_object_type_, pp_instance(), devices);
-  }
-  devices_ = NULL;
-
-  enumerate_devices_callback_->Run(result);
-}
-
-void PPB_AudioInput_Shared::OnOpenComplete(
-    int32_t result,
-    base::SharedMemoryHandle shared_memory_handle,
-    size_t shared_memory_size,
-    base::SyncSocket::Handle socket_handle) {
-  if (open_state_ == BEFORE_OPEN && result == PP_OK) {
-    open_state_ = OPENED;
-    SetStreamInfo(shared_memory_handle, shared_memory_size, socket_handle);
-  } else {
-    // Clean up the handles.
-    base::SyncSocket temp_socket(socket_handle);
-    base::SharedMemory temp_mem(shared_memory_handle, false);
-    capturing_ = false;
-  }
-
-  // The callback may have been aborted by Close().
-  if (TrackedCallback::IsPending(open_callback_))
-    open_callback_->Run(result);
-}
-
-// static
-scoped_refptr<TrackedCallback>
-PPB_AudioInput_Shared::MakeIgnoredCompletionCallback(
-    Resource* resource) {
-  return new TrackedCallback(resource,
-      PP_MakeCompletionCallback(&IgnoredCompletionCallback, NULL));
-}
-
-void PPB_AudioInput_Shared::SetStartCaptureState() {
-  DCHECK(!capturing_);
-  DCHECK(!audio_input_thread_.get());
-
-  capturing_ = true;
-  StartThread();
-}
-
-void PPB_AudioInput_Shared::SetStopCaptureState() {
-  DCHECK(capturing_);
-  StopThread();
-  capturing_ = false;
-}
-
-void PPB_AudioInput_Shared::SetStreamInfo(
-    base::SharedMemoryHandle shared_memory_handle,
-    size_t shared_memory_size,
-    base::SyncSocket::Handle socket_handle) {
-  socket_.reset(new base::CancelableSyncSocket(socket_handle));
-  shared_memory_.reset(new base::SharedMemory(shared_memory_handle, false));
-  shared_memory_size_ = shared_memory_size;
-
-  if (!shared_memory_->Map(shared_memory_size_)) {
-    PpapiGlobals::Get()->LogWithSource(pp_instance(), PP_LOGLEVEL_WARNING, "",
-      "Failed to map shared memory for PPB_AudioInput_Shared.");
-  }
-
-  // There is a pending capture request before SetStreamInfo().
-  if (capturing_) {
-    // Set |capturing_| to false so that the state looks consistent to
-    // InternalStartCapture(). It will be reset to true by
-    // SetStartCaptureState().
-    capturing_ = false;
-    InternalStartCapture();
-  }
-}
-
-void PPB_AudioInput_Shared::StartThread() {
-  // Don't start the thread unless all our state is set up correctly.
-  if (!audio_input_callback_ || !socket_.get() || !capturing_ ||
-      !shared_memory_->memory()) {
-    return;
-  }
-  DCHECK(!audio_input_thread_.get());
-  audio_input_thread_.reset(new base::DelegateSimpleThread(
-      this, "plugin_audio_input_thread"));
-  audio_input_thread_->Start();
-}
-
-void PPB_AudioInput_Shared::StopThread() {
-  // Shut down the socket to escape any hanging |Receive|s.
-  if (socket_.get())
-    socket_->Shutdown();
-  if (audio_input_thread_.get()) {
-    audio_input_thread_->Join();
-    audio_input_thread_.reset();
-  }
-}
-
-void PPB_AudioInput_Shared::Run() {
-  // The shared memory represents AudioInputBufferParameters and the actual data
-  // buffer.
-  media::AudioInputBuffer* buffer =
-      static_cast<media::AudioInputBuffer*>(shared_memory_->memory());
-  uint32_t data_buffer_size =
-      shared_memory_size_ - sizeof(media::AudioInputBufferParameters);
-  int pending_data;
-
-  while (sizeof(pending_data) == socket_->Receive(&pending_data,
-                                                  sizeof(pending_data)) &&
-         pending_data >= 0) {
-    // While closing the stream, we may receive buffers whose size is different
-    // from |data_buffer_size|.
-    CHECK_LE(buffer->params.size, data_buffer_size);
-    if (buffer->params.size > 0)
-      audio_input_callback_(&buffer->audio[0], buffer->params.size, user_data_);
-  }
-}
-
-int32_t PPB_AudioInput_Shared::CommonOpen(
-    const std::string& device_id,
-    PP_Resource config,
-    PPB_AudioInput_Callback audio_input_callback,
-    void* user_data,
-    scoped_refptr<TrackedCallback> callback) {
-  if (open_state_ != BEFORE_OPEN)
-    return PP_ERROR_FAILED;
-
-  thunk::EnterResourceNoLock<thunk::PPB_AudioConfig_API> enter_config(config,
-                                                                      true);
-  if (enter_config.failed())
-    return PP_ERROR_BADARGUMENT;
-
-  if (TrackedCallback::IsPending(open_callback_))
-    return PP_ERROR_INPROGRESS;
-
-  config_ = config;
-  audio_input_callback_ = audio_input_callback;
-  user_data_ = user_data;
-
-  return InternalOpen(device_id, enter_config.object()->GetSampleRate(),
-                      enter_config.object()->GetSampleFrameCount(), callback);
-}
-
-}  // namespace ppapi