MSE: Remove Chromium-side support for LegacyFrameProcessor

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
-#include "media/filters/legacy_frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 static TimeDelta EndTimestamp(const StreamParser::BufferQueue& queue) {
   return queue.back()->timestamp() + queue.back()->duration();
 }
 
@@ skipping 1101 matching lines @@
   SeekAllSources(seek_time);
 
   if (seek_cb_.is_null()) {
     cancel_next_seek_ = true;
     return;
   }
 
   base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 }
 
-ChunkDemuxer::Status ChunkDemuxer::AddId(
-    const std::string& id,
-    const std::string& type,
-    std::vector<std::string>& codecs,
-    const bool use_legacy_frame_processor) {
+ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
+                                         const std::string& type,
+                                         std::vector<std::string>& codecs) {
   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));
 
   if (!stream_parser)
     return ChunkDemuxer::kNotSupported;
 
   if ((has_audio && !source_id_audio_.empty()) ||
       (has_video && !source_id_video_.empty()))
     return kReachedIdLimit;
 
   if (has_audio)
     source_id_audio_ = id;
 
   if (has_video)
     source_id_video_ = id;
 
-  scoped_ptr<FrameProcessorBase> frame_processor;
-  if (use_legacy_frame_processor) {
-    frame_processor.reset(new LegacyFrameProcessor(
-        base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
-                   base::Unretained(this))));
-  } else {
-    frame_processor.reset(new FrameProcessor(
-        base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
-                   base::Unretained(this))));
-  }
+  scoped_ptr<FrameProcessorBase> frame_processor(

[acolwell GONE FROM CHROMIUM, 2014/06/13 18:26:42]

s/Base//?

[wolenetz, 2014/06/16 20:01:38]

Done. I'm leaving the merger of FrameProcessorBase and FrameProcessor to a later
CL.

+      new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
+                         base::Unretained(this))));
 
   scoped_ptr<SourceState> source_state(
       new SourceState(stream_parser.Pass(),
                       frame_processor.Pass(), log_cb_,
                       base::Bind(&ChunkDemuxer::CreateDemuxerStream,
                                  base::Unretained(this))));
 
   SourceState::NewTextTrackCB new_text_track_cb;
 
   if (enable_text_) {
@@ skipping 552 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media