Report PIPELINE_ERROR_DECODE when SourceState::Append fails.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 Pipeline::Pipeline(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     MediaLog* media_log)
     : task_runner_(task_runner),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
       volume_(1.0f),
       playback_rate_(0.0f),
       status_(PIPELINE_OK),
-      is_initialized_(false),
       state_(kCreated),
       renderer_ended_(false),
       text_renderer_ended_(false),
       demuxer_(NULL),
       pending_cdm_context_(nullptr),
       weak_factory_(this) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
@@ skipping 275 matching lines @@
   PipelineStatusCB done_cb =
       base::Bind(&Pipeline::StateTransitionTask, weak_factory_.GetWeakPtr());
 
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitRenderer:
+      // When the state_ transfers to kInitRenderer, it means the demuxer has
+      // finished parsing the init info. It should call ReportMetadata in case
+      // meeting 'decode' error when passing media segment but WebMediaPlayer's
+      // ready_state_ is still ReadyStateHaveNothing. In that case, it will
+      // treat it as NetworkStateFormatError not NetworkStateDecodeError.
+      ReportMetadata();
+      start_timestamp_ = demuxer_->GetStartTime();
+
       return InitializeRenderer(base::Bind(done_cb, PIPELINE_OK));
 
     case kPlaying:
-      // Report metadata the first time we enter the playing state.
-      if (!is_initialized_) {
-        is_initialized_ = true;
-        ReportMetadata();
-        start_timestamp_ = demuxer_->GetStartTime();
-      }
-
       DCHECK(start_timestamp_ >= base::TimeDelta());
       renderer_->StartPlayingFrom(start_timestamp_);
 
       if (text_renderer_)
         text_renderer_->StartPlaying();
 
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 
       PlaybackRateChangedTask(GetPlaybackRate());
       VolumeChangedTask(GetVolume());
@@ skipping 364 matching lines @@
       base::Bind(&Pipeline::OnUpdateStatistics, weak_this),
       base::Bind(&Pipeline::BufferingStateChanged, weak_this),
       base::ResetAndReturn(&paint_cb_),
       base::Bind(&Pipeline::OnRendererEnded, weak_this),
       base::Bind(&Pipeline::OnError, weak_this));
 }
 
 void Pipeline::ReportMetadata() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   PipelineMetadata metadata;
-  metadata.has_audio = renderer_->HasAudio();
-  metadata.has_video = renderer_->HasVideo();
   metadata.timeline_offset = demuxer_->GetTimelineOffset();
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   if (stream) {
+    metadata.has_video = true;
     metadata.natural_size = stream->video_decoder_config().natural_size();
     metadata.video_rotation = stream->video_rotation();
   }
+  if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
+    metadata.has_audio = true;
+  }
   metadata_cb_.Run(metadata);
 }
 
 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media