[PPAPI][MediaStream] Rename AudioFrame to AudioBuffer

For audio, a frame usually has the same meaning as sample,
so AudioFrame is not a good name for a bunch of audio
samples. Change it to AudioBuffer.

BUG=330851

Review URL: https://codereview.chromium.org/156863005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@250460 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 86 insertions, 85 deletions

diff --git a/ppapi/proxy/audio_frame_resource.cc b/ppapi/proxy/audio_buffer_resource.cc
index 0827df7..1435b4c 100644
--- a/ppapi/proxy/audio_frame_resource.cc
+++ b/ppapi/proxy/audio_buffer_resource.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ppapi/proxy/audio_frame_resource.h"
+#include "ppapi/proxy/audio_buffer_resource.h"
 
 #include "base/logging.h"
 #include "ppapi/c/pp_bool.h"
@@ -12,7 +12,7 @@
 namespace ppapi {
 namespace proxy {
 
-AudioFrameResource::AudioFrameResource(PP_Instance instance,
+AudioBufferResource::AudioBufferResource(PP_Instance instance,
                                        int32_t index,
                                        MediaStreamBuffer* buffer)
     : Resource(OBJECT_IS_PROXY, instance),
@@ -21,15 +21,15 @@ AudioFrameResource::AudioFrameResource(PP_Instance instance,
   DCHECK_EQ(buffer_->header.type, MediaStreamBuffer::TYPE_AUDIO);
 }
 
-AudioFrameResource::~AudioFrameResource() {
-  CHECK(!buffer_) << "An unused (or unrecycled) frame is destroyed.";
+AudioBufferResource::~AudioBufferResource() {
+  CHECK(!buffer_) << "An unused (or unrecycled) buffer is destroyed.";
 }
 
-thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() {
+thunk::PPB_AudioBuffer_API* AudioBufferResource::AsPPB_AudioBuffer_API() {
   return this;
 }
 
-PP_TimeDelta AudioFrameResource::GetTimestamp() {
+PP_TimeDelta AudioBufferResource::GetTimestamp() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return 0.0;
@@ -37,7 +37,7 @@ PP_TimeDelta AudioFrameResource::GetTimestamp() {
   return buffer_->audio.timestamp;
 }
 
-void AudioFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
+void AudioBufferResource::SetTimestamp(PP_TimeDelta timestamp) {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return;
@@ -45,23 +45,23 @@ void AudioFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
   buffer_->audio.timestamp = timestamp;
 }
 
-PP_AudioFrame_SampleRate AudioFrameResource::GetSampleRate() {
+PP_AudioBuffer_SampleRate AudioBufferResource::GetSampleRate() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
-    return PP_AUDIOFRAME_SAMPLERATE_UNKNOWN;
+    return PP_AUDIOBUFFER_SAMPLERATE_UNKNOWN;
   }
   return buffer_->audio.sample_rate;
 }
 
-PP_AudioFrame_SampleSize AudioFrameResource::GetSampleSize() {
+PP_AudioBuffer_SampleSize AudioBufferResource::GetSampleSize() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
-    return PP_AUDIOFRAME_SAMPLESIZE_UNKNOWN;
+    return PP_AUDIOBUFFER_SAMPLESIZE_UNKNOWN;
   }
-  return PP_AUDIOFRAME_SAMPLESIZE_16_BITS;
+  return PP_AUDIOBUFFER_SAMPLESIZE_16_BITS;
 }
 
-uint32_t AudioFrameResource::GetNumberOfChannels() {
+uint32_t AudioBufferResource::GetNumberOfChannels() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return 0;
@@ -69,7 +69,7 @@ uint32_t AudioFrameResource::GetNumberOfChannels() {
   return buffer_->audio.number_of_channels;
 }
 
-uint32_t AudioFrameResource::GetNumberOfSamples() {
+uint32_t AudioBufferResource::GetNumberOfSamples() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return 0;
@@ -77,7 +77,7 @@ uint32_t AudioFrameResource::GetNumberOfSamples() {
   return buffer_->audio.number_of_samples;
 }
 
-void* AudioFrameResource::GetDataBuffer() {
+void* AudioBufferResource::GetDataBuffer() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return NULL;
@@ -85,7 +85,7 @@ void* AudioFrameResource::GetDataBuffer() {
   return buffer_->audio.data;
 }
 
-uint32_t AudioFrameResource::GetDataBufferSize() {
+uint32_t AudioBufferResource::GetDataBufferSize() {
   if (!buffer_) {
     VLOG(1) << "Buffer is invalid";
     return 0;
@@ -93,15 +93,15 @@ uint32_t AudioFrameResource::GetDataBufferSize() {
   return buffer_->audio.data_size;
 }
 
-MediaStreamBuffer* AudioFrameResource::GetBuffer() {
+MediaStreamBuffer* AudioBufferResource::GetBuffer() {
   return buffer_;
 }
 
-int32_t AudioFrameResource::GetBufferIndex() {
+int32_t AudioBufferResource::GetBufferIndex() {
   return index_;
 }
 
-void AudioFrameResource::Invalidate() {
+void AudioBufferResource::Invalidate() {
   DCHECK(buffer_);
   DCHECK_GE(index_, 0);
   buffer_ = NULL;
diff --git a/ppapi/proxy/audio_frame_resource.h b/ppapi/proxy/audio_buffer_resource.h
index 8332ec2..b4ef3eb7 100644
--- a/ppapi/proxy/audio_frame_resource.h
+++ b/ppapi/proxy/audio_buffer_resource.h
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef PPAPI_PROXY_AUDIO_FRAME_RESOURCE_H_
-#define PPAPI_PROXY_AUDIO_FRAME_RESOURCE_H_
+#ifndef PPAPI_PROXY_AUDIO_BUFFER_RESOURCE_H_
+#define PPAPI_PROXY_AUDIO_BUFFER_RESOURCE_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
 #include "ppapi/shared_impl/resource.h"
-#include "ppapi/thunk/ppb_audio_frame_api.h"
+#include "ppapi/thunk/ppb_audio_buffer_api.h"
 
 namespace ppapi {
 
@@ -17,23 +17,24 @@ union MediaStreamBuffer;
 
 namespace proxy {
 
-class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource,
-                                              public thunk::PPB_AudioFrame_API {
+class PPAPI_PROXY_EXPORT AudioBufferResource
+    : public Resource,
+      public thunk::PPB_AudioBuffer_API {
  public:
-  AudioFrameResource(PP_Instance instance,
+  AudioBufferResource(PP_Instance instance,
                      int32_t index,
                      MediaStreamBuffer* buffer);
 
-  virtual ~AudioFrameResource();
+  virtual ~AudioBufferResource();
 
   // PluginResource overrides:
-  virtual thunk::PPB_AudioFrame_API* AsPPB_AudioFrame_API() OVERRIDE;
+  virtual thunk::PPB_AudioBuffer_API* AsPPB_AudioBuffer_API() OVERRIDE;
 
-  // PPB_AudioFrame_API overrides:
+  // PPB_AudioBuffer_API overrides:
   virtual PP_TimeDelta GetTimestamp() OVERRIDE;
   virtual void SetTimestamp(PP_TimeDelta timestamp) OVERRIDE;
-  virtual PP_AudioFrame_SampleRate GetSampleRate() OVERRIDE;
-  virtual PP_AudioFrame_SampleSize GetSampleSize() OVERRIDE;
+  virtual PP_AudioBuffer_SampleRate GetSampleRate() OVERRIDE;
+  virtual PP_AudioBuffer_SampleSize GetSampleSize() OVERRIDE;
   virtual uint32_t GetNumberOfChannels() OVERRIDE;
   virtual uint32_t GetNumberOfSamples() OVERRIDE;
   virtual void* GetDataBuffer() OVERRIDE;
@@ -42,15 +43,15 @@ class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource,
   virtual int32_t GetBufferIndex() OVERRIDE;
   virtual void Invalidate() OVERRIDE;
 
-  // Frame index
+  // Buffer index
   int32_t index_;
 
   MediaStreamBuffer* buffer_;
 
-  DISALLOW_COPY_AND_ASSIGN(AudioFrameResource);
+  DISALLOW_COPY_AND_ASSIGN(AudioBufferResource);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
-#endif  // PPAPI_PROXY_AUDIO_FRAME_RESOURCE_H_
+#endif  // PPAPI_PROXY_AUDIO_BUFFER_RESOURCE_H_
diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc
index 249f0fb..6842d4fd 100644
--- a/ppapi/proxy/interface_list.cc
+++ b/ppapi/proxy/interface_list.cc
@@ -31,8 +31,8 @@
 #include "ppapi/c/dev/ppb_view_dev.h"
 #include "ppapi/c/extensions/dev/ppb_ext_socket_dev.h"
 #include "ppapi/c/ppb_audio.h"
+#include "ppapi/c/ppb_audio_buffer.h"
 #include "ppapi/c/ppb_audio_config.h"
-#include "ppapi/c/ppb_audio_frame.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_file_io.h"
diff --git a/ppapi/proxy/media_stream_audio_track_resource.cc b/ppapi/proxy/media_stream_audio_track_resource.cc
index 951bda8..15a6a16 100644
--- a/ppapi/proxy/media_stream_audio_track_resource.cc
+++ b/ppapi/proxy/media_stream_audio_track_resource.cc
@@ -4,7 +4,7 @@
 
 #include "ppapi/proxy/media_stream_audio_track_resource.h"
 
-#include "ppapi/proxy/audio_frame_resource.h"
+#include "ppapi/proxy/audio_buffer_resource.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/var.h"
 
@@ -18,7 +18,7 @@ MediaStreamAudioTrackResource::MediaStreamAudioTrackResource(
     const std::string& id)
     : MediaStreamTrackResourceBase(
         connection, instance, pending_renderer_id, id),
-      get_frame_output_(NULL) {
+      get_buffer_output_(NULL) {
 }
 
 MediaStreamAudioTrackResource::~MediaStreamAudioTrackResource() {
@@ -52,42 +52,42 @@ int32_t MediaStreamAudioTrackResource::GetAttrib(
   return PP_ERROR_NOTSUPPORTED;
 }
 
-int32_t MediaStreamAudioTrackResource::GetFrame(
-    PP_Resource* frame,
+int32_t MediaStreamAudioTrackResource::GetBuffer(
+    PP_Resource* buffer,
     scoped_refptr<TrackedCallback> callback) {
   if (has_ended())
     return PP_ERROR_FAILED;
 
-  if (TrackedCallback::IsPending(get_frame_callback_))
+  if (TrackedCallback::IsPending(get_buffer_callback_))
     return PP_ERROR_INPROGRESS;
 
-  *frame = GetAudioFrame();
-  if (*frame)
+  *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 frames to the target thread directly
+  // use the resource, so we could deliver buffers to the target thread directly
   // for better performance.
-  get_frame_output_ = frame;
-  get_frame_callback_ = callback;
+  get_buffer_output_ = buffer;
+  get_buffer_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t MediaStreamAudioTrackResource::RecycleFrame(PP_Resource frame) {
-  FrameMap::iterator it = frames_.find(frame);
-  if (it == frames_.end())
+int32_t MediaStreamAudioTrackResource::RecycleBuffer(PP_Resource buffer) {
+  BufferMap::iterator it = buffers_.find(buffer);
+  if (it == buffers_.end())
     return PP_ERROR_BADRESOURCE;
 
-  scoped_refptr<AudioFrameResource> frame_resource = it->second;
-  frames_.erase(it);
+  scoped_refptr<AudioBufferResource> buffer_resource = it->second;
+  buffers_.erase(it);
 
   if (has_ended())
     return PP_OK;
 
-  DCHECK_GE(frame_resource->GetBufferIndex(), 0);
+  DCHECK_GE(buffer_resource->GetBufferIndex(), 0);
 
-  SendEnqueueBufferMessageToHost(frame_resource->GetBufferIndex());
-  frame_resource->Invalidate();
+  SendEnqueueBufferMessageToHost(buffer_resource->GetBufferIndex());
+  buffer_resource->Invalidate();
   return PP_OK;
 }
 
@@ -95,50 +95,50 @@ void MediaStreamAudioTrackResource::Close() {
   if (has_ended())
     return;
 
-  if (TrackedCallback::IsPending(get_frame_callback_)) {
-    *get_frame_output_ = 0;
-    get_frame_callback_->PostAbort();
-    get_frame_callback_ = NULL;
-    get_frame_output_ = 0;
+  if (TrackedCallback::IsPending(get_buffer_callback_)) {
+    *get_buffer_output_ = 0;
+    get_buffer_callback_->PostAbort();
+    get_buffer_callback_ = NULL;
+    get_buffer_output_ = 0;
   }
 
-  ReleaseFrames();
+  ReleaseBuffers();
   MediaStreamTrackResourceBase::CloseInternal();
 }
 
 void MediaStreamAudioTrackResource::OnNewBufferEnqueued() {
-  if (!TrackedCallback::IsPending(get_frame_callback_))
+  if (!TrackedCallback::IsPending(get_buffer_callback_))
     return;
 
-  *get_frame_output_ = GetAudioFrame();
-  int32_t result = *get_frame_output_ ? PP_OK : PP_ERROR_FAILED;
-  get_frame_output_ = NULL;
+  *get_buffer_output_ = GetAudioBuffer();
+  int32_t result = *get_buffer_output_ ? PP_OK : PP_ERROR_FAILED;
+  get_buffer_output_ = NULL;
   scoped_refptr<TrackedCallback> callback;
-  callback.swap(get_frame_callback_);
+  callback.swap(get_buffer_callback_);
   callback->Run(result);
 }
 
-PP_Resource MediaStreamAudioTrackResource::GetAudioFrame() {
+PP_Resource MediaStreamAudioTrackResource::GetAudioBuffer() {
   int32_t index = buffer_manager()->DequeueBuffer();
   if (index < 0)
       return 0;
 
   MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index);
   DCHECK(buffer);
-  scoped_refptr<AudioFrameResource> resource =
-      new AudioFrameResource(pp_instance(), index, buffer);
-  // Add |pp_resource()| and |resource| into |frames_|.
-  // |frames_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the
+  scoped_refptr<AudioBufferResource> resource =
+      new AudioBufferResource(pp_instance(), index, buffer);
+  // Add |pp_resource()| and |resource| into |buffers_|.
+  // |buffers_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the
   // resource alive.
-  frames_.insert(FrameMap::value_type(resource->pp_resource(), resource));
+  buffers_.insert(BufferMap::value_type(resource->pp_resource(), resource));
   return resource->GetReference();
 }
 
-void MediaStreamAudioTrackResource::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()|.
+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;
   }
diff --git a/ppapi/proxy/media_stream_audio_track_resource.h b/ppapi/proxy/media_stream_audio_track_resource.h
index 8b9d9ec..694ae22 100644
--- a/ppapi/proxy/media_stream_audio_track_resource.h
+++ b/ppapi/proxy/media_stream_audio_track_resource.h
@@ -15,7 +15,7 @@
 namespace ppapi {
 namespace proxy {
 
-class AudioFrameResource;
+class AudioBufferResource;
 
 class PPAPI_PROXY_EXPORT MediaStreamAudioTrackResource
     : public MediaStreamTrackResourceBase,
@@ -39,27 +39,27 @@ class PPAPI_PROXY_EXPORT MediaStreamAudioTrackResource
                             scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t GetAttrib(PP_MediaStreamAudioTrack_Attrib attrib,
                             int32_t* value) OVERRIDE;
-  virtual int32_t GetFrame(
-      PP_Resource* frame,
+  virtual int32_t GetBuffer(
+      PP_Resource* buffer,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
-  virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE;
+  virtual int32_t RecycleBuffer(PP_Resource buffer) OVERRIDE;
   virtual void Close() OVERRIDE;
 
   // MediaStreamBufferManager::Delegate overrides:
   virtual void OnNewBufferEnqueued() OVERRIDE;
 
  private:
-  PP_Resource GetAudioFrame();
+  PP_Resource GetAudioBuffer();
 
-  void ReleaseFrames();
+  void ReleaseBuffers();
 
-  // Allocated frame resources by |GetFrame()|.
-  typedef std::map<PP_Resource, scoped_refptr<AudioFrameResource> > FrameMap;
-  FrameMap frames_;
+  // Allocated buffer resources by |GetBuffer()|.
+  typedef std::map<PP_Resource, scoped_refptr<AudioBufferResource> > BufferMap;
+  BufferMap buffers_;
 
-  PP_Resource* get_frame_output_;
+  PP_Resource* get_buffer_output_;
 
-  scoped_refptr<TrackedCallback> get_frame_callback_;
+  scoped_refptr<TrackedCallback> get_buffer_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamAudioTrackResource);
 };