[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

25 files changed, 417 insertions, 402 deletions

diff --git a/content/renderer/pepper/pepper_media_stream_audio_track_host.cc b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc
index ed44466..7d0695b 100644
--- a/content/renderer/pepper/pepper_media_stream_audio_track_host.cc
+++ b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc
@@ -11,7 +11,7 @@
 #include "base/message_loop/message_loop_proxy.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio_frame.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 
 using media::AudioParameters;
 
@@ -21,7 +21,7 @@ namespace {
 const uint32_t kMaxDuration = 10;
 
 // TODO(penghuang): make this configurable.
-const int32_t kNumberOfFrames = 4;
+const int32_t kNumberOfBuffers = 4;
 
 }  // namespace
 
@@ -30,7 +30,7 @@ namespace content {
 PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
     PepperMediaStreamAudioTrackHost* host)
     : host_(host),
-      frame_data_size_(0),
+      buffer_data_size_(0),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
       weak_factory_(this) {
 }
@@ -39,33 +39,33 @@ PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
 }
 
-void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueFrame(int32_t index) {
+void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueBuffer(int32_t index) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
   DCHECK_GE(index, 0);
-  DCHECK_LT(index, host_->frame_buffer()->number_of_frames());
+  DCHECK_LT(index, host_->buffer_manager()->number_of_buffers());
   base::AutoLock lock(lock_);
-  frames_.push_back(index);
+  buffers_.push_back(index);
 }
 
-void PepperMediaStreamAudioTrackHost::AudioSink::InitFramesOnMainThread(
-    int32_t number_of_frames, int32_t frame_size) {
+void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffersOnMainThread(
+    int32_t number_of_buffers, int32_t buffer_size) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
-  bool result = host_->InitFrames(number_of_frames, frame_size);
+  bool result = host_->InitBuffers(number_of_buffers, buffer_size);
   // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin.
   CHECK(result);
   base::AutoLock lock(lock_);
-  for (int32_t i = 0; i < number_of_frames; ++i) {
-    int32_t index = host_->frame_buffer()->DequeueFrame();
+  for (int32_t i = 0; i < number_of_buffers; ++i) {
+    int32_t index = host_->buffer_manager()->DequeueBuffer();
     DCHECK_GE(index, 0);
-    frames_.push_back(index);
+    buffers_.push_back(index);
   }
 }
 
 void
-PepperMediaStreamAudioTrackHost::AudioSink::SendEnqueueFrameMessageOnMainThread(
-    int32_t index) {
+PepperMediaStreamAudioTrackHost::AudioSink::
+    SendEnqueueBufferMessageOnMainThread(int32_t index) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
-  host_->SendEnqueueFrameMessageToPlugin(index);
+  host_->SendEnqueueBufferMessageToPlugin(index);
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data,
@@ -80,31 +80,31 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data,
   int32_t index = -1;
   {
     base::AutoLock lock(lock_);
-    if (!frames_.empty()) {
-      index = frames_.front();
-      frames_.pop_front();
+    if (!buffers_.empty()) {
+      index = buffers_.front();
+      buffers_.pop_front();
     }
   }
 
   if (index != -1) {
     // TODO(penghuang): support re-sampling, etc.
-    ppapi::MediaStreamFrame::Audio* frame =
-        &(host_->frame_buffer()->GetFramePointer(index)->audio);
-    frame->header.size = host_->frame_buffer()->frame_size();
-    frame->header.type = ppapi::MediaStreamFrame::TYPE_AUDIO;
-    frame->timestamp = timestamp_.InMillisecondsF();
-    frame->sample_rate = static_cast<PP_AudioFrame_SampleRate>(sample_rate);
-    frame->number_of_channels = number_of_channels;
-    frame->number_of_samples = number_of_channels * number_of_frames;
-    frame->data_size = frame_data_size_;
-    memcpy(frame->data, audio_data, frame_data_size_);
+    ppapi::MediaStreamBuffer::Audio* buffer =
+        &(host_->buffer_manager()->GetBufferPointer(index)->audio);
+    buffer->header.size = host_->buffer_manager()->buffer_size();
+    buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO;
+    buffer->timestamp = timestamp_.InMillisecondsF();
+    buffer->sample_rate = static_cast<PP_AudioFrame_SampleRate>(sample_rate);
+    buffer->number_of_channels = number_of_channels;
+    buffer->number_of_samples = number_of_channels * number_of_frames;
+    buffer->data_size = buffer_data_size_;
+    memcpy(buffer->data, audio_data, buffer_data_size_);
 
     main_message_loop_proxy_->PostTask(
         FROM_HERE,
-        base::Bind(&AudioSink::SendEnqueueFrameMessageOnMainThread,
+        base::Bind(&AudioSink::SendEnqueueBufferMessageOnMainThread,
                    weak_factory_.GetWeakPtr(), index));
   }
-  timestamp_ += frame_duration_;
+  timestamp_ += buffer_duration_;
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat(
@@ -124,8 +124,8 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat(
   audio_params_ = params;
 
   // TODO(penghuang): support setting format more than once.
-  frame_duration_ = params.GetBufferDuration();
-  frame_data_size_ = params.GetBytesPerBuffer();
+  buffer_duration_ = params.GetBufferDuration();
+  buffer_data_size_ = params.GetBytesPerBuffer();
 
   if (original_audio_params_.IsValid()) {
     DCHECK_EQ(params.sample_rate(), original_audio_params_.sample_rate());
@@ -136,17 +136,17 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat(
     audio_thread_checker_.DetachFromThread();
     original_audio_params_ = params;
     // The size is slightly bigger than necessary, because 8 extra bytes are
-    // added into the struct. Also see |MediaStreamFrame|.
-    size_t max_frame_size =
+    // added into the struct. Also see |MediaStreamBuffer|.
+    size_t max_data_size =
         params.sample_rate() * params.bits_per_sample() / 8 *
         params.channels() * kMaxDuration / 1000;
-    size_t size = sizeof(ppapi::MediaStreamFrame::Audio) + max_frame_size;
+    size_t size = sizeof(ppapi::MediaStreamBuffer::Audio) + max_data_size;
 
     main_message_loop_proxy_->PostTask(
         FROM_HERE,
-        base::Bind(&AudioSink::InitFramesOnMainThread,
+        base::Bind(&AudioSink::InitBuffersOnMainThread,
                    weak_factory_.GetWeakPtr(),
-                   kNumberOfFrames,
+                   kNumberOfBuffers,
                    static_cast<int32_t>(size)));
   }
 }
@@ -174,10 +174,10 @@ void PepperMediaStreamAudioTrackHost::OnClose() {
   }
 }
 
-void PepperMediaStreamAudioTrackHost::OnNewFrameEnqueued() {
-  int32_t index = frame_buffer()->DequeueFrame();
+void PepperMediaStreamAudioTrackHost::OnNewBufferEnqueued() {
+  int32_t index = buffer_manager()->DequeueBuffer();
   DCHECK_GE(index, 0);
-  audio_sink_.EnqueueFrame(index);
+  audio_sink_.EnqueueBuffer(index);
 }
 
 void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
diff --git a/content/renderer/pepper/pepper_media_stream_audio_track_host.h b/content/renderer/pepper/pepper_media_stream_audio_track_host.h
index ec19ea1..8c0706f 100644
--- a/content/renderer/pepper/pepper_media_stream_audio_track_host.h
+++ b/content/renderer/pepper/pepper_media_stream_audio_track_host.h
@@ -38,14 +38,18 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase {
     explicit AudioSink(PepperMediaStreamAudioTrackHost* host);
     virtual ~AudioSink();
 
-    // Enqueues a free frame index into |frames_| which will be used for
+    // Enqueues a free buffer index into |buffers_| which will be used for
     // sending audio samples to plugin.
-    // This function is called on the renderer main thread.
-    void EnqueueFrame(int32_t index);
+    // This function is called on the main thread.
+    void EnqueueBuffer(int32_t index);
 
    private:
-    void InitFramesOnMainThread(int32_t number_of_frames, int32_t frame_size);
-    void SendEnqueueFrameMessageOnMainThread(int32_t index);
+    // Initializes buffers on the main thread.
+    void InitBuffersOnMainThread(int32_t number_of_buffers,
+                                 int32_t buffer_size);
+
+    // Send enqueue buffer message on the main thread.
+    void SendEnqueueBufferMessageOnMainThread(int32_t index);
 
     // MediaStreamAudioSink overrides:
     // These two functions should be called on the audio thread.
@@ -57,18 +61,18 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase {
 
     // Unowned host which is available during the AudioSink's lifespan.
     // It is mainly used in the main thread. But the audio thread will use
-    // host_->frame_buffer() to read some buffer properties. It is safe
-    // because the frame_buffer()'s properties will not be changed after
+    // host_->buffer_manager() to read some buffer properties. It is safe
+    // because the buffer_manager()'s properties will not be changed after
     // initialization.
     PepperMediaStreamAudioTrackHost* host_;
 
-    // Timestamp of the next received audio frame.
+    // Timestamp of the next received audio buffer.
     // Access only on the audio thread.
     base::TimeDelta timestamp_;
 
-    // Duration of one audio frame.
+    // Duration of one audio buffer.
     // Access only on the audio thread.
-    base::TimeDelta frame_duration_;
+    base::TimeDelta buffer_duration_;
 
     // The current audio parameters.
     // Access only on the audio thread.
@@ -79,15 +83,15 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase {
     // Access only on the audio thread.
     media::AudioParameters original_audio_params_;
 
-    // The size of a frame in bytes.
+    // The audio data size of one audio buffer in bytes.
     // Access only on the audio thread.
-    uint32_t frame_data_size_;
+    uint32_t buffer_data_size_;
 
-    // A lock to protect the index queue |frames_|.
+    // A lock to protect the index queue |buffers_|.
     base::Lock lock_;
 
-    // A queue for free frame indices.
-    std::deque<int32_t> frames_;
+    // A queue for free buffer indices.
+    std::deque<int32_t> buffers_;
 
     scoped_refptr<base::MessageLoopProxy> main_message_loop_proxy_;
 
@@ -103,8 +107,8 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase {
   // PepperMediaStreamTrackHostBase overrides:
   virtual void OnClose() OVERRIDE;
 
-  // MediaStreamFrameBuffer::Delegate overrides:
-  virtual void OnNewFrameEnqueued() OVERRIDE;
+  // MediaStreamBufferManager::Delegate overrides:
+  virtual void OnNewBufferEnqueued() OVERRIDE;
 
   // ResourceHost overrides:
   virtual void DidConnectPendingHostToResource() OVERRIDE;
diff --git a/content/renderer/pepper/pepper_media_stream_track_host_base.cc b/content/renderer/pepper/pepper_media_stream_track_host_base.cc
index aadc7ab..207de39 100644
--- a/content/renderer/pepper/pepper_media_stream_track_host_base.cc
+++ b/content/renderer/pepper/pepper_media_stream_track_host_base.cc
@@ -12,7 +12,7 @@
 #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_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 
 using ppapi::host::HostMessageContext;
 using ppapi::proxy::SerializedHandle;
@@ -25,23 +25,23 @@ PepperMediaStreamTrackHostBase::PepperMediaStreamTrackHostBase(
     PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       host_(host),
-      frame_buffer_(this) {
+      buffer_manager_(this) {
 }
 
 PepperMediaStreamTrackHostBase::~PepperMediaStreamTrackHostBase() {
 }
 
-bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames,
-                                                int32_t frame_size) {
-  DCHECK_GT(number_of_frames, 0);
-  DCHECK_GT(frame_size,
-            static_cast<int32_t>(sizeof(ppapi::MediaStreamFrame::Header)));
-  // Make each frame 4 byte aligned.
-  frame_size = (frame_size + 3) & ~0x3;
+bool PepperMediaStreamTrackHostBase::InitBuffers(int32_t number_of_buffers,
+                                                 int32_t buffer_size) {
+  DCHECK_GT(number_of_buffers, 0);
+  DCHECK_GT(buffer_size,
+            static_cast<int32_t>(sizeof(ppapi::MediaStreamBuffer::Header)));
+  // Make each buffer 4 byte aligned.
+  buffer_size = (buffer_size + 3) & ~0x3;
 
   // TODO(penghuang): |HostAllocateSharedMemoryBuffer| uses sync IPC. We should
   // avoid it.
-  int32_t size = number_of_frames * frame_size;
+  int32_t size = number_of_buffers * buffer_size;
   content::RenderThread* render_thread = content::RenderThread::Get();
   scoped_ptr<base::SharedMemory> shm(
       render_thread->HostAllocateSharedMemoryBuffer(size).Pass());
@@ -49,8 +49,10 @@ bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames,
     return false;
 
   base::SharedMemoryHandle shm_handle = shm->handle();
-  if (!frame_buffer_.SetFrames(number_of_frames, frame_size, shm.Pass(), true))
+  if (!buffer_manager_.SetBuffers(
+        number_of_buffers, buffer_size, shm.Pass(), true)) {
     return false;
+  }
 
   base::PlatformFile platform_file =
 #if defined(OS_WIN)
@@ -63,17 +65,18 @@ bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames,
   SerializedHandle handle(
       host_->ShareHandleWithRemote(platform_file, false), size);
   host()->SendUnsolicitedReplyWithHandles(pp_resource(),
-      PpapiPluginMsg_MediaStreamTrack_InitFrames(number_of_frames, frame_size),
+      PpapiPluginMsg_MediaStreamTrack_InitBuffers(number_of_buffers,
+                                                  buffer_size),
       std::vector<SerializedHandle>(1, handle));
   return true;
 }
 
-void PepperMediaStreamTrackHostBase::SendEnqueueFrameMessageToPlugin(
+void PepperMediaStreamTrackHostBase::SendEnqueueBufferMessageToPlugin(
     int32_t index) {
   DCHECK_GE(index, 0);
-  DCHECK_LT(index, frame_buffer_.number_of_frames());
+  DCHECK_LT(index, buffer_manager_.number_of_buffers());
   host()->SendUnsolicitedReply(pp_resource(),
-      PpapiPluginMsg_MediaStreamTrack_EnqueueFrame(index));
+      PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer(index));
 }
 
 int32_t PepperMediaStreamTrackHostBase::OnResourceMessageReceived(
@@ -81,17 +84,17 @@ int32_t PepperMediaStreamTrackHostBase::OnResourceMessageReceived(
     HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperMediaStreamTrackHostBase, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(
-        PpapiHostMsg_MediaStreamTrack_EnqueueFrame, OnHostMsgEnqueueFrame)
+        PpapiHostMsg_MediaStreamTrack_EnqueueBuffer, OnHostMsgEnqueueBuffer)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
         PpapiHostMsg_MediaStreamTrack_Close, OnHostMsgClose)
   IPC_END_MESSAGE_MAP()
   return ppapi::host::ResourceHost::OnResourceMessageReceived(msg, context);
 }
 
-int32_t PepperMediaStreamTrackHostBase::OnHostMsgEnqueueFrame(
+int32_t PepperMediaStreamTrackHostBase::OnHostMsgEnqueueBuffer(
     HostMessageContext* context,
     int32_t index) {
-  frame_buffer_.EnqueueFrame(index);
+  buffer_manager_.EnqueueBuffer(index);
   return PP_OK;
 }
 
diff --git a/content/renderer/pepper/pepper_media_stream_track_host_base.h b/content/renderer/pepper/pepper_media_stream_track_host_base.h
index bb34eb5..a31c1e1 100644
--- a/content/renderer/pepper/pepper_media_stream_track_host_base.h
+++ b/content/renderer/pepper/pepper_media_stream_track_host_base.h
@@ -8,7 +8,7 @@
 #include "base/compiler_specific.h"
 #include "content/common/content_export.h"
 #include "ppapi/host/resource_host.h"
-#include "ppapi/shared_impl/media_stream_frame_buffer.h"
+#include "ppapi/shared_impl/media_stream_buffer_manager.h"
 
 namespace content {
 
@@ -16,21 +16,22 @@ class RendererPpapiHost;
 
 class PepperMediaStreamTrackHostBase
     : public ppapi::host::ResourceHost,
-      public ppapi::MediaStreamFrameBuffer::Delegate {
+      public ppapi::MediaStreamBufferManager::Delegate {
  protected:
   PepperMediaStreamTrackHostBase(RendererPpapiHost* host,
                                  PP_Instance instance,
                                  PP_Resource resource);
   virtual ~PepperMediaStreamTrackHostBase();
 
-  bool InitFrames(int32_t number_of_frames, int32_t frame_size);
+  bool InitBuffers(int32_t number_of_buffers, int32_t buffer_size);
 
-  ppapi::MediaStreamFrameBuffer* frame_buffer() { return &frame_buffer_; }
+  ppapi::MediaStreamBufferManager* buffer_manager() { return &buffer_manager_; }
 
-  // Sends a frame index to the corresponding MediaStreamTrackResourceBase
-  // via an IPC message. The resource adds the frame index into its
-  // |frame_buffer_| for reading or writing. Also see |MediaStreamFrameBuffer|.
-  void SendEnqueueFrameMessageToPlugin(int32_t index);
+  // Sends a buffer index to the corresponding MediaStreamTrackResourceBase
+  // via an IPC message. The resource adds the buffer index into its
+  // |buffer_manager_| for reading or writing.
+  // Also see |MediaStreamBufferManager|.
+  void SendEnqueueBufferMessageToPlugin(int32_t index);
 
  private:
   // Subclasses must implement this method to clean up when the track is closed.
@@ -42,13 +43,13 @@ class PepperMediaStreamTrackHostBase
       ppapi::host::HostMessageContext* context) OVERRIDE;
 
   // Message handlers:
-  int32_t OnHostMsgEnqueueFrame(ppapi::host::HostMessageContext* context,
+  int32_t OnHostMsgEnqueueBuffer(ppapi::host::HostMessageContext* context,
                                 int32_t index);
   int32_t OnHostMsgClose(ppapi::host::HostMessageContext* context);
 
   RendererPpapiHost* host_;
 
-  ppapi::MediaStreamFrameBuffer frame_buffer_;
+  ppapi::MediaStreamBufferManager buffer_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperMediaStreamTrackHostBase);
 };
diff --git a/content/renderer/pepper/pepper_media_stream_video_track_host.cc b/content/renderer/pepper/pepper_media_stream_video_track_host.cc
index 0cf8036c..7512c5a 100644
--- a/content/renderer/pepper/pepper_media_stream_video_track_host.cc
+++ b/content/renderer/pepper/pepper_media_stream_video_track_host.cc
@@ -7,7 +7,7 @@
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_video_frame.h"
-#include "ppapi/shared_impl/media_stream_frame.h"
+#include "ppapi/shared_impl/media_stream_buffer.h"
 
 using media::VideoFrame;
 
@@ -77,33 +77,33 @@ void PepperMediaStreamVideoTrackHost::OnVideoFrame(
     // than once.
     DCHECK(!frame_data_size_);
     frame_data_size_ = VideoFrame::AllocationSize(frame_format_, frame_size_);
-    int32_t size = sizeof(ppapi::MediaStreamFrame::Video) + frame_data_size_;
-    bool result = InitFrames(kNumberOfFrames, size);
+    int32_t size = sizeof(ppapi::MediaStreamBuffer::Video) + frame_data_size_;
+    bool result = InitBuffers(kNumberOfFrames, size);
     // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin.
     CHECK(result);
   }
 
-  int32_t index = frame_buffer()->DequeueFrame();
+  int32_t index = buffer_manager()->DequeueBuffer();
   // Drop frames if the underlying buffer is full.
   if (index < 0)
     return;
 
   // TODO(penghuang): support format conversion and size scaling.
-  ppapi::MediaStreamFrame::Video* ppframe =
-      &(frame_buffer()->GetFramePointer(index)->video);
-  ppframe->header.size = frame_buffer()->frame_size();
-  ppframe->header.type = ppapi::MediaStreamFrame::TYPE_VIDEO;
-  ppframe->timestamp = frame->GetTimestamp().InSecondsF();
-  ppframe->format = ppformat;
-  ppframe->size.width = frame->coded_size().width();
-  ppframe->size.height = frame->coded_size().height();
-  ppframe->data_size = frame_data_size_;
+  ppapi::MediaStreamBuffer::Video* buffer =
+      &(buffer_manager()->GetBufferPointer(index)->video);
+  buffer->header.size = buffer_manager()->buffer_size();
+  buffer->header.type = ppapi::MediaStreamBuffer::TYPE_VIDEO;
+  buffer->timestamp = frame->GetTimestamp().InSecondsF();
+  buffer->format = ppformat;
+  buffer->size.width = frame->coded_size().width();
+  buffer->size.height = frame->coded_size().height();
+  buffer->data_size = frame_data_size_;
 
   COMPILE_ASSERT(VideoFrame::kYPlane == 0, y_plane_should_be_0);
   COMPILE_ASSERT(VideoFrame::kUPlane == 1, u_plane_should_be_1);
   COMPILE_ASSERT(VideoFrame::kVPlane == 2, v_plane_should_be_2);
 
-  uint8_t* dst = ppframe->data;
+  uint8_t* dst = buffer->data;
   size_t num_planes = VideoFrame::NumPlanes(frame->format());
   for (size_t i = 0; i < num_planes; ++i) {
     const uint8_t* src = frame->data(i);
@@ -117,7 +117,7 @@ void PepperMediaStreamVideoTrackHost::OnVideoFrame(
     }
   }
 
-  SendEnqueueFrameMessageToPlugin(index);
+  SendEnqueueBufferMessageToPlugin(index);
 }
 
 void PepperMediaStreamVideoTrackHost::DidConnectPendingHostToResource() {
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;
 };