Revert of Define AudioBuffer and VideoFrame for mojo

media/base/audio_buffer.h

 // Copyright 2013 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_BUFFER_H_
 #define MEDIA_BASE_AUDIO_BUFFER_H_
 
 #include <vector>
 
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "media/base/channel_layout.h"
 #include "media/base/media_export.h"
 #include "media/base/sample_format.h"
 
-namespace mojo {
-template <typename T, typename U>
-struct TypeConverter;
-template <typename T>
-class StructPtr;
-};
-
 namespace media {
 class AudioBus;
 
-namespace interfaces {
-class AudioBuffer;
-}
-
 // An audio buffer that takes a copy of the data passed to it, holds it, and
 // copies it into an AudioBus when needed. Also supports an end of stream
 // marker.
 class MEDIA_EXPORT AudioBuffer
     : public base::RefCountedThreadSafe<AudioBuffer> {
  public:
   // Alignment of each channel's data; this must match what ffmpeg expects
   // (which may be 0, 16, or 32, depending on the processor). Selecting 32 in
   // order to work on all processors.
   enum { kChannelAlignment = 32 };
@@ skipping 85 matching lines @@
   // If there's no data in this buffer, it represents end of stream.
   bool end_of_stream() const { return end_of_stream_; }
 
   // Access to the raw buffer for ffmpeg to write directly to. Data for planar
   // data is grouped by channel. There is only 1 entry for interleaved formats.
   const std::vector<uint8*>& channel_data() const { return channel_data_; }
 
  private:
   friend class base::RefCountedThreadSafe<AudioBuffer>;
 
-  // mojo::TypeConverter added as a friend so that AudioBuffer can be
-  // transferred across a mojo connection.
-  friend struct mojo::TypeConverter<mojo::StructPtr<interfaces::AudioBuffer>,
-                                    scoped_refptr<AudioBuffer>>;
-
   // Allocates aligned contiguous buffer to hold all channel data (1 block for
   // interleaved data, |channel_count| blocks for planar data), copies
   // [data,data+data_size) to the allocated buffer(s). If |data| is null, no
   // data is copied. If |create_buffer| is false, no data buffer is created (or
   // copied to).
   AudioBuffer(SampleFormat sample_format,
               ChannelLayout channel_layout,
               int channel_count,
               int sample_rate,
               int frame_count,
               bool create_buffer,
               const uint8* const* data,
               const base::TimeDelta timestamp);
 
   virtual ~AudioBuffer();
 
   const SampleFormat sample_format_;
   const ChannelLayout channel_layout_;
   const int channel_count_;
   const int sample_rate_;
   int adjusted_frame_count_;
   int trim_start_;
   const bool end_of_stream_;
   base::TimeDelta timestamp_;
   base::TimeDelta duration_;
 
   // Contiguous block of channel data.
   scoped_ptr<uint8, base::AlignedFreeDeleter> data_;
-  size_t data_size_;
 
   // For planar data, points to each channels data.
   std::vector<uint8*> channel_data_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AudioBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_AUDIO_BUFFER_H_