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),
       weak_factory_(this) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
@@ skipping 237 matching lines @@
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
   duration_ = duration;
   if (!duration_change_cb_.is_null())
     duration_change_cb_.Run();
 }
 
 void Pipeline::OnStateTransition(PipelineStatus status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
+  // When demuxer has finished the init segment, it should call ReportMetadata

[DaleCurtis, 2014/11/20 18:59:51]

This is too general of a location for this code; this method simply trampolines
to the state machinery.

It should instead be immediately prior to the next state transition which should
be kInitRenderer.

+  // in case meeting 'decode' error when passing media segment but
+  // WebMediaPlayer's ready_state_ is still ReadyStateHaveNothing. In that case
+  // it will be treated as NetworkStateFormatError not NetworkStateDecodeError.
+  if (state_ == kInitDemuxer && status == PIPELINE_OK) {
+    ReportMetadata();
+    start_timestamp_ = demuxer_->GetStartTime();
+  }
   // Force post to process state transitions after current execution frame.
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &Pipeline::StateTransitionTask, weak_factory_.GetWeakPtr(), status));
 }
 
 void Pipeline::StateTransitionTask(PipelineStatus status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 22 matching lines @@
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitRenderer:
       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();
-      }
-
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 
       DCHECK(start_timestamp_ >= base::TimeDelta());
       renderer_->StartPlayingFrom(start_timestamp_);
 
       if (text_renderer_)
         text_renderer_->StartPlaying();
 
       PlaybackRateChangedTask(GetPlaybackRate());
       VolumeChangedTask(GetVolume());
@@ skipping 336 matching lines @@
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, weak_this),
       base::Bind(&Pipeline::OnRendererEnded, weak_this),
       base::Bind(&Pipeline::OnError, weak_this),
       base::Bind(&Pipeline::BufferingStateChanged, 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();
   }
-  metadata_cb_.Run(metadata);
+  if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
+    metadata.has_audio = true;
+  }
+  base::ResetAndReturn(&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