[PPAPI][MediaStream] Rename AudioFrame to AudioBuffer

ppapi/examples/media_stream_audio/media_stream_audio.cc

 // 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 <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
-#include "ppapi/cpp/audio_frame.h"
+#include "ppapi/cpp/audio_buffer.h"
 #include "ppapi/cpp/dev/var_resource_dev.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/media_stream_audio_track.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
 #include "ppapi/utility/completion_callback_factory.h"
@@ skipping 13 matching lines @@
 const uint32_t kColorGreen = 0xFF00FF00;
 const uint32_t kColorGrey1 = 0xFF202020;
 const uint32_t kColorGrey2 = 0xFF404040;
 const uint32_t kColorGrey3 = 0xFF606060;
 
 class MediaStreamAudioInstance : public pp::Instance {
  public:
   explicit MediaStreamAudioInstance(PP_Instance instance)
       : pp::Instance(instance),
         callback_factory_(this),
-        first_frame_(true),
+        first_buffer_(true),
         sample_count_(0),
         channel_count_(0),
         timer_interval_(0),
         pending_paint_(false),
         waiting_for_flush_completion_(false) {
   }
 
   virtual ~MediaStreamAudioInstance() {
   }
 
@@ skipping 12 matching lines @@
   virtual void HandleMessage(const pp::Var& var_message) {
     if (!var_message.is_dictionary())
       return;
     pp::VarDictionary var_dictionary_message(var_message);
     pp::Var var_track = var_dictionary_message.Get("track");
     if (!var_track.is_resource())
       return;
 
     pp::Resource resource_track = pp::VarResource_Dev(var_track).AsResource();
     audio_track_ = pp::MediaStreamAudioTrack(resource_track);
-    audio_track_.GetFrame(callback_factory_.NewCallbackWithOutput(
-          &MediaStreamAudioInstance::OnGetFrame));
+    audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
+          &MediaStreamAudioInstance::OnGetBuffer));
   }
 
  private:
   void ScheduleNextTimer() {
     PP_DCHECK(timer_interval_ > 0);
     pp::Module::Get()->core()->CallOnMainThread(
         timer_interval_,
         callback_factory_.NewCallback(&MediaStreamAudioInstance::OnTimer),
         0);
   }
@@ skipping 58 matching lines @@
       for (uint32_t ch = 0; ch < std::min(channel_count_, 2U); ++ch) {
         int y = samples_[i + ch] * max_amplitude /
                 (std::numeric_limits<int16_t>::max() + 1) + mid_height;
         *image.GetAddr32(pp::Point(x, y)) = (ch == 0 ? kColorRed : kColorGreen);
       }
     }
 
     return image;
   }
 
-  // Callback that is invoked when new frames are received.
-  void OnGetFrame(int32_t result, pp::AudioFrame frame) {
+  // Callback that is invoked when new buffers are received.
+  void OnGetBuffer(int32_t result, pp::AudioBuffer buffer) {
     if (result != PP_OK)
       return;
 
-    PP_DCHECK(frame.GetSampleSize() == PP_AUDIOFRAME_SAMPLESIZE_16_BITS);
-    const char* data = static_cast<const char*>(frame.GetDataBuffer());
-    uint32_t channels = frame.GetNumberOfChannels();
-    uint32_t samples = frame.GetNumberOfSamples() / channels;
+    PP_DCHECK(buffer.GetSampleSize() == PP_AUDIOBUFFER_SAMPLESIZE_16_BITS);
+    const char* data = static_cast<const char*>(buffer.GetDataBuffer());
+    uint32_t channels = buffer.GetNumberOfChannels();
+    uint32_t samples = buffer.GetNumberOfSamples() / channels;
 
     if (channel_count_ != channels || sample_count_ != samples) {
       channel_count_ = channels;
       sample_count_ = samples;
 
       samples_.resize(sample_count_ * channel_count_);
-      timer_interval_ = (sample_count_ * 1000) / frame.GetSampleRate() + 5;
-      // Start the timer for the first frame.
-      if (first_frame_) {
-        first_frame_ = false;
+      timer_interval_ = (sample_count_ * 1000) / buffer.GetSampleRate() + 5;
+      // Start the timer for the first buffer.
+      if (first_buffer_) {
+        first_buffer_ = false;
         ScheduleNextTimer();
       }
     }
 
     memcpy(samples_.data(), data,
         sample_count_ * channel_count_ * sizeof(int16_t));
 
-    audio_track_.RecycleFrame(frame);
-    audio_track_.GetFrame(callback_factory_.NewCallbackWithOutput(
-        &MediaStreamAudioInstance::OnGetFrame));
+    audio_track_.RecycleBuffer(buffer);
+    audio_track_.GetBuffer(callback_factory_.NewCallbackWithOutput(
+        &MediaStreamAudioInstance::OnGetBuffer));
 
   }
 
   pp::MediaStreamAudioTrack audio_track_;
   pp::CompletionCallbackFactory<MediaStreamAudioInstance> callback_factory_;
 
-  bool first_frame_;
+  bool first_buffer_;
   uint32_t sample_count_;
   uint32_t channel_count_;
   std::vector<int16_t> samples_;
 
   int32_t timer_interval_;
 
   // Painting stuff.
   pp::Size size_;
   pp::Graphics2D device_context_;
   bool pending_paint_;
@@ skipping 10 matching lines @@
 }  // namespace
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MediaStreamAudioModule();
 }
 
 }  // namespace pp