Rename WebSourceBuffer::abort -> resetParserState

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 <list>
 
@@ skipping 108 matching lines @@
   // frame processing. |init_segment_received_cb| is run for each new fully
   // parsed initialization segment.
   bool Append(const uint8* data,
               size_t length,
               TimeDelta append_window_start,
               TimeDelta append_window_end,
               TimeDelta* timestamp_offset,
               const InitSegmentReceivedCB& init_segment_received_cb);
 
   // Aborts the current append sequence and resets the parser.
-  void Abort(TimeDelta append_window_start,
-             TimeDelta append_window_end,
-             TimeDelta* timestamp_offset);
+  void ResetParserState(TimeDelta append_window_start,
+                        TimeDelta append_window_end,
+                        TimeDelta* timestamp_offset);
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
   // If the buffer is full, attempts to try to free up space, as specified in
   // the "Coded Frame Eviction Algorithm" in the Media Source Extensions Spec.
   // Returns false iff buffer is still full after running eviction.
   // https://w3c.github.io/media-source/#sourcebuffer-coded-frame-eviction
   bool EvictCodedFrames(DecodeTimestamp media_time, size_t newDataSize);
@@ skipping 206 matching lines @@
         << __FUNCTION__ << ": stream parsing failed."
         << " Data size=" << length
         << " append_window_start=" << append_window_start.InSecondsF()
         << " append_window_end=" << append_window_end.InSecondsF();
   }
   timestamp_offset_during_append_ = NULL;
   init_segment_received_cb_.Reset();
   return result;
 }
 
-void SourceState::Abort(TimeDelta append_window_start,
-                        TimeDelta append_window_end,
-                        base::TimeDelta* timestamp_offset) {
+void SourceState::ResetParserState(TimeDelta append_window_start,
+                                   TimeDelta append_window_end,
+                                   base::TimeDelta* timestamp_offset) {
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
   timestamp_offset_during_append_ = timestamp_offset;
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
 
   stream_parser_->Flush();
   timestamp_offset_during_append_ = NULL;
 
   frame_processor_->Reset();
@@ skipping 1135 matching lines @@
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
     }
 
     ranges = GetBufferedRanges_Locked();
   }
 
   for (size_t i = 0; i < ranges.size(); ++i)
     host_->AddBufferedTimeRange(ranges.start(i), ranges.end(i));
 }
 
-void ChunkDemuxer::Abort(const std::string& id,
-                         TimeDelta append_window_start,
-                         TimeDelta append_window_end,
-                         TimeDelta* timestamp_offset) {
-  DVLOG(1) << "Abort(" << id << ")";
+void ChunkDemuxer::ResetParserState(const std::string& id,
+                                    TimeDelta append_window_start,
+                                    TimeDelta append_window_end,
+                                    TimeDelta* timestamp_offset) {
+  DVLOG(1) << "ResetParserState(" << id << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
   CHECK(IsValidId(id));
   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
-  source_state_map_[id]->Abort(append_window_start,
-                               append_window_end,
-                               timestamp_offset);
-  // Abort can possibly emit some buffers.
+  source_state_map_[id]->ResetParserState(append_window_start,
+                                          append_window_end,
+                                          timestamp_offset);
+  // ResetParserState can possibly emit some buffers.
   // Need to check whether seeking can be completed.
   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
       !seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   }
 }
 
 void ChunkDemuxer::Remove(const std::string& id, TimeDelta start,
                           TimeDelta end) {
   DVLOG(1) << "Remove(" << id << ", " << start.InSecondsF()
@@ skipping 419 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media