Implement MojoAudioRendererSink and use it in UtilityMojoMediaClient

media/base/audio_bus.h

 // Copyright (c) 2012 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 MEDIA_BASE_AUDIO_BUS_H_
 #define MEDIA_BASE_AUDIO_BUS_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/media_export.h"
 
+namespace mojo {
+template <typename T, typename U>
+struct TypeConverter;
+template <typename T>
+class StructPtr;
+};
+
 namespace media {
 class AudioParameters;
 
+namespace mojom {
+class AudioBus;
+}
+
 // Represents a sequence of audio frames containing frames() audio samples for
 // each of channels() channels. The data is stored as a set of contiguous
 // float arrays with one array per channel. The memory for the arrays is either
 // allocated and owned by the AudioBus or it is provided to one of the factory
 // methods. AudioBus guarantees that it allocates memory such that float array
 // for each channel is aligned by AudioBus::kChannelAlignment bytes and it
 // requires the same for memory passed to its Wrap...() factory methods.
 // TODO(chfremer): There are currently no unit tests involving CreateWrapper and
 // SetChannelData, so we need to add them.
 class MEDIA_EXPORT AudioBus {
@@ skipping 149 matching lines @@
 
   virtual ~AudioBus();
 
  protected:
   AudioBus(int channels, int frames);
   AudioBus(int channels, int frames, float* data);
   AudioBus(int frames, const std::vector<float*>& channel_data);
   explicit AudioBus(int channels);
 
  private:
+  // mojo::TypeConverter added as a friend so that AudioBus can be
+  // transferred across a mojo connection.
+  friend struct mojo::TypeConverter<mojo::StructPtr<mojom::AudioBus>, AudioBus>;
+
   // Helper method for building |channel_data_| from a block of memory.  |data|
   // must be at least CalculateMemorySize(...) bytes in size.
   void BuildChannelData(int channels, int aligned_frame, float* data);
 
   static void CheckOverflow(int start_frame, int frames, int total_frames);
 
   template <class SourceSampleTypeTraits>
   static void CopyConvertFromInterleavedSourceToAudioBus(
       const typename SourceSampleTypeTraits::ValueType* source_buffer,
       int write_offset_in_frames,
       int num_frames_to_write,
       AudioBus* dest);
 
   template <class TargetSampleTypeTraits>
   static void CopyConvertFromAudioBusToInterleavedTarget(
       const AudioBus* source,
       int read_offset_in_frames,
       int num_frames_to_read,
       typename TargetSampleTypeTraits::ValueType* dest_buffer);
 
   // Contiguous block of channel memory.
   std::unique_ptr<float, base::AlignedFreeDeleter> data_;
+  size_t data_size_;
 
   // One float pointer per channel pointing to a contiguous block of memory for
   // that channel. If the memory is owned by this instance, this will
   // point to the memory in |data_|. Otherwise, it may point to memory provided
   // by the client.
   std::vector<float*> channel_data_;
   int frames_;
 
   // Protect SetChannelData() and set_frames() for use by CreateWrapper().
   bool can_set_channel_data_;
@@ skipping 98 matching lines @@
 
   AudioBusRefCounted(int channels, int frames);
   ~AudioBusRefCounted() override;
 
   DISALLOW_COPY_AND_ASSIGN(AudioBusRefCounted);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_AUDIO_BUS_H_