Move ppapi audio interface out of dev, but...

webkit/plugins/ppapi/ppb_audio_impl.cc

 // Copyright (c) 2010 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 "webkit/plugins/ppapi/ppb_audio_impl.h"
 
 #include "base/logging.h"
-#include "ppapi/c/dev/ppb_audio_dev.h"
-#include "ppapi/c/dev/ppb_audio_trusted_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/ppb_audio.h"
+#include "ppapi/c/ppb_audio_config.h"
+#include "ppapi/c/trusted/ppb_audio_trusted.h"
 #include "webkit/plugins/ppapi/common.h"
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 // PPB_AudioConfig -------------------------------------------------------------
 
-uint32_t RecommendSampleFrameCount(uint32_t requested_sample_frame_count);
+uint32_t RecommendSampleFrameCount(PP_AudioSampleRate sample_rate,
+                                   uint32_t requested_sample_frame_count);
 
 PP_Resource CreateStereo16bit(PP_Instance instance_id,
-                              PP_AudioSampleRate_Dev sample_rate,
+                              PP_AudioSampleRate sample_rate,
                               uint32_t sample_frame_count) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return 0;
 
   // TODO(brettw): Currently we don't actually check what the hardware
   // supports, so just allow sample rates of the "guaranteed working" ones.
   if (sample_rate != PP_AUDIOSAMPLERATE_44100 &&
       sample_rate != PP_AUDIOSAMPLERATE_48000)
     return 0;
 
   // TODO(brettw): Currently we don't actually query to get a value from the
   // hardware, so just validate the range.
-  if (RecommendSampleFrameCount(sample_frame_count) != sample_frame_count)
+  if (RecommendSampleFrameCount(sample_rate, sample_frame_count) !=
+      sample_frame_count)
     return 0;
 
   scoped_refptr<PPB_AudioConfig_Impl> config(
       new PPB_AudioConfig_Impl(instance->module(), sample_rate,
                                sample_frame_count));
   return config->GetReference();
 }
 
-uint32_t RecommendSampleFrameCount(uint32_t requested_sample_frame_count) {
+uint32_t RecommendSampleFrameCount(PP_AudioSampleRate sample_rate,
+                                   uint32_t requested_sample_frame_count) {
   // TODO(brettw) Currently we don't actually query to get a value from the
   // hardware, so we always return the input for in-range values.
   if (requested_sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
     return PP_AUDIOMINSAMPLEFRAMECOUNT;
   if (requested_sample_frame_count > PP_AUDIOMAXSAMPLEFRAMECOUNT)
     return PP_AUDIOMAXSAMPLEFRAMECOUNT;
   return requested_sample_frame_count;
 }
 
 PP_Bool IsAudioConfig(PP_Resource resource) {
   scoped_refptr<PPB_AudioConfig_Impl> config =
       Resource::GetAs<PPB_AudioConfig_Impl>(resource);
   return BoolToPPBool(!!config);
 }
 
-PP_AudioSampleRate_Dev GetSampleRate(PP_Resource config_id) {
+PP_AudioSampleRate GetSampleRate(PP_Resource config_id) {
   scoped_refptr<PPB_AudioConfig_Impl> config =
       Resource::GetAs<PPB_AudioConfig_Impl>(config_id);
   return config ? config->sample_rate() : PP_AUDIOSAMPLERATE_NONE;
 }
 
 uint32_t GetSampleFrameCount(PP_Resource config_id) {
   scoped_refptr<PPB_AudioConfig_Impl> config =
       Resource::GetAs<PPB_AudioConfig_Impl>(config_id);
   return config ? config->sample_frame_count() : 0;
 }
 
-const PPB_AudioConfig_Dev ppb_audioconfig = {
+const PPB_AudioConfig ppb_audioconfig = {
   &CreateStereo16bit,
   &RecommendSampleFrameCount,
   &IsAudioConfig,
   &GetSampleRate,
   &GetSampleFrameCount
 };
 
 // PPB_Audio -------------------------------------------------------------------
 
 PP_Resource Create(PP_Instance instance_id, PP_Resource config_id,
@@ skipping 28 matching lines @@
       Resource::GetAs<PPB_Audio_Impl>(audio_id);
   return audio ? BoolToPPBool(audio->StartPlayback()) : PP_FALSE;
 }
 
 PP_Bool StopPlayback(PP_Resource audio_id) {
   scoped_refptr<PPB_Audio_Impl> audio =
       Resource::GetAs<PPB_Audio_Impl>(audio_id);
   return audio ? BoolToPPBool(audio->StopPlayback()) : PP_FALSE;
 }
 
-const PPB_Audio_Dev ppb_audio = {
+const PPB_Audio ppb_audio = {
   &Create,
   &IsAudio,
   &GetCurrentConfig,
   &StartPlayback,
   &StopPlayback,
 };
 
 // PPB_AudioTrusted ------------------------------------------------------------
 
 PP_Resource CreateTrusted(PP_Instance instance_id) {
@@ skipping 32 matching lines @@
 int32_t GetSharedMemory(PP_Resource audio_id,
                         int* shm_handle,
                         uint32_t* shm_size) {
   scoped_refptr<PPB_Audio_Impl> audio =
       Resource::GetAs<PPB_Audio_Impl>(audio_id);
   if (audio)
     return audio->GetSharedMemory(shm_handle, shm_size);
   return PP_ERROR_BADRESOURCE;
 }
 
-const PPB_AudioTrusted_Dev ppb_audiotrusted = {
+const PPB_AudioTrusted ppb_audiotrusted = {
   &CreateTrusted,
   &Open,
   &GetSyncSocket,
   &GetSharedMemory,
 };
 
 }  // namespace
 
 // PPB_AudioConfig_Impl --------------------------------------------------------
 
 PPB_AudioConfig_Impl::PPB_AudioConfig_Impl(
     PluginModule* module,
-    PP_AudioSampleRate_Dev sample_rate,
+    PP_AudioSampleRate sample_rate,
     uint32_t sample_frame_count)
     : Resource(module),
       sample_rate_(sample_rate),
       sample_frame_count_(sample_frame_count) {
 }
 
-const PPB_AudioConfig_Dev* PPB_AudioConfig_Impl::GetInterface() {
+const PPB_AudioConfig* PPB_AudioConfig_Impl::GetInterface() {
   return &ppb_audioconfig;
 }
 
 size_t PPB_AudioConfig_Impl::BufferSize() {
   // TODO(audio): as more options become available, we'll need to
   // have additional code here to correctly calculate the size in
   // bytes of an audio buffer.  For now, only support two channel
   // int16_t sample buffers.
   const int kChannels = 2;
   const int kSizeOfSample = sizeof(int16_t);
@@ skipping 20 matching lines @@
   audio_ = NULL;
 
   // If the completion callback hasn't fired yet, do so here
   // with an error condition.
   if (create_callback_pending_) {
     PP_RunCompletionCallback(&create_callback_, PP_ERROR_ABORTED);
     create_callback_pending_ = false;
   }
 }
 
-const PPB_Audio_Dev* PPB_Audio_Impl::GetInterface() {
+const PPB_Audio* PPB_Audio_Impl::GetInterface() {
   return &ppb_audio;
 }
 
-const PPB_AudioTrusted_Dev* PPB_Audio_Impl::GetTrustedInterface() {
+const PPB_AudioTrusted* PPB_Audio_Impl::GetTrustedInterface() {
   return &ppb_audiotrusted;
 }
 
 PPB_Audio_Impl* PPB_Audio_Impl::AsPPB_Audio_Impl() {
   return this;
 }
 
 bool PPB_Audio_Impl::Init(PluginDelegate* plugin_delegate,
                           PP_Resource config_id,
                           PPB_Audio_Callback callback, void* user_data) {
@@ skipping 107 matching lines @@
     // the I/O thread and back, but this extra complexity doesn't seem worth it
     // just to clean up these handles faster.
   } else {
     SetStreamInfo(shared_memory_handle, shared_memory_size, socket_handle);
   }
 }
 
 }  // namespace ppapi
 }  // namespace webkit