Refactoring StreamParser & StreamParserHost interfaces.

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_(WAITING_FOR_INIT),
+    : state_(kWaitingForInit),
       host_(NULL) {
 }
 
 WebMStreamParser::~WebMStreamParser() {}
 
 void WebMStreamParser::Init(const InitCB& init_cb, StreamParserHost* host) {
-  DCHECK_EQ(state_, WAITING_FOR_INIT);
+  DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!host_);
   DCHECK(!init_cb.is_null());
   DCHECK(host);
 
-  ChangeState(PARSING_HEADERS);
+  ChangeState(kParsingHeaders);
   init_cb_ = init_cb;
   host_ = host;
 }
 
 void WebMStreamParser::Flush() {
-  DCHECK_NE(state_, WAITING_FOR_INIT);
+  DCHECK_NE(state_, kWaitingForInit);
 
-  if (state_ != PARSING_CLUSTERS)
+  byte_queue_.Reset();
+
+  if (state_ != kParsingClusters)
     return;
 
   cluster_parser_->Reset();
 }
 
-int WebMStreamParser::Parse(const uint8* buf, int size) {
-  DCHECK_NE(state_, WAITING_FOR_INIT);
+bool WebMStreamParser::Parse(const uint8* buf, int size) {
+  DCHECK_NE(state_, kWaitingForInit);
 
-  if (state_ == PARSING_HEADERS)
-    return ParseInfoAndTracks(buf, size);
+  if (state_ == kError)
+    return false;
 
-  if (state_ == PARSING_CLUSTERS)
-    return ParseCluster(buf, size);
+  byte_queue_.Push(buf, size);
 
-  return -1;
+  int result = 0;
+  int bytes_parsed = 0;
+  const uint8* cur = NULL;
+  int cur_size = 0;
+
+  byte_queue_.Peek(&cur, &cur_size);
+  do {
+    switch (state_) {
+      case kParsingHeaders:
+        result = ParseInfoAndTracks(cur, cur_size);
+        break;
+
+      case kParsingClusters:
+        result = ParseCluster(cur, cur_size);
+        break;
+
+      case kWaitingForInit:
+      case kError:
+        return false;
+    }
+
+    if (result < 0) {
+      ChangeState(kError);
+      return false;
+    }
+
+    cur += result;
+    cur_size -= result;
+    bytes_parsed += result;
+  } while (result > 0 && cur_size > 0);
+
+  byte_queue_.Pop(bytes_parsed);
+  return true;
 }
 
 void WebMStreamParser::ChangeState(State new_state) {
   state_ = new_state;
 }
 
 int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   DCHECK(data);
   DCHECK_GT(size, 0);
 
@@ skipping 57 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;
 
-  if (config_helper.audio_config().IsValidConfig())
-    host_->OnNewAudioConfig(config_helper.audio_config());
-
-  if (config_helper.video_config().IsValidConfig())
-    host_->OnNewVideoConfig(config_helper.video_config());
+  host_->OnNewConfigs(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()));
 
-  ChangeState(PARSING_CLUSTERS);
+  ChangeState(kParsingClusters);
   init_cb_.Run(true, duration);
   init_cb_.Reset();
 
   return bytes_parsed;
 }
 
 int WebMStreamParser::ParseCluster(const uint8* data, int size) {
   if (!cluster_parser_.get())
     return -1;
 
@@ skipping 26 matching lines @@
   if (!audio_buffers.empty() && !host_->OnAudioBuffers(audio_buffers))
     return -1;
 
   if (!video_buffers.empty() && !host_->OnVideoBuffers(video_buffers))
     return -1;
 
   return bytes_parsed;
 }
 
 }  // namespace media