[PPAPI] Pepper MediaStream API audio track implementation and example.

ppapi/shared_impl/media_stream_frame_buffer.h

 // 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 "base/synchronization/lock.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
@@ skipping 17 matching lines @@
     // 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 number_of_frames() const {
+    base::AutoLock lock(mutex_);
+    return number_of_frames_;
+  }
 
-  int32_t frame_size() const { return frame_size_; }
+  int32_t frame_size() const {
+    base::AutoLock lock(mutex_);
+    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 mutex to protect below fields.
+  mutable base::Lock mutex_;

[dmichael (off chromium), 2014/01/16 22:34:20]

Can you explain more about why you've done this? We try to avoid explicit
locking as much as possible in Chromium. FWIW, on the plugin side of the proxy,
there is already a lock around everything.

On the host side, we should find a different approach. Usually it involves
posting tasks to an appropriate thread. If you can outline which functions are
on which threads currently in the host side, maybe we can help you come up with
a good approach for dealing with the threading.

[Peng, 2014/01/17 00:23:49]

All audio frames are received from an audio thread (|OnData()|). I know we could
post it to main thread. But it will add some latency.:( And samples data passed
to OnData is not refcounted. If we want to post task to main thread |OnData()|,
we also need find a way how to handle it (copied it to a temp buffer, or call
Dequeue() to get a free frame ready in main thread before OnData() is called).

FYI, This Lock protects operations on the frame_queue_. Most operations are
enqueue and dequeue. They are not big time consuming operations.
The lock's impact is minor I think. 

I have add more inline comments on AudioTrackHost, please take a look.

+
   // 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_