Rename MediaSourceState -> SourceBufferState

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 <limits>
 #include <utility>
 
@@ skipping 63 matching lines @@
   if (!read_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kOk,
                                         StreamParserBuffer::CreateEOSBuffer());
   }
 }
 
 bool ChunkDemuxerStream::IsSeekWaitingForData() const {
   base::AutoLock auto_lock(lock_);
 
   // This method should not be called for text tracks. See the note in
-  // MediaSourceState::IsSeekWaitingForData().
+  // SourceBufferState::IsSeekWaitingForData().
   DCHECK_NE(type_, DemuxerStream::TEXT);
 
   return stream_->IsSeekPending();
 }
 
 void ChunkDemuxerStream::Seek(TimeDelta time) {
   DVLOG(1) << "ChunkDemuxerStream::Seek(" << time.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   DCHECK(state_ == UNINITIALIZED || state_ == RETURNING_ABORT_FOR_READS)
@@ skipping 494 matching lines @@
       StreamParserFactory::Create(type, parsed_codec_ids, media_log_));
 
   if (!stream_parser)
     return ChunkDemuxer::kNotSupported;
 
   std::unique_ptr<FrameProcessor> frame_processor(
       new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
                                     base::Unretained(this)),
                          media_log_));
 
-  std::unique_ptr<MediaSourceState> source_state(
-      new MediaSourceState(std::move(stream_parser), std::move(frame_processor),
-                           base::Bind(&ChunkDemuxer::CreateDemuxerStream,
-                                      base::Unretained(this), id),
-                           media_log_));
+  std::unique_ptr<SourceBufferState> source_state(new SourceBufferState(
+      std::move(stream_parser), std::move(frame_processor),
+      base::Bind(&ChunkDemuxer::CreateDemuxerStream, base::Unretained(this),
+                 id),
+      media_log_));
 
-  MediaSourceState::NewTextTrackCB new_text_track_cb;
+  SourceBufferState::NewTextTrackCB new_text_track_cb;
 
   if (enable_text_) {
     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
                                    base::Unretained(this));
   }
 
   pending_source_init_ids_.insert(id);
 
-  std::string expected_mss_codecs = codecs;
+  std::string expected_sbs_codecs = codecs;
   if (codecs == "" && type == "audio/aac")
-    expected_mss_codecs = "aac";
+    expected_sbs_codecs = "aac";
   if (codecs == "" && (type == "audio/mpeg" || type == "audio/mp3"))
-    expected_mss_codecs = "mp3";
+    expected_sbs_codecs = "mp3";
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this), id),
-      expected_mss_codecs, encrypted_media_init_data_cb_, new_text_track_cb);
+      expected_sbs_codecs, encrypted_media_init_data_cb_, new_text_track_cb);
 
   source_state_map_[id] = std::move(source_state);
   return kOk;
 }
 
 void ChunkDemuxer::SetTracksWatcher(
     const std::string& id,
     const MediaTracksUpdatedCB& tracks_updated_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
@@ skipping 631 matching lines @@
   base::AutoLock auto_lock(lock_);
   return GetBufferedRanges_Locked();
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges_Locked() const {
   lock_.AssertAcquired();
 
   bool ended = state_ == ENDED;
   // TODO(acolwell): When we start allowing SourceBuffers that are not active,
   // we'll need to update this loop to only add ranges from active sources.
-  MediaSourceState::RangesList ranges_list;
+  SourceBufferState::RangesList ranges_list;
   for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
        ++itr) {
     ranges_list.push_back(itr->second->GetBufferedRanges(duration_, ended));
   }
 
-  return MediaSourceState::ComputeRangesIntersection(ranges_list, ended);
+  return SourceBufferState::ComputeRangesIntersection(ranges_list, ended);
 }
 
 void ChunkDemuxer::StartReturningData() {
   for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
        ++itr) {
     itr->second->StartReturningData();
   }
 }
 
 void ChunkDemuxer::AbortPendingReads_Locked() {
@@ skipping 18 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
        ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media