[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.

This CL only changes the name in base classes. The API
interface will be changed in a separate CL.

BUG=330851

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

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

20 files changed, 309 insertions, 302 deletions

diff --git a/ppapi/examples/media_stream_video/media_stream_video.cc b/ppapi/examples/media_stream_video/media_stream_video.cc
index b23f3ed..3635e0e 100644
--- a/ppapi/examples/media_stream_video/media_stream_video.cc
+++ b/ppapi/examples/media_stream_video/media_stream_video.cc
@@ -342,7 +342,7 @@ void MediaStreamVideoDemoInstance::OnGetFrame(
     return;
   const char* data = static_cast<const char*>(frame.GetDataBuffer());
   pp::Size size;
-  PP_DCHECK(frame.GetSize(&size));
+  frame.GetSize(&size);
 
   if (size != frame_size_) {
     frame_size_ = size;
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi
index 43f5b71..580bf01 100644
--- a/ppapi/ppapi_shared.gypi
+++ b/ppapi/ppapi_shared.gypi
@@ -39,9 +39,9 @@
           'shared_impl/host_resource.h',
           'shared_impl/id_assignment.cc',
           'shared_impl/id_assignment.h',
-          'shared_impl/media_stream_frame.h',
-          'shared_impl/media_stream_frame_buffer.cc',
-          'shared_impl/media_stream_frame_buffer.h',
+          'shared_impl/media_stream_buffer.h',
+          'shared_impl/media_stream_buffer_manager.cc',
+          'shared_impl/media_stream_buffer_manager.h',
           'shared_impl/platform_file.cc',
           'shared_impl/platform_file.h',
           'shared_impl/ppapi_globals.cc',
diff --git a/ppapi/proxy/audio_frame_resource.cc b/ppapi/proxy/audio_frame_resource.cc
index 4954857..0827df7 100644
--- a/ppapi/proxy/audio_frame_resource.cc
+++ b/ppapi/proxy/audio_frame_resource.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "ppapi/c/pp_bool.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
@@ -13,15 +14,15 @@ namespace proxy {
 
 AudioFrameResource::AudioFrameResource(PP_Instance instance,
                                        int32_t index,
-                                       MediaStreamFrame* frame)
+                                       MediaStreamBuffer* buffer)
     : Resource(OBJECT_IS_PROXY, instance),
       index_(index),
-      frame_(frame) {
-  DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_AUDIO);
+      buffer_(buffer) {
+  DCHECK_EQ(buffer_->header.type, MediaStreamBuffer::TYPE_AUDIO);
 }
 
 AudioFrameResource::~AudioFrameResource() {
-  CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed.";
+  CHECK(!buffer_) << "An unused (or unrecycled) frame is destroyed.";
 }
 
 thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() {
@@ -29,81 +30,81 @@ thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() {
 }
 
 PP_TimeDelta AudioFrameResource::GetTimestamp() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return 0.0;
   }
-  return frame_->audio.timestamp;
+  return buffer_->audio.timestamp;
 }
 
 void AudioFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return;
   }
-  frame_->audio.timestamp = timestamp;
+  buffer_->audio.timestamp = timestamp;
 }
 
 PP_AudioFrame_SampleRate AudioFrameResource::GetSampleRate() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return PP_AUDIOFRAME_SAMPLERATE_UNKNOWN;
   }
-  return frame_->audio.sample_rate;
+  return buffer_->audio.sample_rate;
 }
 
 PP_AudioFrame_SampleSize AudioFrameResource::GetSampleSize() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return PP_AUDIOFRAME_SAMPLESIZE_UNKNOWN;
   }
   return PP_AUDIOFRAME_SAMPLESIZE_16_BITS;
 }
 
 uint32_t AudioFrameResource::GetNumberOfChannels() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return 0;
   }
-  return frame_->audio.number_of_channels;
+  return buffer_->audio.number_of_channels;
 }
 
 uint32_t AudioFrameResource::GetNumberOfSamples() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return 0;
   }
-  return frame_->audio.number_of_samples;
+  return buffer_->audio.number_of_samples;
 }
 
 void* AudioFrameResource::GetDataBuffer() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return NULL;
   }
-  return frame_->audio.data;
+  return buffer_->audio.data;
 }
 
 uint32_t AudioFrameResource::GetDataBufferSize() {
-  if (!frame_) {
-    VLOG(1) << "Frame is invalid";
+  if (!buffer_) {
+    VLOG(1) << "Buffer is invalid";
     return 0;
   }
-  return frame_->audio.data_size;
+  return buffer_->audio.data_size;
 }
 
-MediaStreamFrame* AudioFrameResource::GetFrameBuffer() {
-  return frame_;
+MediaStreamBuffer* AudioFrameResource::GetBuffer() {
+  return buffer_;
 }
 
-int32_t AudioFrameResource::GetFrameBufferIndex() {
+int32_t AudioFrameResource::GetBufferIndex() {
   return index_;
 }
 
 void AudioFrameResource::Invalidate() {
-  DCHECK(frame_);
+  DCHECK(buffer_);
   DCHECK_GE(index_, 0);
-  frame_ = NULL;
+  buffer_ = NULL;
   index_ = -1;
 }
 
diff --git a/ppapi/proxy/audio_frame_resource.h b/ppapi/proxy/audio_frame_resource.h
index a463bba..8332ec2 100644
--- a/ppapi/proxy/audio_frame_resource.h
+++ b/ppapi/proxy/audio_frame_resource.h
@@ -8,11 +8,13 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/ppb_audio_frame_api.h"
 
 namespace ppapi {
+
+union MediaStreamBuffer;
+
 namespace proxy {
 
 class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource,
@@ -20,7 +22,7 @@ class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource,
  public:
   AudioFrameResource(PP_Instance instance,
                      int32_t index,
-                     MediaStreamFrame* frame);
+                     MediaStreamBuffer* buffer);
 
   virtual ~AudioFrameResource();
 
@@ -36,14 +38,14 @@ class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource,
   virtual uint32_t GetNumberOfSamples() OVERRIDE;
   virtual void* GetDataBuffer() OVERRIDE;
   virtual uint32_t GetDataBufferSize() OVERRIDE;
-  virtual MediaStreamFrame* GetFrameBuffer();
-  virtual int32_t GetFrameBufferIndex();
-  virtual void Invalidate();
+  virtual MediaStreamBuffer* GetBuffer() OVERRIDE;
+  virtual int32_t GetBufferIndex() OVERRIDE;
+  virtual void Invalidate() OVERRIDE;
 
   // Frame index
   int32_t index_;
 
-  MediaStreamFrame* frame_;
+  MediaStreamBuffer* buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFrameResource);
 };
diff --git a/ppapi/proxy/media_stream_audio_track_resource.cc b/ppapi/proxy/media_stream_audio_track_resource.cc
index 10956ab..951bda8 100644
--- a/ppapi/proxy/media_stream_audio_track_resource.cc
+++ b/ppapi/proxy/media_stream_audio_track_resource.cc
@@ -5,7 +5,7 @@
 #include "ppapi/proxy/media_stream_audio_track_resource.h"
 
 #include "ppapi/proxy/audio_frame_resource.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
@@ -84,9 +84,9 @@ int32_t MediaStreamAudioTrackResource::RecycleFrame(PP_Resource frame) {
   if (has_ended())
     return PP_OK;
 
-  DCHECK_GE(frame_resource->GetFrameBufferIndex(), 0);
+  DCHECK_GE(frame_resource->GetBufferIndex(), 0);
 
-  SendEnqueueFrameMessageToHost(frame_resource->GetFrameBufferIndex());
+  SendEnqueueBufferMessageToHost(frame_resource->GetBufferIndex());
   frame_resource->Invalidate();
   return PP_OK;
 }
@@ -106,7 +106,7 @@ void MediaStreamAudioTrackResource::Close() {
   MediaStreamTrackResourceBase::CloseInternal();
 }
 
-void MediaStreamAudioTrackResource::OnNewFrameEnqueued() {
+void MediaStreamAudioTrackResource::OnNewBufferEnqueued() {
   if (!TrackedCallback::IsPending(get_frame_callback_))
     return;
 
@@ -119,14 +119,14 @@ void MediaStreamAudioTrackResource::OnNewFrameEnqueued() {
 }
 
 PP_Resource MediaStreamAudioTrackResource::GetAudioFrame() {
-  int32_t index = frame_buffer()->DequeueFrame();
+  int32_t index = buffer_manager()->DequeueBuffer();
   if (index < 0)
       return 0;
 
-  MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index);
-  DCHECK(frame);
+  MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index);
+  DCHECK(buffer);
   scoped_refptr<AudioFrameResource> resource =
-      new AudioFrameResource(pp_instance(), index, frame);
+      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
   // resource alive.
diff --git a/ppapi/proxy/media_stream_audio_track_resource.h b/ppapi/proxy/media_stream_audio_track_resource.h
index 2686381..8b9d9ec 100644
--- a/ppapi/proxy/media_stream_audio_track_resource.h
+++ b/ppapi/proxy/media_stream_audio_track_resource.h
@@ -45,8 +45,8 @@ class PPAPI_PROXY_EXPORT MediaStreamAudioTrackResource
   virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE;
   virtual void Close() OVERRIDE;
 
-  // MediaStreamFrameBuffer::Delegate overrides:
-  virtual void OnNewFrameEnqueued() OVERRIDE;
+  // MediaStreamBufferManager::Delegate overrides:
+  virtual void OnNewBufferEnqueued() OVERRIDE;
 
  private:
   PP_Resource GetAudioFrame();
diff --git a/ppapi/proxy/media_stream_track_resource_base.cc b/ppapi/proxy/media_stream_track_resource_base.cc
index 73aa470..d259036 100644
--- a/ppapi/proxy/media_stream_track_resource_base.cc
+++ b/ppapi/proxy/media_stream_track_resource_base.cc
@@ -16,7 +16,7 @@ MediaStreamTrackResourceBase::MediaStreamTrackResourceBase(
     int pending_renderer_id,
     const std::string& id)
     : PluginResource(connection, instance),
-      frame_buffer_(this),
+      buffer_manager_(this),
       id_(id),
       has_ended_(false) {
   AttachToPendingHost(RENDERER, pending_renderer_id);
@@ -25,11 +25,11 @@ MediaStreamTrackResourceBase::MediaStreamTrackResourceBase(
 MediaStreamTrackResourceBase::~MediaStreamTrackResourceBase() {
 }
 
-void MediaStreamTrackResourceBase::SendEnqueueFrameMessageToHost(
+void MediaStreamTrackResourceBase::SendEnqueueBufferMessageToHost(
     int32_t index) {
   DCHECK_GE(index, 0);
-  DCHECK_LT(index, frame_buffer()->number_of_frames());
-  Post(RENDERER, PpapiHostMsg_MediaStreamTrack_EnqueueFrame(index));
+  DCHECK_LT(index, buffer_manager()->number_of_buffers());
+  Post(RENDERER, PpapiHostMsg_MediaStreamTrack_EnqueueBuffer(index));
 }
 
 void MediaStreamTrackResourceBase::OnReplyReceived(
@@ -37,9 +37,9 @@ void MediaStreamTrackResourceBase::OnReplyReceived(
     const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(MediaStreamTrackResourceBase, msg)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
-        PpapiPluginMsg_MediaStreamTrack_InitFrames, OnPluginMsgInitFrames)
+        PpapiPluginMsg_MediaStreamTrack_InitBuffers, OnPluginMsgInitBuffers)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
-        PpapiPluginMsg_MediaStreamTrack_EnqueueFrame, OnPluginMsgEnqueueFrame)
+        PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer, OnPluginMsgEnqueueBuffer)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
         PluginResource::OnReplyReceived(params, msg))
   IPC_END_MESSAGE_MAP()
@@ -52,21 +52,21 @@ void MediaStreamTrackResourceBase::CloseInternal() {
   }
 }
 
-void MediaStreamTrackResourceBase::OnPluginMsgInitFrames(
+void MediaStreamTrackResourceBase::OnPluginMsgInitBuffers(
     const ResourceMessageReplyParams& params,
-    int32_t number_of_frames,
-    int32_t frame_size) {
+    int32_t number_of_buffers,
+    int32_t buffer_size) {
   base::SharedMemoryHandle shm_handle = base::SharedMemory::NULLHandle();
   params.TakeSharedMemoryHandleAtIndex(0, &shm_handle);
-  frame_buffer_.SetFrames(number_of_frames, frame_size,
+  buffer_manager_.SetBuffers(number_of_buffers, buffer_size,
       scoped_ptr<base::SharedMemory>(new base::SharedMemory(shm_handle, true)),
       false);
 }
 
-void MediaStreamTrackResourceBase::OnPluginMsgEnqueueFrame(
+void MediaStreamTrackResourceBase::OnPluginMsgEnqueueBuffer(
     const ResourceMessageReplyParams& params,
     int32_t index) {
-  frame_buffer_.EnqueueFrame(index);
+  buffer_manager_.EnqueueBuffer(index);
 }
 
 }  // namespace proxy
diff --git a/ppapi/proxy/media_stream_track_resource_base.h b/ppapi/proxy/media_stream_track_resource_base.h
index 4a4aa3b..b5438ce 100644
--- a/ppapi/proxy/media_stream_track_resource_base.h
+++ b/ppapi/proxy/media_stream_track_resource_base.h
@@ -7,14 +7,14 @@
 
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
-#include "ppapi/shared_impl/media_stream_frame_buffer.h"
+#include "ppapi/shared_impl/media_stream_buffer_manager.h"
 
 namespace ppapi {
 namespace proxy {
 
 class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase
   : public PluginResource,
-    public MediaStreamFrameBuffer::Delegate {
+    public MediaStreamBufferManager::Delegate {
  protected:
   MediaStreamTrackResourceBase(Connection connection,
                                PP_Instance instance,
@@ -27,14 +27,15 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase
 
   bool has_ended() const { return has_ended_; }
 
-  MediaStreamFrameBuffer* frame_buffer() { return &frame_buffer_; }
+  MediaStreamBufferManager* buffer_manager() { return &buffer_manager_; }
 
   void CloseInternal();
 
-  // Sends a frame index to the corresponding PepperMediaStreamTrackHostBase
-  // via an IPC message. The host adds the frame index into its
-  // |frame_buffer_| for reading or writing. Also see |MediaStreamFrameBuffer|.
-  void SendEnqueueFrameMessageToHost(int32_t index);
+  // Sends a buffer index to the corresponding PepperMediaStreamTrackHostBase
+  // via an IPC message. The host adds the buffer index into its
+  // |buffer_manager_| for reading or writing.
+  // Also see |MediaStreamBufferManager|.
+  void SendEnqueueBufferMessageToHost(int32_t index);
 
   // PluginResource overrides:
   virtual void OnReplyReceived(const ResourceMessageReplyParams& params,
@@ -42,13 +43,13 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase
 
  private:
   // Message handlers:
-  void OnPluginMsgInitFrames(const ResourceMessageReplyParams& params,
-                             int32_t number_of_frames,
-                             int32_t frame_size);
-  void OnPluginMsgEnqueueFrame(const ResourceMessageReplyParams& params,
-                               int32_t index);
+  void OnPluginMsgInitBuffers(const ResourceMessageReplyParams& params,
+                              int32_t number_of_buffers,
+                              int32_t buffer_size);
+  void OnPluginMsgEnqueueBuffer(const ResourceMessageReplyParams& params,
+                                int32_t index);
 
-  MediaStreamFrameBuffer frame_buffer_;
+  MediaStreamBufferManager buffer_manager_;
 
   std::string id_;
 
diff --git a/ppapi/proxy/media_stream_video_track_resource.cc b/ppapi/proxy/media_stream_video_track_resource.cc
index 804df00..451f259 100644
--- a/ppapi/proxy/media_stream_video_track_resource.cc
+++ b/ppapi/proxy/media_stream_video_track_resource.cc
@@ -6,7 +6,7 @@
 
 #include "base/logging.h"
 #include "ppapi/proxy/video_frame_resource.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
@@ -84,9 +84,9 @@ int32_t MediaStreamVideoTrackResource::RecycleFrame(PP_Resource frame) {
   if (has_ended())
     return PP_OK;
 
-  DCHECK_GE(frame_resource->GetFrameBufferIndex(), 0);
+  DCHECK_GE(frame_resource->GetBufferIndex(), 0);
 
-  SendEnqueueFrameMessageToHost(frame_resource->GetFrameBufferIndex());
+  SendEnqueueBufferMessageToHost(frame_resource->GetBufferIndex());
   frame_resource->Invalidate();
   return PP_OK;
 }
@@ -106,7 +106,7 @@ void MediaStreamVideoTrackResource::Close() {
   MediaStreamTrackResourceBase::CloseInternal();
 }
 
-void MediaStreamVideoTrackResource::OnNewFrameEnqueued() {
+void MediaStreamVideoTrackResource::OnNewBufferEnqueued() {
   if (!TrackedCallback::IsPending(get_frame_callback_))
     return;
 
@@ -119,14 +119,14 @@ void MediaStreamVideoTrackResource::OnNewFrameEnqueued() {
 }
 
 PP_Resource MediaStreamVideoTrackResource::GetVideoFrame() {
-  int32_t index = frame_buffer()->DequeueFrame();
+  int32_t index = buffer_manager()->DequeueBuffer();
   if (index < 0)
     return 0;
 
-  MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index);
-  DCHECK(frame);
+  MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index);
+  DCHECK(buffer);
   scoped_refptr<VideoFrameResource> resource =
-      new VideoFrameResource(pp_instance(), index, frame);
+      new VideoFrameResource(pp_instance(), index, buffer);
   // Add |pp_resource()| and |resource| into |frames_|.
   // |frames_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the
   // resource alive.
diff --git a/ppapi/proxy/media_stream_video_track_resource.h b/ppapi/proxy/media_stream_video_track_resource.h
index 935a8a9..ee301d2 100644
--- a/ppapi/proxy/media_stream_video_track_resource.h
+++ b/ppapi/proxy/media_stream_video_track_resource.h
@@ -44,8 +44,8 @@ class PPAPI_PROXY_EXPORT MediaStreamVideoTrackResource
   virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE;
   virtual void Close() OVERRIDE;
 
-  // MediaStreamFrameBuffer::Delegate overrides:
-  virtual void OnNewFrameEnqueued() OVERRIDE;
+  // MediaStreamBufferManager::Delegate overrides:
+  virtual void OnNewBufferEnqueued() OVERRIDE;
 
  private:
   PP_Resource GetVideoFrame();
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 04148f6..d750f9c 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -1442,14 +1442,14 @@ IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamAudioTrack_CreateFromPendingHost,
 IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamVideoTrack_CreateFromPendingHost,
                      std::string /* track_id */)
 
-// Message for init frames. It also takes a shared memory handle which is put in
-// the outer ResourceReplyMessage.
-IPC_MESSAGE_CONTROL2(PpapiPluginMsg_MediaStreamTrack_InitFrames,
-                     int32_t /* number_of_frames */,
-                     int32_t /* frame_size */)
-IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueFrame,
+// Message for init buffers. It also takes a shared memory handle which is put
+// in the outer ResourceReplyMessage.
+IPC_MESSAGE_CONTROL2(PpapiPluginMsg_MediaStreamTrack_InitBuffers,
+                     int32_t /* number_of_buffers */,
+                     int32_t /* buffer_size */)
+IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer,
                      int32_t /* index */);
-IPC_MESSAGE_CONTROL1(PpapiHostMsg_MediaStreamTrack_EnqueueFrame,
+IPC_MESSAGE_CONTROL1(PpapiHostMsg_MediaStreamTrack_EnqueueBuffer,
                      int32_t /* index */);
 IPC_MESSAGE_CONTROL0(PpapiHostMsg_MediaStreamTrack_Close)
 
diff --git a/ppapi/proxy/video_frame_resource.cc b/ppapi/proxy/video_frame_resource.cc
index b314838..9414712 100644
--- a/ppapi/proxy/video_frame_resource.cc
+++ b/ppapi/proxy/video_frame_resource.cc
@@ -13,15 +13,15 @@ namespace proxy {
 
 VideoFrameResource::VideoFrameResource(PP_Instance instance,
                                        int32_t index,
-                                       MediaStreamFrame* frame)
+                                       MediaStreamBuffer* buffer)
     : Resource(OBJECT_IS_PROXY, instance),
       index_(index),
-      frame_(frame) {
-  DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_VIDEO);
+      buffer_(buffer) {
+  DCHECK_EQ(buffer_->header.type, MediaStreamBuffer::TYPE_VIDEO);
 }
 
 VideoFrameResource::~VideoFrameResource() {
-  CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed.";
+  CHECK(!buffer_) << "An unused (or unrecycled) frame is destroyed.";
 }
 
 thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() {
@@ -29,66 +29,66 @@ thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() {
 }
 
 PP_TimeDelta VideoFrameResource::GetTimestamp() {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return 0.0;
   }
-  return frame_->video.timestamp;
+  return buffer_->video.timestamp;
 }
 
 void VideoFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return;
   }
-  frame_->video.timestamp = timestamp;
+  buffer_->video.timestamp = timestamp;
 }
 
 PP_VideoFrame_Format VideoFrameResource::GetFormat() {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return PP_VIDEOFRAME_FORMAT_UNKNOWN;
   }
-  return frame_->video.format;
+  return buffer_->video.format;
 }
 
 PP_Bool VideoFrameResource::GetSize(PP_Size* size) {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return PP_FALSE;
   }
-  *size = frame_->video.size;
+  *size = buffer_->video.size;
   return PP_TRUE;
 }
 
 void* VideoFrameResource::GetDataBuffer() {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return NULL;
   }
-  return frame_->video.data;
+  return buffer_->video.data;
 }
 
 uint32_t VideoFrameResource::GetDataBufferSize() {
-  if (!frame_) {
+  if (!buffer_) {
     VLOG(1) << "Frame is invalid";
     return 0;
   }
-  return frame_->video.data_size;
+  return buffer_->video.data_size;
 }
 
-MediaStreamFrame* VideoFrameResource::GetFrameBuffer() {
-  return frame_;
+MediaStreamBuffer* VideoFrameResource::GetBuffer() {
+  return buffer_;
 }
 
-int32_t VideoFrameResource::GetFrameBufferIndex() {
+int32_t VideoFrameResource::GetBufferIndex() {
   return index_;
 }
 
 void VideoFrameResource::Invalidate() {
-  DCHECK(frame_);
+  DCHECK(buffer_);
   DCHECK_GE(index_, 0);
-  frame_ = NULL;
+  buffer_ = NULL;
   index_ = -1;
 }
 
diff --git a/ppapi/proxy/video_frame_resource.h b/ppapi/proxy/video_frame_resource.h
index ba92f4d..92ac08e 100644
--- a/ppapi/proxy/video_frame_resource.h
+++ b/ppapi/proxy/video_frame_resource.h
@@ -8,7 +8,7 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/ppb_video_frame_api.h"
 
@@ -20,7 +20,7 @@ class PPAPI_PROXY_EXPORT VideoFrameResource : public Resource,
  public:
   VideoFrameResource(PP_Instance instance,
                      int32_t index,
-                     MediaStreamFrame* frame);
+                     MediaStreamBuffer* buffer);
 
   virtual ~VideoFrameResource();
 
@@ -34,14 +34,14 @@ class PPAPI_PROXY_EXPORT VideoFrameResource : public Resource,
   virtual PP_Bool GetSize(PP_Size* size) OVERRIDE;
   virtual void* GetDataBuffer() OVERRIDE;
   virtual uint32_t GetDataBufferSize() OVERRIDE;
-  virtual MediaStreamFrame* GetFrameBuffer();
-  virtual int32_t GetFrameBufferIndex();
-  virtual void Invalidate();
+  virtual MediaStreamBuffer* GetBuffer() OVERRIDE;
+  virtual int32_t GetBufferIndex() OVERRIDE;
+  virtual void Invalidate() OVERRIDE;
 
   // Frame index
   int32_t index_;
 
-  MediaStreamFrame* frame_;
+  MediaStreamBuffer* buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameResource);
 };
diff --git a/ppapi/shared_impl/media_stream_frame.h b/ppapi/shared_impl/media_stream_buffer.h
index 72eeef9..9010403 100644
--- a/ppapi/shared_impl/media_stream_frame.h
+++ b/ppapi/shared_impl/media_stream_buffer.h
@@ -2,15 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_
-#define PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_
+#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_
+#define PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_
 
 #include "ppapi/c/ppb_audio_frame.h"
 #include "ppapi/c/ppb_video_frame.h"
 
 namespace ppapi {
 
-union MediaStreamFrame {
+union MediaStreamBuffer {
   enum Type {
     TYPE_UNKNOWN = 0,
     TYPE_AUDIO = 1,
@@ -59,4 +59,4 @@ union MediaStreamFrame {
 
 }  // namespace ppapi
 
-#endif  // PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_
+#endif  // PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_
diff --git a/ppapi/shared_impl/media_stream_buffer_manager.cc b/ppapi/shared_impl/media_stream_buffer_manager.cc
new file mode 100644
index 0000000..b0588d6d
--- /dev/null
+++ b/ppapi/shared_impl/media_stream_buffer_manager.cc
@@ -0,0 +1,80 @@
+// 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/shared_impl/media_stream_buffer_manager.h"
+
+#include "base/logging.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
+
+namespace ppapi {
+
+MediaStreamBufferManager::Delegate::~Delegate() {}
+
+void MediaStreamBufferManager::Delegate::OnNewBufferEnqueued() {
+}
+
+MediaStreamBufferManager::MediaStreamBufferManager(Delegate* delegate)
+   : delegate_(delegate),
+     buffer_size_(0),
+     number_of_buffers_(0) {
+  DCHECK(delegate_);
+}
+
+MediaStreamBufferManager::~MediaStreamBufferManager() {
+}
+
+bool MediaStreamBufferManager::SetBuffers(
+    int32_t number_of_buffers,
+    int32_t buffer_size,
+    scoped_ptr<base::SharedMemory> shm,
+    bool enqueue_all_buffers) {
+  DCHECK(shm);
+  DCHECK(!shm_);
+  DCHECK_GT(number_of_buffers, 0);
+  DCHECK_GT(buffer_size,
+            static_cast<int32_t>(sizeof(MediaStreamBuffer::Header)));
+  DCHECK_EQ(buffer_size & 0x3, 0);
+
+  number_of_buffers_ = number_of_buffers;
+  buffer_size_ = buffer_size;
+
+  int32_t size = number_of_buffers_ * buffer_size;
+  shm_ = shm.Pass();
+  if (!shm_->Map(size))
+    return false;
+
+  uint8_t* p = reinterpret_cast<uint8_t*>(shm_->memory());
+  for (int32_t i = 0; i < number_of_buffers; ++i) {
+    if (enqueue_all_buffers)
+      buffer_queue_.push_back(i);
+    buffers_.push_back(reinterpret_cast<MediaStreamBuffer*>(p));
+    p += buffer_size_;
+  }
+  return true;
+}
+
+int32_t MediaStreamBufferManager::DequeueBuffer() {
+  if (buffer_queue_.empty())
+    return PP_ERROR_FAILED;
+  int32_t buffer = buffer_queue_.front();
+  buffer_queue_.pop_front();
+  return buffer;
+}
+
+void MediaStreamBufferManager::EnqueueBuffer(int32_t index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, number_of_buffers_);
+  buffer_queue_.push_back(index);
+  delegate_->OnNewBufferEnqueued();
+}
+
+MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer(
+    int32_t index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, number_of_buffers_);
+  return buffers_[index];
+}
+
+}  // namespace ppapi
diff --git a/ppapi/shared_impl/media_stream_buffer_manager.h b/ppapi/shared_impl/media_stream_buffer_manager.h
new file mode 100644
index 0000000..b59d027
--- /dev/null
+++ b/ppapi/shared_impl/media_stream_buffer_manager.h
@@ -0,0 +1,94 @@
+// 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.
+
+#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_
+#define PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_
+
+#include <deque>
+#include <vector>
+
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/shared_memory.h"
+#include "ppapi/shared_impl/ppapi_shared_export.h"
+
+namespace ppapi {
+
+union MediaStreamBuffer;
+
+// This class is used by both read side and write side of a MediaStreamTrack to
+// maintain a queue of buffers for reading or writing.
+//
+// An example:
+//  1. The writer calls the writer's |buffer_manager_.Dequeue()| to get a free
+//     buffer.
+//  2. The writer fills data into the buffer.
+//  3. The writer sends the buffer index to the reader via an IPC message.
+//  4. The reader receives the buffer index and calls the reader's
+//     |buffer_buffer.Enqueue()| to put the buffer into the read's queue.
+//  5. The reader calls reader's |buffer_buffer_.Dequeue()| to get a received
+//     buffer.
+//  6. When the buffer from the step 5 is consumed, the reader sends the buffer
+//     index back to writer via an IPC message.
+//  7. The writer receives the buffer index and puts it back to the writer's
+//     free buffer queue by calling the writer's |buffer_manager_.Enqueue()|.
+//  8. Go back to step 1.
+class PPAPI_SHARED_EXPORT MediaStreamBufferManager {
+ public:
+  class PPAPI_SHARED_EXPORT Delegate {
+   public:
+    virtual ~Delegate();
+    // It is called when a new buffer is enqueued.
+    virtual void OnNewBufferEnqueued();
+  };
+
+  // MediaStreamBufferManager doesn't own |delegate|, the caller should keep
+  // it alive during the MediaStreamBufferManager's lifecycle.
+  explicit MediaStreamBufferManager(Delegate* delegate);
+
+  ~MediaStreamBufferManager();
+
+  int32_t number_of_buffers() const { return number_of_buffers_; }
+
+  int32_t buffer_size() const { return buffer_size_; }
+
+  // Initializes shared memory for buffers transmission.
+  bool SetBuffers(int32_t number_of_buffers,
+                 int32_t buffer_size,
+                 scoped_ptr<base::SharedMemory> shm,
+                 bool enqueue_all_buffers);
+
+  // Dequeues a buffer from |buffer_queue_|.
+  int32_t DequeueBuffer();
+
+  // Puts a buffer into |buffer_queue_|.
+  void EnqueueBuffer(int32_t index);
+
+  // Gets the buffer address for the given buffer index.
+  MediaStreamBuffer* GetBufferPointer(int32_t index);
+
+ private:
+  Delegate* delegate_;
+
+  // A queue of buffer indices.
+  std::deque<int32_t> buffer_queue_;
+
+  // A vector of buffer pointers. It is used for index to pointer converting.
+  std::vector<MediaStreamBuffer*> buffers_;
+
+  // The buffer size in bytes.
+  int32_t buffer_size_;
+
+  // The number of buffers in the shared memory.
+  int32_t number_of_buffers_;
+
+  // A memory block shared between renderer process and plugin process.
+  scoped_ptr<base::SharedMemory> shm_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaStreamBufferManager);
+};
+
+}  // namespace ppapi
+
+#endif  // PPAPI_SHAERD_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_
diff --git a/ppapi/shared_impl/media_stream_frame_buffer.cc b/ppapi/shared_impl/media_stream_frame_buffer.cc
deleted file mode 100644
index 6248830..0000000
--- a/ppapi/shared_impl/media_stream_frame_buffer.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-// 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/shared_impl/media_stream_frame_buffer.h"
-
-#include "base/logging.h"
-#include "ppapi/c/pp_errors.h"
-
-namespace ppapi {
-
-MediaStreamFrameBuffer::Delegate::~Delegate() {}
-
-void MediaStreamFrameBuffer::Delegate::OnNewFrameEnqueued() {
-}
-
-MediaStreamFrameBuffer::MediaStreamFrameBuffer(Delegate* delegate)
-   : delegate_(delegate),
-     frame_size_(0),
-     number_of_frames_(0) {
-  DCHECK(delegate_);
-}
-
-MediaStreamFrameBuffer::~MediaStreamFrameBuffer() {
-}
-
-bool MediaStreamFrameBuffer::SetFrames(
-    int32_t number_of_frames,
-    int32_t frame_size,
-    scoped_ptr<base::SharedMemory> shm,
-    bool enqueue_all_frames) {
-  DCHECK(shm);
-  DCHECK(!shm_);
-  DCHECK_GT(number_of_frames, 0);
-  DCHECK_GT(frame_size, static_cast<int32_t>(sizeof(MediaStreamFrame::Header)));
-  DCHECK_EQ(frame_size & 0x3, 0);
-
-  number_of_frames_ = number_of_frames;
-  frame_size_ = frame_size;
-
-  int32_t size = number_of_frames_ * frame_size;
-  shm_ = shm.Pass();
-  if (!shm_->Map(size))
-    return false;
-
-  uint8_t* p = reinterpret_cast<uint8_t*>(shm_->memory());
-  for (int32_t i = 0; i < number_of_frames; ++i) {
-    if (enqueue_all_frames)
-      frame_queue_.push_back(i);
-    frames_.push_back(reinterpret_cast<MediaStreamFrame*>(p));
-    p += frame_size_;
-  }
-  return true;
-}
-
-int32_t MediaStreamFrameBuffer::DequeueFrame() {
-  if (frame_queue_.empty())
-    return PP_ERROR_FAILED;
-  int32_t frame = frame_queue_.front();
-  frame_queue_.pop_front();
-  return frame;
-}
-
-void MediaStreamFrameBuffer::EnqueueFrame(int32_t index) {
-  DCHECK_GE(index, 0);
-  DCHECK_LT(index, number_of_frames_);
-  frame_queue_.push_back(index);
-  delegate_->OnNewFrameEnqueued();
-}
-
-MediaStreamFrame* MediaStreamFrameBuffer::GetFramePointer(
-    int32_t index) {
-  DCHECK_GE(index, 0);
-  DCHECK_LT(index, number_of_frames_);
-  return frames_[index];
-}
-
-}  // namespace ppapi
diff --git a/ppapi/shared_impl/media_stream_frame_buffer.h b/ppapi/shared_impl/media_stream_frame_buffer.h
deleted file mode 100644
index e950846..0000000
--- a/ppapi/shared_impl/media_stream_frame_buffer.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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.
-
-#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_
-#define PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_
-
-#include <deque>
-#include <vector>
-
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/shared_memory.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
-#include "ppapi/shared_impl/ppapi_shared_export.h"
-
-namespace ppapi {
-
-// This class is used by both read side and write side of a MediaStreamTrack to
-// maintain a queue of frames for reading or writing.
-//
-// An example:
-//  1. The writer calls the writer's |frame_buffer_.Dequeue()| to get a free
-//     frame.
-//  2. The writer fills data into the frame.
-//  3. The writer sends the frame index to the reader via an IPC message.
-//  4. The reader receives the frame index and calls the reader's
-//     |frame_buffer.Enqueue()| to put the frame into the read's queue.
-//  5. The reader calls reader's |frame_buffer_.Dequeue()| to get a received
-//     frame.
-//  6. When the frame from the step 5 is consumed, the reader sends the frame
-//     index back to writer via an IPC message.
-//  7. The writer receives the frame index and puts it back to the writer's free
-//     frame queue by calling the writer's |frame_buffer_.Enqueue()|.
-//  8. Go back to step 1.
-class PPAPI_SHARED_EXPORT MediaStreamFrameBuffer {
- public:
-  class PPAPI_SHARED_EXPORT Delegate {
-   public:
-    virtual ~Delegate();
-    // It is called when a new frame is enqueued.
-    virtual void OnNewFrameEnqueued();
-  };
-
-  // MediaStreamFrameBuffer doesn't own |delegate|, the caller should keep
-  // it alive during the MediaStreamFrameBuffer's lifecycle.
-  explicit MediaStreamFrameBuffer(Delegate* delegate);
-
-  ~MediaStreamFrameBuffer();
-
-  int32_t number_of_frames() const { return number_of_frames_; }
-
-  int32_t frame_size() const { return frame_size_; }
-
-  // Initializes shared memory for frames transmission.
-  bool SetFrames(int32_t number_of_frames,
-                 int32_t frame_size,
-                 scoped_ptr<base::SharedMemory> shm,
-                 bool enqueue_all_frames);
-
-  // Dequeues a frame from |frame_queue_|.
-  int32_t DequeueFrame();
-
-  // Puts a frame into |frame_queue_|.
-  void EnqueueFrame(int32_t index);
-
-  // Gets the frame address for the given frame index.
-  MediaStreamFrame* GetFramePointer(int32_t index);
-
- private:
-  Delegate* delegate_;
-
-  // A queue of frame indexes.
-  std::deque<int32_t> frame_queue_;
-
-  // A vector of frame pointers. It is used for index to pointer converting.
-  std::vector<MediaStreamFrame*> frames_;
-
-  // The frame size in bytes.
-  int32_t frame_size_;
-
-  // The number of frames in the shared memory.
-  int32_t number_of_frames_;
-
-  // A memory block shared between renderer process and plugin process.
-  scoped_ptr<base::SharedMemory> shm_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaStreamFrameBuffer);
-};
-
-}  // namespace ppapi
-
-#endif  // PPAPI_SHAERD_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_
diff --git a/ppapi/thunk/ppb_audio_frame_api.h b/ppapi/thunk/ppb_audio_frame_api.h
index ca9cd1f..6d106c6 100644
--- a/ppapi/thunk/ppb_audio_frame_api.h
+++ b/ppapi/thunk/ppb_audio_frame_api.h
@@ -10,7 +10,7 @@
 
 namespace ppapi {
 
-union MediaStreamFrame;
+union MediaStreamBuffer;
 
 namespace thunk {
 
@@ -27,8 +27,8 @@ class PPAPI_THUNK_EXPORT PPB_AudioFrame_API {
   virtual uint32_t GetDataBufferSize() = 0;
 
   // Methods used by Pepper internal implementation only.
-  virtual MediaStreamFrame* GetFrameBuffer() = 0;
-  virtual int32_t GetFrameBufferIndex() = 0;
+  virtual MediaStreamBuffer* GetBuffer() = 0;
+  virtual int32_t GetBufferIndex() = 0;
   virtual void Invalidate() = 0;
 };
 
diff --git a/ppapi/thunk/ppb_video_frame_api.h b/ppapi/thunk/ppb_video_frame_api.h
index d3c46b8..105d72b 100644
--- a/ppapi/thunk/ppb_video_frame_api.h
+++ b/ppapi/thunk/ppb_video_frame_api.h
@@ -10,7 +10,7 @@
 
 namespace ppapi {
 
-union MediaStreamFrame;
+union MediaStreamBuffer;
 
 namespace thunk {
 
@@ -25,8 +25,8 @@ class PPAPI_THUNK_EXPORT PPB_VideoFrame_API {
   virtual uint32_t GetDataBufferSize() = 0;
 
   // Methods used by Pepper internal implementation only.
-  virtual MediaStreamFrame* GetFrameBuffer() = 0;
-  virtual int32_t GetFrameBufferIndex() = 0;
+  virtual MediaStreamBuffer* GetBuffer() = 0;
+  virtual int32_t GetBufferIndex() = 0;
   virtual void Invalidate() = 0;
 };