Replace StreamParserHost interface with callbacks.

media/webm/webm_stream_parser.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/webm/webm_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
@@ skipping 163 matching lines @@
       AVStreamToVideoDecoderConfig(stream, &video_config_);
       no_supported_streams = false;
       continue;
     }
   }
 
   return !no_supported_streams;
 }
 
 WebMStreamParser::WebMStreamParser()
-    : state_(kWaitingForInit),
-      host_(NULL) {
+    : state_(kWaitingForInit) {
 }
 
 WebMStreamParser::~WebMStreamParser() {}
 
-void WebMStreamParser::Init(const InitCB& init_cb, StreamParserHost* host) {
+void WebMStreamParser::Init(const InitCB& init_cb,
+                            const NewConfigCB& config_cb,
+                            const NewBuffersCB& audio_cb,
+                            const NewBuffersCB& video_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
-  DCHECK(!host_);
   DCHECK(!init_cb.is_null());
-  DCHECK(host);
+  DCHECK(!config_cb.is_null());
+  DCHECK(!audio_cb.is_null() || !video_cb.is_null());
 
   ChangeState(kParsingHeaders);
   init_cb_ = init_cb;
-  host_ = host;
+  config_cb_ = config_cb;
+  audio_cb_ = audio_cb;
+  video_cb_ = video_cb;
 }
 
 void WebMStreamParser::Flush() {
   DCHECK_NE(state_, kWaitingForInit);
 
   byte_queue_.Reset();
 
   if (state_ != kParsingClusters)
     return;
 
@@ skipping 111 matching lines @@
     double mult = info_parser.timecode_scale() / 1000.0;
     int64 duration_in_us = info_parser.duration() * mult;
     duration = base::TimeDelta::FromMicroseconds(duration_in_us);
   }
 
   FFmpegConfigHelper config_helper;
 
   if (!config_helper.Parse(data, bytes_parsed))
     return -1;
 
-  host_->OnNewConfigs(config_helper.audio_config(),
-                      config_helper.video_config());
+  config_cb_.Run(config_helper.audio_config(),config_helper.video_config());
 
   cluster_parser_.reset(new WebMClusterParser(
       info_parser.timecode_scale(),
       tracks_parser.audio_track_num(),
       tracks_parser.audio_default_duration(),
       tracks_parser.video_track_num(),
       tracks_parser.video_default_duration(),
       tracks_parser.video_encryption_key_id(),
       tracks_parser.video_encryption_key_id_size()));
 
@@ skipping 22 matching lines @@
     }
     // Skip the element.
     return result + element_size;
   }
 
   int bytes_parsed = cluster_parser_->Parse(data, size);
 
   if (bytes_parsed <= 0)
     return bytes_parsed;
 
-  const StreamParserHost::BufferQueue& audio_buffers =
-      cluster_parser_->audio_buffers();
-  const StreamParserHost::BufferQueue& video_buffers =
-      cluster_parser_->video_buffers();
+  const BufferQueue& audio_buffers = cluster_parser_->audio_buffers();
+  const BufferQueue& video_buffers = cluster_parser_->video_buffers();
 
-  if (!audio_buffers.empty() && !host_->OnAudioBuffers(audio_buffers))
+  if (!audio_buffers.empty() && !audio_cb_.Run(audio_buffers))
     return -1;
 
-  if (!video_buffers.empty() && !host_->OnVideoBuffers(video_buffers))
+  if (!video_buffers.empty() && !video_cb_.Run(video_buffers))
     return -1;
 
   return bytes_parsed;
 }
 
 }  // namespace media