Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/chunk_demuxer.cc

Index: media/filters/chunk_demuxer.cc
diff --git a/media/filters/chunk_demuxer.cc b/media/filters/chunk_demuxer.cc
index 73dbae6c0cf4e3144b4b2a459642e6b63a74ee39..e38a615b522f7da0bb8995b9122446c79d69e88c 100644
--- a/media/filters/chunk_demuxer.cc
+++ b/media/filters/chunk_demuxer.cc
@@ -48,7 +48,7 @@ class SourceState {
   // 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);
+  bool set_timestampOffset(TimeDelta timestamp_offset);
 
   TimeDelta timestamp_offset() const { return timestamp_offset_; }
 
@@ -96,9 +96,7 @@ class 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,
@@ -109,25 +107,20 @@ void SourceState::Init(const StreamParser::InitCB& init_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);
-}
-
-bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
-  if (!can_update_offset_)
-    return false;
+  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::set_timestampOffset(TimeDelta timestamp_offset) {
+  if (!can_update_offset_) return false;
 
   timestamp_offset_ = timestamp_offset;
   return true;
@@ -144,14 +137,13 @@ void SourceState::Abort() {
 
 void SourceState::AdjustBufferTimestamps(
     const StreamParser::BufferQueue& buffers) {
-  if (timestamp_offset_ == TimeDelta())
-    return;
+  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)
+        ->SetDecodeTimestamp((*itr)->GetDecodeTimestamp() + timestamp_offset_);
+    (*itr)->set_timestamp((*itr)->get_timestamp() + timestamp_offset_);
   }
 }
 
@@ -172,8 +164,7 @@ void SourceState::OnEndOfMediaSegment() {
 
 bool SourceState::OnBuffers(const StreamParser::NewBuffersCB& new_buffers_cb,
                             const StreamParser::BufferQueue& buffers) {
-  if (new_buffers_cb.is_null())
-    return false;
+  if (new_buffers_cb.is_null()) return false;
 
   AdjustBufferTimestamps(buffers);
 
@@ -181,11 +172,9 @@ bool SourceState::OnBuffers(const StreamParser::NewBuffersCB& new_buffers_cb,
 }
 
 bool SourceState::OnTextBuffers(
-    const StreamParser::NewTextBuffersCB& new_buffers_cb,
-    TextTrack* text_track,
+    const StreamParser::NewTextBuffersCB& new_buffers_cb, TextTrack* text_track,
     const StreamParser::BufferQueue& buffers) {
-  if (new_buffers_cb.is_null())
-    return false;
+  if (new_buffers_cb.is_null()) return false;
 
   AdjustBufferTimestamps(buffers);
 
@@ -215,7 +204,7 @@ class ChunkDemuxerStream : public DemuxerStream {
   bool Append(const StreamParser::BufferQueue& buffers);
 
   // Signal to the stream that duration has changed to |duration|.
-  void OnSetDuration(base::TimeDelta duration);
+  void Onset_duration(base::TimeDelta duration);
 
   // Returns the range of buffered data in this stream, capped at |duration|.
   Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
@@ -281,15 +270,13 @@ class ChunkDemuxerStream : public DemuxerStream {
 
 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));
 }
 
@@ -312,13 +299,11 @@ void ChunkDemuxerStream::Seek(TimeDelta time) {
   DCHECK(read_cbs_.empty());
 
   // Ignore seek requests when canceled.
-  if (state_ == CANCELED)
-    return;
+  if (state_ == CANCELED) return;
 
   stream_->Seek(time);
 
-  if (state_ == WAITING_FOR_SEEK)
-    ChangeState_Locked(RETURNING_DATA_FOR_READS);
+  if (state_ == WAITING_FOR_SEEK) ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
 void ChunkDemuxerStream::CancelPendingSeek() {
@@ -345,8 +330,7 @@ void ChunkDemuxerStream::OnNewMediaSegment(TimeDelta start_timestamp) {
 }
 
 bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
-  if (buffers.empty())
-    return false;
+  if (buffers.empty()) return false;
 
   ClosureQueue closures;
   {
@@ -365,7 +349,7 @@ bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
   return true;
 }
 
-void ChunkDemuxerStream::OnSetDuration(base::TimeDelta duration) {
+void ChunkDemuxerStream::Onset_duration(base::TimeDelta duration) {
   base::AutoLock auto_lock(lock_);
   stream_->OnSetDuration(duration);
 }
@@ -375,8 +359,7 @@ Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
   base::AutoLock auto_lock(lock_);
   Ranges<TimeDelta> range = stream_->GetBufferedTime();
 
-  if (range.size() == 0u)
-    return range;
+  if (range.size() == 0u) return range;
 
   // Clamp the end of the stream's buffered ranges to fit within the duration.
   // This can be done by intersecting the stream's range with the valid time
@@ -428,18 +411,18 @@ void ChunkDemuxerStream::Shutdown() {
   // Pass end of stream buffers to all callbacks to signal that no more data
   // will be sent.
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
-    it->Run(DemuxerStream::kOk, StreamParserBuffer::CreateEOSBuffer());
+    it->Run(DemuxerStream::kOk, StreamParserBuffer::create_eos_buffer());
 }
 
 // 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) {
+    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;
   }
 
@@ -458,8 +441,8 @@ void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
     }
   }
 
-  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_; }
@@ -481,8 +464,7 @@ VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() {
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
-           << "type " << type_
-           << " - " << state_ << " -> " << state;
+           << "type " << type_ << " - " << state_ << " -> " << state;
   state_ = state;
 }
 
@@ -499,23 +481,19 @@ void ChunkDemuxerStream::DeferRead_Locked(const ReadCB& read_cb) {
 void ChunkDemuxerStream::CreateReadDoneClosures_Locked(ClosureQueue* closures) {
   lock_.AssertAcquired();
 
-  if (state_ != RETURNING_DATA_FOR_READS)
-    return;
+  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));
+    if (!GetNextBuffer_Locked(&status, &buffer)) return;
+    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) {
+    DemuxerStream::Status* status, scoped_refptr<StreamParserBuffer>* buffer) {
   lock_.AssertAcquired();
 
   switch (state_) {
@@ -528,7 +506,7 @@ bool ChunkDemuxerStream::GetNextBuffer_Locked(
           return false;
         case SourceBufferStream::kEndOfStream:
           *status = DemuxerStream::kOk;
-          *buffer = StreamParserBuffer::CreateEOSBuffer();
+          *buffer = StreamParserBuffer::create_eos_buffer();
           return true;
         case SourceBufferStream::kConfigChange:
           DVLOG(2) << "Config change reported to ChunkDemuxerStream.";
@@ -549,7 +527,7 @@ bool ChunkDemuxerStream::GetNextBuffer_Locked(
     case SHUTDOWN:
       DCHECK(read_cbs_.empty());
       *status = DemuxerStream::kOk;
-      *buffer = StreamParserBuffer::CreateEOSBuffer();
+      *buffer = StreamParserBuffer::create_eos_buffer();
       return true;
   }
 
@@ -579,8 +557,8 @@ void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   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);
@@ -608,11 +586,9 @@ void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
     base::AutoLock auto_lock(lock_);
 
     if (state_ == INITIALIZED || state_ == ENDED) {
-      if (audio_)
-        audio_->Seek(time);
+      if (audio_) audio_->Seek(time);
 
-      if (video_)
-        video_->Seek(time);
+      if (video_) video_->Seek(time);
 
       if (IsSeekPending_Locked()) {
         DVLOG(1) << "Seek() : waiting for more data to arrive.";
@@ -636,32 +612,25 @@ void ChunkDemuxer::OnAudioRendererDisabled() {
 // Demuxer implementation.
 DemuxerStream* ChunkDemuxer::GetStream(DemuxerStream::Type type) {
   base::AutoLock auto_lock(lock_);
-  if (type == DemuxerStream::VIDEO)
-    return video_.get();
+  if (type == DemuxerStream::VIDEO) return video_.get();
 
-  if (type == DemuxerStream::AUDIO)
-    return audio_.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 (state_ == SHUTDOWN) return;
 
-  if (audio_)
-    audio_->StartWaitingForSeek();
+  if (audio_) audio_->StartWaitingForSeek();
 
-  if (video_)
-    video_->StartWaitingForSeek();
+  if (video_) video_->StartWaitingForSeek();
 }
 
 void ChunkDemuxer::CancelPendingSeek() {
@@ -671,15 +640,12 @@ void ChunkDemuxer::CancelPendingSeek() {
     if (IsSeekPending_Locked() && !seek_cb_.is_null()) {
       std::swap(cb, seek_cb_);
     }
-    if (audio_)
-      audio_->CancelPendingSeek();
+    if (audio_) audio_->CancelPendingSeek();
 
-    if (video_)
-      video_->CancelPendingSeek();
+    if (video_) video_->CancelPendingSeek();
   }
 
-  if (!cb.is_null())
-    cb.Run(PIPELINE_OK);
+  if (!cb.is_null()) cb.Run(PIPELINE_OK);
 }
 
 ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
@@ -693,12 +659,10 @@ ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
 
   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 (!stream_parser) return ChunkDemuxer::kNotSupported;
 
   if ((has_audio && !source_id_audio_.empty()) ||
       (has_video && !source_id_video_.empty()))
@@ -709,23 +673,22 @@ ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
 
   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),
-      audio_cb,
-      video_cb,
+      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_,
@@ -744,14 +707,12 @@ void ChunkDemuxer::RemoveId(const std::string& id) {
   source_state_map_.erase(id);
 
   if (source_id_audio_ == id) {
-    if (audio_)
-      audio_->Shutdown();
+    if (audio_) audio_->Shutdown();
     source_id_audio_.clear();
   }
 
   if (source_id_video_ == id) {
-    if (video_)
-      video_->Shutdown();
+    if (video_) video_->Shutdown();
     source_id_video_.clear();
   }
 }
@@ -778,8 +739,7 @@ Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
 Ranges<TimeDelta> ChunkDemuxer::ComputeIntersection() const {
   lock_.AssertAcquired();
 
-  if (!audio_ || !video_)
-    return Ranges<TimeDelta>();
+  if (!audio_ || !video_) return Ranges<TimeDelta>();
 
   // Include ranges that have been buffered in both |audio_| and |video_|.
   Ranges<TimeDelta> audio_ranges = audio_->GetBufferedRanges(duration_);
@@ -800,14 +760,13 @@ Ranges<TimeDelta> ChunkDemuxer::ComputeIntersection() const {
     // 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,
+void ChunkDemuxer::AppendData(const std::string& id, const uint8* data,
                               size_t length) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
@@ -825,15 +784,12 @@ void ChunkDemuxer::AppendData(const std::string& id,
     if (state_ == ENDED) {
       ChangeState_Locked(INITIALIZED);
 
-      if (audio_)
-        audio_->CancelEndOfStream();
+      if (audio_) audio_->CancelEndOfStream();
 
-      if (video_)
-        video_->CancelEndOfStream();
+      if (video_) video_->CancelEndOfStream();
     }
 
-    if (length == 0u)
-      return;
+    if (length == 0u) return;
 
     DCHECK(data);
 
@@ -877,8 +833,7 @@ void ChunkDemuxer::AppendData(const std::string& id,
   for (size_t i = 0; i < ranges.size(); ++i)
     host_->AddBufferedTimeRange(ranges.start(i), ranges.end(i));
 
-  if (!cb.is_null())
-    cb.Run(PIPELINE_OK);
+  if (!cb.is_null()) cb.Run(PIPELINE_OK);
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
@@ -904,19 +859,17 @@ double ChunkDemuxer::GetDuration_Locked() {
   if (duration_ == kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
-  if (user_specified_duration_ >= 0)
-    return user_specified_duration_;
+  if (user_specified_duration_ >= 0) return user_specified_duration_;
 
   return duration_.InSecondsF();
 }
 
 void ChunkDemuxer::SetDuration(double duration) {
   base::AutoLock auto_lock(lock_);
-  DVLOG(1) << "SetDuration(" << duration << ")";
+  DVLOG(1) << "set_duration(" << duration << ")";
   DCHECK_GE(duration, 0);
 
-  if (duration == GetDuration_Locked())
-    return;
+  if (duration == GetDuration_Locked()) return;
 
   // Compute & bounds check the TimeDelta representation of duration.
   // This can be different if the value of |duration| doesn't fit the range or
@@ -945,19 +898,18 @@ void ChunkDemuxer::SetDuration(double duration) {
   duration_ = duration_td;
   host_->SetDuration(duration_);
 
-  if (audio_)
-    audio_->OnSetDuration(duration_);
+  if (audio_) audio_->Onset_duration(duration_);
 
-  if (video_)
-    video_->OnSetDuration(duration_);
+  if (video_) video_->Onset_duration(duration_);
 }
 
 bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
   base::AutoLock auto_lock(lock_);
-  DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
+  DVLOG(1) << "set_timestampOffset(" << id << ", " << offset.InSecondsF()
+           << ")";
   CHECK(IsValidId(id));
 
-  return source_state_map_[id]->SetTimestampOffset(offset);
+  return source_state_map_[id]->set_timestampOffset(offset);
 }
 
 void ChunkDemuxer::EndOfStream(PipelineStatus status) {
@@ -968,8 +920,7 @@ void ChunkDemuxer::EndOfStream(PipelineStatus status) {
     DCHECK_NE(state_, WAITING_FOR_INIT);
     DCHECK_NE(state_, ENDED);
 
-    if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
-      return;
+    if (state_ == SHUTDOWN || state_ == PARSE_ERROR) return;
 
     if (state_ == INITIALIZING) {
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
@@ -977,11 +928,9 @@ void ChunkDemuxer::EndOfStream(PipelineStatus status) {
     }
 
     bool old_seek_pending = IsSeekPending_Locked();
-    if (audio_)
-      audio_->EndOfStream();
+    if (audio_) audio_->EndOfStream();
 
-    if (video_)
-      video_->EndOfStream();
+    if (video_) video_->EndOfStream();
 
     // Give a chance to resume the pending seek process.
     if (status != PIPELINE_OK) {
@@ -996,8 +945,7 @@ void ChunkDemuxer::EndOfStream(PipelineStatus status) {
       std::swap(cb, seek_cb_);
   }
 
-  if (!cb.is_null())
-    cb.Run(PIPELINE_OK);
+  if (!cb.is_null()) cb.Run(PIPELINE_OK);
 }
 
 void ChunkDemuxer::Shutdown() {
@@ -1006,28 +954,24 @@ void ChunkDemuxer::Shutdown() {
   {
     base::AutoLock auto_lock(lock_);
 
-    if (state_ == SHUTDOWN)
-      return;
+    if (state_ == SHUTDOWN) return;
 
     std::swap(cb, seek_cb_);
 
-    if (audio_)
-      audio_->Shutdown();
+    if (audio_) audio_->Shutdown();
 
-    if (video_)
-      video_->Shutdown();
+    if (video_) video_->Shutdown();
 
     ChangeState_Locked(SHUTDOWN);
   }
 
-  if (!cb.is_null())
-    cb.Run(PIPELINE_ERROR_ABORT);
+  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;
 }
 
@@ -1052,14 +996,11 @@ void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   if (!init_cb_.is_null()) {
     std::swap(cb, init_cb_);
   } else {
-    if (!seek_cb_.is_null())
-      std::swap(cb, seek_cb_);
+    if (!seek_cb_.is_null()) std::swap(cb, seek_cb_);
 
-    if (audio_)
-      audio_->Shutdown();
+    if (audio_) audio_->Shutdown();
 
-    if (video_)
-      video_->Shutdown();
+    if (video_) video_->Shutdown();
   }
 
   if (!cb.is_null()) {
@@ -1076,18 +1017,16 @@ bool ChunkDemuxer::IsSeekPending_Locked() const {
   lock_.AssertAcquired();
   bool seek_pending = false;
 
-  if (audio_)
-    seek_pending = audio_->IsSeekPending();
+  if (audio_) seek_pending = audio_->IsSeekPending();
 
-  if (!seek_pending && video_)
-    seek_pending = video_->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_)) {
@@ -1103,14 +1042,11 @@ void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration) {
       (!source_id_video_.empty() && !video_))
     return;
 
-  if (audio_)
-    audio_->Seek(TimeDelta());
+  if (audio_) audio_->Seek(TimeDelta());
 
-  if (video_)
-    video_->Seek(TimeDelta());
+  if (video_) video_->Seek(TimeDelta());
 
-  if (duration_ == kNoTimestamp())
-    duration_ = kInfiniteDuration();
+  if (duration_ == kNoTimestamp()) duration_ = kInfiniteDuration();
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
@@ -1120,9 +1056,9 @@ void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration) {
 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()) {
@@ -1179,12 +1115,10 @@ bool ChunkDemuxer::OnAudioBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
-  if (!audio_)
-    return false;
+  if (!audio_) return false;
 
   CHECK(IsValidId(source_id_audio_));
-  if (!audio_->Append(buffers))
-    return false;
+  if (!audio_->Append(buffers)) return false;
 
   IncreaseDurationIfNecessary(buffers, audio_.get());
   return true;
@@ -1194,20 +1128,17 @@ bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
-  if (!video_)
-    return false;
+  if (!video_) return false;
 
   CHECK(IsValidId(source_id_video_));
-  if (!video_->Append(buffers))
-    return false;
+  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);
 
@@ -1216,14 +1147,13 @@ bool ChunkDemuxer::OnTextBuffers(
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
        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->get_timestamp();
+    const base::TimeDelta end = start + buffer->get_duration();
 
     std::string id, settings, content;
 
-    WebMWebVTTParser::Parse(buffer->GetData(),
-                            buffer->GetDataSize(),
-                            &id, &settings, &content);
+    WebMWebVTTParser::Parse(buffer->get_data(), buffer->get_data_size(), &id,
+                            &settings, &content);
 
     text_track->addWebVTTCue(start, end, id, content, settings);
   }
@@ -1269,11 +1199,9 @@ void ChunkDemuxer::UpdateDuration(base::TimeDelta new_duration) {
 }
 
 void ChunkDemuxer::IncreaseDurationIfNecessary(
-    const StreamParser::BufferQueue& buffers,
-    ChunkDemuxerStream* stream) {
+    const StreamParser::BufferQueue& buffers, ChunkDemuxerStream* stream) {
   DCHECK(!buffers.empty());
-  if (buffers.back()->GetTimestamp() <= duration_)
-    return;
+  if (buffers.back()->get_timestamp() <= duration_) return;
 
   Ranges<TimeDelta> ranges = stream->GetBufferedRanges(kInfiniteDuration());
   DCHECK_GT(ranges.size(), 0u);
@@ -1285,8 +1213,7 @@ void ChunkDemuxer::IncreaseDurationIfNecessary(
 
 void ChunkDemuxer::DecreaseDurationIfNecessary() {
   Ranges<TimeDelta> ranges = GetBufferedRanges();
-  if (ranges.size() == 0u)
-    return;
+  if (ranges.size() == 0u) return;
 
   base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
   if (last_timestamp_buffered < duration_)