Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/chunk_demuxer.cc

 // 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.
 
 #include "media/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 
@@ skipping 32 matching lines @@
   bool Append(const uint8* data, size_t length);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
 
   // Sets |timestamp_offset_| if possible.
   // Returns if the offset was set. Returns false if the offset could not be
   // updated at this time.
   bool SetTimestampOffset(TimeDelta timestamp_offset);
 
-  TimeDelta timestamp_offset() const { return timestamp_offset_; }
+  TimeDelta GetTimestampOffset() const {

[scherkus (not reviewing), 2013/06/22 00:39:17]

whoops -- this is still incorrect

the original code was as follows:
TimeDelta timestamp_offset() const { return timestamp_offset_; }

+    return timestamp_offset_;
+  }
 
  private:
   // Called by the |stream_parser_| at the beginning of a new media segment.
   // |timestamp| is the timestamp on the first buffer in the segment.
   // It modifies the state of this object and then calls |new_segment_cb| with
   // modified version of |timestamp|.
   void OnNewMediaSegment(const StreamParser::NewMediaSegmentCB& new_segment_cb,
                          TimeDelta timestamp);
 
   // Called by the |stream_parser_| at the end of a media segment.
@@ skipping 25 matching lines @@
   // Keeps track of whether |timestamp_offset_| can be modified.
   bool can_update_offset_;
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser)
-    : can_update_offset_(true),
-      stream_parser_(stream_parser.release()) {
-}
+    : can_update_offset_(true), stream_parser_(stream_parser.release()) {}
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        const StreamParser::NewConfigCB& config_cb,
                        const StreamParser::NewBuffersCB& audio_cb,
                        const StreamParser::NewBuffersCB& video_cb,
                        const StreamParser::NewTextBuffersCB& text_cb,
                        const StreamParser::NeedKeyCB& need_key_cb,
                        const AddTextTrackCB& add_text_track_cb,
                        const StreamParser::NewMediaSegmentCB& new_segment_cb,
                        const LogCB& log_cb) {
-  stream_parser_->Init(init_cb, config_cb,
-                       base::Bind(&SourceState::OnBuffers,
-                                  base::Unretained(this), audio_cb),
-                       base::Bind(&SourceState::OnBuffers,
-                                  base::Unretained(this), video_cb),
-                       base::Bind(&SourceState::OnTextBuffers,
-                                  base::Unretained(this), text_cb),
-                       need_key_cb,
-                       add_text_track_cb,
-                       base::Bind(&SourceState::OnNewMediaSegment,
-                                  base::Unretained(this), new_segment_cb),
-                       base::Bind(&SourceState::OnEndOfMediaSegment,
-                                  base::Unretained(this)),
-                       log_cb);
+  stream_parser_->Init(
+      init_cb,
+      config_cb,
+      base::Bind(&SourceState::OnBuffers, base::Unretained(this), audio_cb),
+      base::Bind(&SourceState::OnBuffers, base::Unretained(this), video_cb),
+      base::Bind(&SourceState::OnTextBuffers, base::Unretained(this), text_cb),
+      need_key_cb,
+      add_text_track_cb,
+      base::Bind(&SourceState::OnNewMediaSegment,
+                 base::Unretained(this),
+                 new_segment_cb),
+      base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
+      log_cb);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
   if (!can_update_offset_)
     return false;
 
   timestamp_offset_ = timestamp_offset;
   return true;
 }
 
 bool SourceState::Append(const uint8* data, size_t length) {
   return stream_parser_->Parse(data, length);
 }
 
 void SourceState::Abort() {
   stream_parser_->Flush();
   can_update_offset_ = true;
 }
 
 void SourceState::AdjustBufferTimestamps(
     const StreamParser::BufferQueue& buffers) {
   if (timestamp_offset_ == TimeDelta())
     return;
 
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
-       itr != buffers.end(); ++itr) {
-    (*itr)->SetDecodeTimestamp(
-        (*itr)->GetDecodeTimestamp() + timestamp_offset_);
-    (*itr)->SetTimestamp((*itr)->GetTimestamp() + timestamp_offset_);
+       itr != buffers.end();
+       ++itr) {
+    (*itr)
+        ->SetDecodeTimestamp((*itr)->GetDecodeTimestamp() + timestamp_offset_);
+    (*itr)->set_timestamp((*itr)->timestamp() + timestamp_offset_);
   }
 }
 
 void SourceState::OnNewMediaSegment(
     const StreamParser::NewMediaSegmentCB& new_segment_cb,
     TimeDelta timestamp) {
   DCHECK(timestamp != kNoTimestamp());
   DVLOG(2) << "OnNewMediaSegment(" << timestamp.InSecondsF() << ")";
 
   can_update_offset_ = false;
@@ skipping 109 matching lines @@
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 ChunkDemuxerStream::ChunkDemuxerStream(const AudioDecoderConfig& audio_config,
                                        const LogCB& log_cb)
-    : type_(AUDIO),
-      state_(RETURNING_DATA_FOR_READS) {
+    : type_(AUDIO), state_(RETURNING_DATA_FOR_READS) {
   stream_.reset(new SourceBufferStream(audio_config, log_cb));
 }
 
 ChunkDemuxerStream::ChunkDemuxerStream(const VideoDecoderConfig& video_config,
                                        const LogCB& log_cb)
-    : type_(VIDEO),
-      state_(RETURNING_DATA_FOR_READS) {
+    : type_(VIDEO), state_(RETURNING_DATA_FOR_READS) {
   stream_.reset(new SourceBufferStream(video_config, log_cb));
 }
 
 void ChunkDemuxerStream::StartWaitingForSeek() {
   DVLOG(1) << "ChunkDemuxerStream::StartWaitingForSeek()";
   ReadCBQueue read_cbs;
   {
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(WAITING_FOR_SEEK);
     std::swap(read_cbs_, read_cbs);
@@ skipping 128 matching lines @@
     it->Run(DemuxerStream::kOk, StreamParserBuffer::CreateEOSBuffer());
 }
 
 // Helper function that makes sure |read_cb| runs on |message_loop_proxy|.
 static void RunOnMessageLoop(
     const DemuxerStream::ReadCB& read_cb,
     const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   if (!message_loop_proxy->BelongsToCurrentThread()) {
-    message_loop_proxy->PostTask(FROM_HERE, base::Bind(
-        &RunOnMessageLoop, read_cb, message_loop_proxy, status, buffer));
+    message_loop_proxy->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &RunOnMessageLoop, read_cb, message_loop_proxy, status, buffer));
     return;
   }
 
   read_cb.Run(status, buffer);
 }
 
 // DemuxerStream methods.
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
   DemuxerStream::Status status = kOk;
   scoped_refptr<StreamParserBuffer> buffer;
   {
     base::AutoLock auto_lock(lock_);
     if (!read_cbs_.empty() || !GetNextBuffer_Locked(&status, &buffer)) {
       DeferRead_Locked(read_cb);
       return;
     }
   }
 
-  base::MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
-      read_cb, status, buffer));
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE, base::Bind(read_cb, status, buffer));
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
 
 void ChunkDemuxerStream::EnableBitstreamConverter() {}
 
 AudioDecoderConfig ChunkDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentAudioDecoderConfig();
 }
 
 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentVideoDecoderConfig();
 }
 
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
-           << "type " << type_
-           << " - " << state_ << " -> " << state;
+           << "type " << type_ << " - " << state_ << " -> " << state;
   state_ = state;
 }
 
 ChunkDemuxerStream::~ChunkDemuxerStream() {}
 
 void ChunkDemuxerStream::DeferRead_Locked(const ReadCB& read_cb) {
   lock_.AssertAcquired();
   // Wrap & store |read_cb| so that it will
   // get called on the current MessageLoop.
-  read_cbs_.push_back(base::Bind(&RunOnMessageLoop, read_cb,
-                                 base::MessageLoopProxy::current()));
+  read_cbs_.push_back(base::Bind(
+      &RunOnMessageLoop, read_cb, base::MessageLoopProxy::current()));
 }
 
 void ChunkDemuxerStream::CreateReadDoneClosures_Locked(ClosureQueue* closures) {
   lock_.AssertAcquired();
 
   if (state_ != RETURNING_DATA_FOR_READS)
     return;
 
   DemuxerStream::Status status;
   scoped_refptr<StreamParserBuffer> buffer;
   while (!read_cbs_.empty()) {
     if (!GetNextBuffer_Locked(&status, &buffer))
       return;
-    closures->push_back(base::Bind(read_cbs_.front(),
-                                   status, buffer));
+    closures->push_back(base::Bind(read_cbs_.front(), status, buffer));
     read_cbs_.pop_front();
   }
 }
 
 bool ChunkDemuxerStream::GetNextBuffer_Locked(
     DemuxerStream::Status* status,
     scoped_refptr<StreamParserBuffer>* buffer) {
   lock_.AssertAcquired();
 
   switch (state_) {
@@ skipping 50 matching lines @@
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
 
   base::AutoLock auto_lock(lock_);
 
   if (state_ == SHUTDOWN) {
-    base::MessageLoopProxy::current()->PostTask(FROM_HERE, base::Bind(
-        cb, DEMUXER_ERROR_COULD_NOT_OPEN));
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE, base::Bind(cb, DEMUXER_ERROR_COULD_NOT_OPEN));
     return;
   }
   DCHECK_EQ(state_, WAITING_FOR_INIT);
   host_ = host;
 
   ChangeState_Locked(INITIALIZING);
   init_cb_ = cb;
 
   base::ResetAndReturn(&open_cb_).Run();
 }
@@ skipping 44 matching lines @@
   base::AutoLock auto_lock(lock_);
   if (type == DemuxerStream::VIDEO)
     return video_.get();
 
   if (type == DemuxerStream::AUDIO)
     return audio_.get();
 
   return NULL;
 }
 
-TimeDelta ChunkDemuxer::GetStartTime() const {
-  return TimeDelta();
-}
+TimeDelta ChunkDemuxer::GetStartTime() const { return TimeDelta(); }
 
 void ChunkDemuxer::StartWaitingForSeek() {
   DVLOG(1) << "StartWaitingForSeek()";
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN);
 
   if (state_ == SHUTDOWN)
     return;
 
   if (audio_)
@@ skipping 25 matching lines @@
                                          const std::string& type,
                                          std::vector<std::string>& codecs) {
   DCHECK_GT(codecs.size(), 0u);
   base::AutoLock auto_lock(lock_);
 
   if ((state_ != WAITING_FOR_INIT && state_ != INITIALIZING) || IsValidId(id))
     return kReachedIdLimit;
 
   bool has_audio = false;
   bool has_video = false;
-  scoped_ptr<media::StreamParser> stream_parser(
-      StreamParserFactory::Create(type, codecs, log_cb_,
-                                  &has_audio, &has_video));
+  scoped_ptr<media::StreamParser> stream_parser(StreamParserFactory::Create(
+      type, codecs, log_cb_, &has_audio, &has_video));
 
   if (!stream_parser)
     return ChunkDemuxer::kNotSupported;
 
   if ((has_audio && !source_id_audio_.empty()) ||
       (has_video && !source_id_video_.empty()))
     return kReachedIdLimit;
 
   StreamParser::NewBuffersCB audio_cb;
   StreamParser::NewBuffersCB video_cb;
 
   if (has_audio) {
     source_id_audio_ = id;
-    audio_cb = base::Bind(&ChunkDemuxer::OnAudioBuffers,
-                          base::Unretained(this));
+    audio_cb =
+        base::Bind(&ChunkDemuxer::OnAudioBuffers, base::Unretained(this));
   }
 
   if (has_video) {
     source_id_video_ = id;
-    video_cb = base::Bind(&ChunkDemuxer::OnVideoBuffers,
-                          base::Unretained(this));
+    video_cb =
+        base::Bind(&ChunkDemuxer::OnVideoBuffers, base::Unretained(this));
   }
 
   scoped_ptr<SourceState> source_state(new SourceState(stream_parser.Pass()));
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
-      base::Bind(&ChunkDemuxer::OnNewConfigs, base::Unretained(this),
-                 has_audio, has_video),
+      base::Bind(&ChunkDemuxer::OnNewConfigs,
+                 base::Unretained(this),
+                 has_audio,
+                 has_video),
       audio_cb,
       video_cb,
       base::Bind(&ChunkDemuxer::OnTextBuffers, base::Unretained(this)),
       base::Bind(&ChunkDemuxer::OnNeedKey, base::Unretained(this)),
       add_text_track_cb_,
       base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id),
       log_cb_);
 
   source_state_map_[id] = source_state.release();
   return kOk;
@@ skipping 56 matching lines @@
     // the streams have slightly different lengths.
     TimeDelta audio_start = audio_ranges.start(audio_ranges.size() - 1);
     TimeDelta audio_end = audio_ranges.end(audio_ranges.size() - 1);
     TimeDelta video_start = video_ranges.start(video_ranges.size() - 1);
     TimeDelta video_end = video_ranges.end(video_ranges.size() - 1);
 
     // Verify the last audio range overlaps with the last video range.
     // This is enforced by the logic that controls the transition to ENDED.
     DCHECK((audio_start <= video_start && video_start <= audio_end) ||
            (video_start <= audio_start && audio_start <= video_end));
-    result.Add(result.end(result.size()-1), std::max(audio_end, video_end));
+    result.Add(result.end(result.size() - 1), std::max(audio_end, video_end));
   }
 
   return result;
 }
 
 void ChunkDemuxer::AppendData(const std::string& id,
                               const uint8* data,
                               size_t length) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
@@ skipping 205 matching lines @@
 
     ChangeState_Locked(SHUTDOWN);
   }
 
   if (!cb.is_null())
     cb.Run(PIPELINE_ERROR_ABORT);
 }
 
 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   lock_.AssertAcquired();
-  DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : "
-           << state_ << " -> " << new_state;
+  DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : " << state_ << " -> "
+           << new_state;
   state_ = new_state;
 }
 
 ChunkDemuxer::~ChunkDemuxer() {
   DCHECK_NE(state_, INITIALIZED);
   for (SourceStateMap::iterator it = source_state_map_.begin();
-       it != source_state_map_.end(); ++it) {
+       it != source_state_map_.end();
+       ++it) {
     delete it->second;
   }
   source_state_map_.clear();
 }
 
 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   DVLOG(1) << "ReportError_Locked(" << error << ")";
   lock_.AssertAcquired();
   DCHECK_NE(error, PIPELINE_OK);
 
@@ skipping 31 matching lines @@
   if (audio_)
     seek_pending = audio_->IsSeekPending();
 
   if (!seek_pending && video_)
     seek_pending = video_->IsSeekPending();
 
   return seek_pending;
 }
 
 void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration) {
-  DVLOG(1) << "OnSourceInitDone(" << success << ", "
-           << duration.InSecondsF() << ")";
+  DVLOG(1) << "OnSourceInitDone(" << success << ", " << duration.InSecondsF()
+           << ")";
   lock_.AssertAcquired();
   DCHECK_EQ(state_, INITIALIZING);
   if (!success || (!audio_ && !video_)) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   if (duration != base::TimeDelta() && duration_ == kNoTimestamp())
     UpdateDuration(duration);
 
   // Wait until all streams have initialized.
   if ((!source_id_audio_.empty() && !audio_) ||
       (!source_id_video_.empty() && !video_))
     return;
 
   if (audio_)
     audio_->Seek(TimeDelta());
 
   if (video_)
     video_->Seek(TimeDelta());
 
   if (duration_ == kNoTimestamp())
     duration_ = kInfiniteDuration();
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
-bool ChunkDemuxer::OnNewConfigs(bool has_audio, bool has_video,
+bool ChunkDemuxer::OnNewConfigs(bool has_audio,
+                                bool has_video,
                                 const AudioDecoderConfig& audio_config,
                                 const VideoDecoderConfig& video_config) {
-  DVLOG(1) << "OnNewConfigs(" << has_audio << ", " << has_video
-           << ", " << audio_config.IsValidConfig()
-           << ", " << video_config.IsValidConfig() << ")";
+  DVLOG(1) << "OnNewConfigs(" << has_audio << ", " << has_video << ", "
+           << audio_config.IsValidConfig() << ", "
+           << video_config.IsValidConfig() << ")";
   lock_.AssertAcquired();
 
   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
     return false;
   }
 
   // Signal an error if we get configuration info for stream types that weren't
   // specified in AddId() or more configs after a stream is initialized.
   // Only allow a single audio config for now.
@@ skipping 62 matching lines @@
     return false;
 
   CHECK(IsValidId(source_id_video_));
   if (!video_->Append(buffers))
     return false;
 
   IncreaseDurationIfNecessary(buffers, video_.get());
   return true;
 }
 
-bool ChunkDemuxer::OnTextBuffers(
-  TextTrack* text_track,
-  const StreamParser::BufferQueue& buffers) {
+bool ChunkDemuxer::OnTextBuffers(TextTrack* text_track,
+                                 const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   // TODO(matthewjheaney): IncreaseDurationIfNecessary
 
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
-       itr != buffers.end(); ++itr) {
+       itr != buffers.end();
+       ++itr) {
     const StreamParserBuffer* const buffer = itr->get();
-    const base::TimeDelta start = buffer->GetTimestamp();
-    const base::TimeDelta end = start + buffer->GetDuration();
+    const base::TimeDelta start = buffer->timestamp();
+    const base::TimeDelta end = start + buffer->duration();
 
     std::string id, settings, content;
 
-    WebMWebVTTParser::Parse(buffer->GetData(),
-                            buffer->GetDataSize(),
-                            &id, &settings, &content);
+    WebMWebVTTParser::Parse(
+        buffer->data(), buffer->data_size(), &id, &settings, &content);
 
     text_track->addWebVTTCue(start, end, id, content, settings);
   }
 
   return true;
 }
 
 // TODO(acolwell): Remove bool from StreamParser::NeedKeyCB so that
 // this method can be removed and need_key_cb_ can be passed directly
 // to the parser.
@@ skipping 28 matching lines @@
   DCHECK(duration_ != new_duration);
   user_specified_duration_ = -1;
   duration_ = new_duration;
   host_->SetDuration(new_duration);
 }
 
 void ChunkDemuxer::IncreaseDurationIfNecessary(
     const StreamParser::BufferQueue& buffers,
     ChunkDemuxerStream* stream) {
   DCHECK(!buffers.empty());
-  if (buffers.back()->GetTimestamp() <= duration_)
+  if (buffers.back()->timestamp() <= duration_)
     return;
 
   Ranges<TimeDelta> ranges = stream->GetBufferedRanges(kInfiniteDuration());
   DCHECK_GT(ranges.size(), 0u);
 
   base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
   if (last_timestamp_buffered > duration_)
     UpdateDuration(last_timestamp_buffered);
 }
 
 void ChunkDemuxer::DecreaseDurationIfNecessary() {
   Ranges<TimeDelta> ranges = GetBufferedRanges();
   if (ranges.size() == 0u)
     return;
 
   base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
   if (last_timestamp_buffered < duration_)
     UpdateDuration(last_timestamp_buffered);
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media