Removed PushSource::Packet. SeekableBuffer.current_time() fixed to return

media/audio/simple_sources.cc

 // Copyright (c) 2010 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 "media/audio/simple_sources.h"
 
 #include <algorithm>
 #include <math.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/ref_counted.h"
 #include "media/audio/audio_output.h"
+#include "media/base/data_buffer.h"
 
 //////////////////////////////////////////////////////////////////////////////
 // SineWaveAudioSource implementation.
 
 SineWaveAudioSource::SineWaveAudioSource(Format format, int channels,
                                          double freq, double sample_freq)
     : format_(format),
       channels_(channels),
       freq_(freq),
       sample_freq_(sample_freq) {
@@ skipping 21 matching lines @@
 }
 
 void SineWaveAudioSource::OnError(AudioOutputStream* stream, int code) {
   NOTREACHED();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // PushSource implementation.
 
 PushSource::PushSource()
-    : buffered_bytes_(0),
-      front_buffer_consumed_(0) {
+    : buffer_(0, 0) {
 }
 
-PushSource::~PushSource() {
-  CleanUp();
-}
+PushSource::~PushSource() { }
 
 uint32 PushSource::OnMoreData(AudioOutputStream* stream, void* dest,
                               uint32 max_size, uint32 pending_bytes) {
-  uint32 copied = 0;
-  while (copied < max_size) {
-    AutoLock auto_lock(lock_);
-
-    // Under lock processing in this scope.
-    if (!packets_.size())
-      break;
-    Packet packet = packets_.front();
-    uint32 size = std::min(max_size - copied,
-                           packet.size - front_buffer_consumed_);
-    memcpy(static_cast<char*>(dest) + copied,
-           packet.buffer + front_buffer_consumed_,
-           size);
-    front_buffer_consumed_ += size;
-    buffered_bytes_ -= size;
-    copied += size;
-    if (front_buffer_consumed_ == packet.size) {
-      delete [] packet.buffer;
-      packets_.pop_front();
-      front_buffer_consumed_ = 0;
-    }
-  }
-  return copied;
+  AutoLock auto_lock(buffer_lock_);

[awong, 2010/05/26 20:54:41]

PushSource really just becomes a small interface adapter on a seekable buffer
doesn't it?  This makes me feel like there's room for further simplification. 
Thoughts?

[scherkus (not reviewing), 2010/05/27 02:36:06]

Agreed.  SeekableBuffer is now a sort of swiss army knife of buffer
implementations :)

+  return buffer_.Read(static_cast<uint8*>(dest), max_size);
 }
 
 void PushSource::OnClose(AudioOutputStream* stream) {
   CleanUp();
 }
 
 void PushSource::OnError(AudioOutputStream* stream, int code) {
   NOTREACHED();
 }
 
 // TODO(cpu): Manage arbitrary large sizes.
 bool PushSource::Write(const void *data, uint32 len) {
   if (len == 0) {
     NOTREACHED();
     return false;
   }
-  Packet packet = { new char[len], len };
-  memcpy(packet.buffer, data, packet.size);
-  // Under lock processing here.
-  AutoLock auto_lock(lock_);
-  packets_.push_back(packet);
-  buffered_bytes_ += len;
+  AutoLock auto_lock(buffer_lock_);
+  buffer_.Append(static_cast<const uint8*>(data), len);
   return true;
 }
 
 uint32 PushSource::UnProcessedBytes() {
-  AutoLock auto_lock(lock_);
-  return buffered_bytes_;
+  AutoLock auto_lock(buffer_lock_);
+  return buffer_.forward_bytes();
 }
 
 void PushSource::ClearAll() {
   // Cleanup() will discard all the data.
   CleanUp();
 }
 
 void PushSource::CleanUp() {
-  AutoLock auto_lock(lock_);
-  PacketList::const_iterator it;
-  for (it = packets_.begin(); it != packets_.end(); ++it) {
-    delete [] it->buffer;
-  }
-  packets_.clear();
-  buffered_bytes_ = 0;
-  front_buffer_consumed_ = 0;
+  AutoLock auto_lock(buffer_lock_);
+  buffer_.Clear();
 }