Convert WMPI state management to level-triggered.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 100 matching lines @@
 #if !defined(OS_ANDROID)
   // Suspend/Resume is only enabled by default on Android.
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableMediaSuspend);
 #else
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableMediaSuspend);
 #endif
 }
 
+bool IsNetworkStateError(blink::WebMediaPlayer::NetworkState state) {
+  bool result = (state == blink::WebMediaPlayer::NetworkStateFormatError ||
+                 state == blink::WebMediaPlayer::NetworkStateNetworkError ||
+                 state == blink::WebMediaPlayer::NetworkStateDecodeError);
+  DCHECK_EQ(state > blink::WebMediaPlayer::NetworkStateLoaded, result);
+  return result;
+}
+
 }  // namespace
 
 class BufferedDataSourceHostImpl;
 
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeUnspecified,
                    UrlData::CORS_UNSPECIFIED);
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeAnonymous, UrlData::CORS_ANONYMOUS);
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeUseCredentials,
                    UrlData::CORS_USE_CREDENTIALS);
 
 #define BIND_TO_RENDER_LOOP(function) \
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr())))
 
 #define BIND_TO_RENDER_LOOP1(function, arg1) \
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     scoped_ptr<RendererFactory> renderer_factory,
     linked_ptr<UrlIndex> url_index,
     const WebMediaPlayerParams& params)
     : frame_(frame),
+      play_state_(PlayState::GONE),
+      idle_suspend_(false),
+      must_suspend_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
+      highest_ready_state_(WebMediaPlayer::ReadyStateHaveNothing),

[DaleCurtis, 2016/03/26 01:12:55]

Is this sufficient? What happens when a seek takes longer than idle timeout
while in the paused state?

[sandersd (OOO until July 31), 2016/03/28 21:31:58]

Currently the logic is that a suspend while seeking does not complete until
after Resume(), so if the page is waiting for the seeked event to play() there
will be a problem. We could change it to complete before suspending, but that
prevents us from implementing seek cancellation for suspend.

As a matter of compatibility, we may want to change this so that idle suspend
always waits for a stable state before suspending. It would add some complexity
to PipelineController but is probably manageable.

For maximum compatibility, we could avoid idle suspending for the same reasons
that removed video elements stay alive, but not doing that was a key goal for
idle suspend.

       preload_(BufferedDataSource::AUTO),
       buffering_strategy_(
           BufferedDataSourceInterface::BUFFERING_STRATEGY_NORMAL),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(params.media_task_runner()),
       worker_task_runner_(params.worker_task_runner()),
       media_log_(params.media_log()),
       pipeline_(media_task_runner_, media_log_.get()),
       pipeline_controller_(
           &pipeline_,
           base::Bind(&WebMediaPlayerImpl::CreateRenderer,
                      base::Unretained(this)),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSeeked, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSuspended, AsWeakPtr()),
-          base::Bind(&WebMediaPlayerImpl::OnPipelineResumed, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineError, AsWeakPtr())),
       load_type_(LoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       should_notify_time_changed_(false),
       fullscreen_(false),
@@ skipping 171 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
     cast_impl_.play();
     return;
   }
 #endif
 
-  const bool was_paused = paused_;
   paused_ = false;
+  idle_suspend_ = false;
   pipeline_.SetPlaybackRate(playback_rate_);
 
   if (data_source_)
     data_source_->MediaIsPlaying();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PLAY));
-
-  if (playback_rate_ > 0 && was_paused) {
-    NotifyPlaybackStarted();
-
-    // Resume the player if allowed. We always call Resume() in case there is a
-    // pending suspend that should be aborted. If the pipeline is not suspended,
-    // Resume() will have no effect.
-    if (IsAutomaticResumeAllowed())
-      pipeline_controller_.Resume();
-  }
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  const bool was_already_paused = paused_ || playback_rate_ == 0;
+  // We update the paused state even when casting, since we expect pause() to be
+  // called when casting begins, and when we exit casting we should end up in a
+  // paused state.
   paused_ = true;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
     cast_impl_.pause();
     return;
   }
 #endif
 
   pipeline_.SetPlaybackRate(0.0);
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
-
-  if (!was_already_paused)
-    NotifyPlaybackPaused();
+  UpdatePlayState();
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << "s)";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DoSeek(base::TimeDelta::FromSecondsD(seconds), true);
 }
 
 void WebMediaPlayerImpl::DoSeek(base::TimeDelta time, bool time_updated) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  ended_ = false;
-
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
     cast_impl_.seek(time);
     return;
   }
 #endif
 
   ReadyState old_state = ready_state_;
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
@@ skipping 13 matching lines @@
     // ready state change to eventually happen.
     if (old_state == ReadyStateHaveEnoughData) {
       main_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WebMediaPlayerImpl::OnPipelineBufferingStateChanged,
                      AsWeakPtr(), BUFFERING_HAVE_ENOUGH));
     }
     return;
   }
 
+  // TODO(sandersd): Ideally we would not clear the idle state if
+  // |pipeline_controller_| can elide the seek.
+  idle_suspend_ = false;
+  ended_ = false;
+
   seeking_ = true;
   seek_time_ = time;
   if (paused_)
     paused_time_ = time;
   pipeline_controller_.Seek(time, time_updated);
 
-  // Resume the pipeline if allowed so that the correct frame is displayed. We
-  // always call Resume() in case there is a pending suspend that should be
-  // aborted. If the pipeline is not suspended, Resume() will have no effect.
-  if (IsAutomaticResumeAllowed())
-    pipeline_controller_.Resume();
+  // This needs to be called after Seek() so that if a resume is triggered, it
+  // is to the correct time.
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DVLOG(1) << __FUNCTION__ << "(" << rate << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
   if (rate < 0.0)
     return;
 
   // Limit rates to reasonable values by clamping.
   if (rate != 0.0) {
     if (rate < kMinRate)
       rate = kMinRate;
     else if (rate > kMaxRate)
       rate = kMaxRate;
-    if (playback_rate_ == 0 && !paused_)
-      NotifyPlaybackStarted();
-  } else if (playback_rate_ != 0 && !paused_) {
-    NotifyPlaybackPaused();
   }
 
   playback_rate_ = rate;
   if (!paused_) {
     pipeline_.SetPlaybackRate(rate);
     if (data_source_)
       data_source_->MediaPlaybackRateChanged(rate);
   }
 }
 
@@ skipping 77 matching lines @@
   return blink::WebSize(pipeline_metadata_.natural_size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote())
     return cast_impl_.paused();
 #endif
+
   return pipeline_.GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return false;
 
   return seeking_;
@@ skipping 308 matching lines @@
     paused_time_ = pipeline_.GetMediaTime();
 #endif
   }
   if (time_updated)
     should_notify_time_changed_ = true;
 }
 
 void WebMediaPlayerImpl::OnPipelineSuspended() {
 #if defined(OS_ANDROID)
   if (isRemote()) {
-    if (delegate_)
-      delegate_->PlayerGone(delegate_id_);
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
-    if (frame) {
+    if (frame)
       compositor_->PaintFrameUsingOldRenderingPath(frame);
-    }
   }
 #endif
 
-  memory_usage_reporting_timer_.Stop();
-  ReportMemoryUsage();
-
   // If we're not in an aggressive buffering state, tell the data source we have
   // enough data so that it may release the connection.
   if (buffering_strategy_ !=
       BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE) {
     if (data_source_)
       data_source_->OnBufferingHaveEnough(true);
   }
 
+  ReportMemoryUsage();
+
   if (pending_suspend_resume_cycle_) {
     pending_suspend_resume_cycle_ = false;
-    pipeline_controller_.Resume();
-    return;
+    UpdatePlayState();
   }
 }
 
-void WebMediaPlayerImpl::OnPipelineResumed() {
-  if (playback_rate_ > 0 && !paused_) {
-    NotifyPlaybackStarted();
-  } else if (!playback_rate_ || paused_ || ended_) {
-    // Resend our paused notification so the pipeline is considered for idle
-    // resource reclamation; duplicate pause notifications are ignored.
-    NotifyPlaybackPaused();
-  }
-}
-
 void WebMediaPlayerImpl::OnPipelineEnded() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Ignore state changes until we've completed all outstanding operations.
   if (!pipeline_controller_.IsStable())
     return;
 
   ended_ = true;
   client_->timeChanged();
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(error, PIPELINE_OK);
 
   if (suppress_destruction_errors_)
     return;
 
-  // Release the delegate for player errors; this drops the media session and
-  // avoids idle suspension from ticking.
-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
-
 #if defined(OS_ANDROID)
   // For 10% of pipeline decode failures log the playback URL. The URL is set
   // as the crash-key 'subresource_url' during DoLoad().
   //
   // TODO(dalecurtis): This is temporary to track down higher than average
   // decode failure rates for video-only content. See http://crbug.com/595076.
   if (base::RandDouble() <= 0.1 && error == PIPELINE_ERROR_DECODE)
     base::debug::DumpWithoutCrashing();
 #endif
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing) {
     // Any error that occurs before reaching ReadyStateHaveMetadata should
     // be considered a format error.
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
-    return;
+  } else {
+    SetNetworkState(PipelineErrorToNetworkState(error));
   }
 
-  SetNetworkState(PipelineErrorToNetworkState(error));
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnPipelineMetadata(
     PipelineMetadata metadata) {
   DVLOG(1) << __FUNCTION__;
 
   pipeline_metadata_ = metadata;
 
   UMA_HISTOGRAM_ENUMERATION("Media.VideoRotation", metadata.video_rotation,
                             VIDEO_ROTATION_MAX + 1);
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
   if (hasVideo()) {
     DCHECK(!video_weblayer_);
     scoped_refptr<cc::VideoLayer> layer =
         cc::VideoLayer::Create(compositor_, pipeline_metadata_.video_rotation);
 
     if (pipeline_metadata_.video_rotation == VIDEO_ROTATION_90 ||
         pipeline_metadata_.video_rotation == VIDEO_ROTATION_270) {
       gfx::Size size = pipeline_metadata_.natural_size;
       pipeline_metadata_.natural_size = gfx::Size(size.height(), size.width());
     }
 
     video_weblayer_.reset(new cc_blink::WebLayerImpl(layer));
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
     video_weblayer_->SetContentsOpaqueIsFixed(true);
     client_->setWebLayer(video_weblayer_.get());
   }
 
-  // Tell the delegate we can now be safely suspended due to inactivity if a
-  // subsequent play event does not occur.
-  if (paused_)
-    NotifyPlaybackPaused();
-
-  // If the frame is hidden, it may be time to suspend playback.
-  if (delegate_ && delegate_->IsHidden())
-    OnHidden();
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnPipelineBufferingStateChanged(
     BufferingState buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << buffering_state << ")";
 
   // Ignore buffering state changes until we've completed all outstanding
   // operations.
   if (!pipeline_controller_.IsStable())
     return;
 
   // TODO(scherkus): Handle other buffering states when Pipeline starts using
   // them and translate them ready state changes http://crbug.com/144683
   DCHECK_EQ(buffering_state, BUFFERING_HAVE_ENOUGH);
   SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   // Let the DataSource know we have enough data. It may use this information to
   // release unused network connections.
   if (data_source_)
     data_source_->OnBufferingHaveEnough(false);
 
   // Blink expects a timeChanged() in response to a seek().
   if (should_notify_time_changed_)
     client_->timeChanged();
 
   // Once we have enough, start reporting the total memory usage. We'll also
   // report once playback starts.
   ReportMemoryUsage();
+
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(
       new WebMediaSourceImpl(chunk_demuxer_, media_log_));
 }
 
 void WebMediaPlayerImpl::OnAddTextTrack(
     const TextTrackConfig& config,
@@ skipping 13 matching lines @@
       new WebInbandTextTrackImpl(web_kind, web_label, web_language, web_id));
 
   scoped_ptr<TextTrack> text_track(new TextTrackImpl(
       main_task_runner_, client_, std::move(web_inband_text_track)));
 
   done_cb.Run(std::move(text_track));
 }
 
 void WebMediaPlayerImpl::OnHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  if (!IsSuspendUponHiddenEnabled())
-    return;
-
-#if defined(OS_ANDROID)  // WMPI_CAST
-  // If we're remote, the pipeline should already be suspended.
-  if (isRemote())
-    return;
-#endif
-
-  // Don't suspend before metadata is available, as we don't know if there is a
-  // video track yet.
-  if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
-    return;
-
-  // Don't suspend players which only have audio and have not completed
-  // playback. The user can still control these players via the MediaSession UI.
-  // If the player has never started playback, OnSuspendRequested() will handle
-  // release of any idle resources.
-  if (!hasVideo() && !paused_ && !ended_)
-    return;
-
-  // Always reset the buffering strategy to normal when suspending for hidden to
-  // prevent an idle network connection from lingering.
-  setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal);
-  pipeline_controller_.Suspend();
-  // If we're in the middle of a suspend/resume cycle we no longer want to
-  // resume when the suspend completes.
-  pending_suspend_resume_cycle_ = false;

[DaleCurtis, 2016/03/26 01:12:55]

You dropped this bit. I think it's still necessary.

[sandersd (OOO until July 31), 2016/03/28 21:31:58]

We need to eventually suspend, and as soon as we do this bit is cleared.
|pending_suspend_resume_cycle_| no longer controls resuming; resuming happens
automatically when nothing is causing a suspend (and backgrounding continues to
cause a suspension in this case).

-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  if (!IsSuspendUponHiddenEnabled())
-    return;
-
-#if defined(OS_ANDROID)  // WMPI_CAST
-  // If we're remote, the pipeline should stay suspended.
-  if (isRemote())
-    return;
-#endif
-
-  // If we do not yet have metadata, the only way we could have been suspended
-  // is by a OnSuspendRequested() with |must_suspend| set. In that case we need
-  // to resume, otherwise playback will be broken.
-  //
-  // Otherwise, resume if we should be playing.
-  if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata ||
-      (!ended_ && !paused_)) {
-    pipeline_controller_.Resume();
-  }
+  must_suspend_ = false;
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-#if defined(OS_ANDROID)  // WMPI_CAST
-  // If we're remote, the pipeline should already be suspended.
-  if (isRemote())
-    return;
-#endif
-
-#if defined(OS_MACOSX)
-  // TODO(sandersd): Idle suspend is disabled on OSX since hardware decoded
-  // frames are owned by the video decoder in the GPU process. A mechanism for
-  // detaching ownership from the decoder is needed. http://crbug.com/595716.
-  return;
-#else
-  // Suspend should never be requested unless required or we're already in an
-  // idle state (paused or ended).
-  DCHECK(must_suspend || paused_ || ended_);
-
-  // Always suspend, but only notify the delegate if we must; this allows any
-  // exposed UI for player controls to continue to function even though the
-  // player has now been suspended.
-  pipeline_controller_.Suspend();
-  if (must_suspend && delegate_)
-    delegate_->PlayerGone(delegate_id_);
-#endif
+  if (must_suspend) {
+    must_suspend_ = true;
+  } else {
+    idle_suspend_ = true;
+  }
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnPlay() {
   play();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerImpl::OnPause() {
   pause();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerImpl::OnVolumeMultiplierUpdate(double multiplier) {
   volume_multiplier_ = multiplier;
   setVolume(volume_);
 }
 
 void WebMediaPlayerImpl::ScheduleRestart() {
-  if (!pipeline_controller_.IsSuspended()) {
+  // TODO(watk): All restart logic should be moved into PipelineController.
+  if (pipeline_.IsRunning() && !pipeline_controller_.IsSuspended()) {
     pending_suspend_resume_cycle_ = true;
-    pipeline_controller_.Suspend();
+    UpdatePlayState();
   }
 }
 
 #if defined(OS_ANDROID)  // WMPI_CAST
 bool WebMediaPlayerImpl::isRemote() const {
   return cast_impl_.isRemote();
 }
 
 void WebMediaPlayerImpl::SetMediaPlayerManager(
     RendererMediaPlayerManagerInterface* media_player_manager) {
@@ skipping 11 matching lines @@
 void WebMediaPlayerImpl::OnRemotePlaybackEnded() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   ended_ = true;
   client_->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnDisconnectedFromRemoteDevice(double t) {
   DoSeek(base::TimeDelta::FromSecondsD(t), false);
-  if (delegate_ && !delegate_->IsHidden())
-    pipeline_controller_.Resume();
 
   // We already told the delegate we're paused when remoting started.
   client_->playbackStateChanged();
   client_->disconnectedFromRemoteDevice();
+
+  UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::SuspendForRemote() {
-  if (!pipeline_controller_.IsSuspended()) {
-    pipeline_controller_.Suspend();
-  } else {
-    // TODO(sandersd): If PipelineController::Suspend() called |suspended_cb|
-    // when already suspended, we wouldn't need this case.
+  if (pipeline_controller_.IsSuspended()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
-    if (frame) {
+    if (frame)
       compositor_->PaintFrameUsingOldRenderingPath(frame);
-    }
   }
+
+  UpdatePlayState();
 }
 
 gfx::Size WebMediaPlayerImpl::GetCanvasSize() const {
   if (!video_weblayer_)
     return pipeline_metadata_.natural_size;
 
   return video_weblayer_->bounds();
 }
 
 void WebMediaPlayerImpl::SetDeviceScaleFactor(float scale_factor) {
   cast_impl_.SetDeviceScaleFactor(scale_factor);
 }
 #endif  // defined(OS_ANDROID)  // WMPI_CAST
 
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
+
+    // Not really necessary, since the pipeline was never started, but it at
+    // least this makes sure that the error handling code is in sync.
+    UpdatePlayState();
+
     return;
   }
 
   StartPipeline();
 }
 
 void WebMediaPlayerImpl::NotifyDownloading(bool is_downloading) {
   DVLOG(1) << __FUNCTION__;
   if (!is_downloading && network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
@@ skipping 107 matching lines @@
 void WebMediaPlayerImpl::SetReadyState(WebMediaPlayer::ReadyState state) {
   DVLOG(1) << __FUNCTION__ << "(" << state << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (state == WebMediaPlayer::ReadyStateHaveEnoughData && data_source_ &&
       data_source_->assume_fully_buffered() &&
       network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   ready_state_ = state;
+  highest_ready_state_ = std::max(highest_ready_state_, ready_state_);
+
   // Always notify to ensure client has the latest value.
   client_->readyStateChanged();
 }
 
 blink::WebAudioSourceProvider* WebMediaPlayerImpl::getAudioSourceProvider() {
   return audio_source_provider_.get();
 }
 
 double WebMediaPlayerImpl::GetPipelineDuration() const {
   base::TimeDelta duration = pipeline_.GetMediaDuration();
 
   // Return positive infinity if the resource is unbounded.
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-media-duration
   if (duration == kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
   return duration.InSecondsF();
 }
 
 void WebMediaPlayerImpl::OnDurationChanged() {
+  // TODO(sandersd): Do we need to re-init the media session?

[DaleCurtis, 2016/03/26 01:12:55]

Probably a good idea. It will really only matter if we transition from < 5
seconds to > 5 seconds.

[sandersd (OOO until July 31), 2016/03/28 21:31:58]

Acknowledged.

   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return;
 
   client_->durationChanged();
 }
 
 void WebMediaPlayerImpl::OnNaturalSizeChanged(gfx::Size size) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
   TRACE_EVENT0("media", "WebMediaPlayerImpl::OnNaturalSizeChanged");
@@ skipping 42 matching lines @@
   base::WaitableEvent event(false, false);
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
-void WebMediaPlayerImpl::NotifyPlaybackStarted() {
+void WebMediaPlayerImpl::UpdatePlayState() {
+  // This includes both data source (pre-pipeline startup) and pipeline errors.
+  bool has_error = IsNetworkStateError(network_state_);
+
 #if defined(OS_ANDROID)  // WMPI_CAST
-  // We do not tell our delegates about remote playback, because that would
-  // keep the device awake, which is not what we want.
-  if (isRemote())
-    return;
+  bool casting = isRemote();

[DaleCurtis, 2016/03/26 01:12:55]

Maybe just is_remote ?

[sandersd (OOO until July 31), 2016/03/28 21:31:58]

Done.

+#else
+  bool casting = false;
 #endif
 
-  // NotifyPlaybackStarted() may be called by interactions while suspended,
-  // (play/pause in particular). Those actions won't have any effect until the
-  // pipeline is resumed.
-  // TODO(dalecurtis): Should these be dropped at the call sites instead?
-  // Alternatively, rename this method to include Maybe or Changed, and handle
-  // multiple calls safely.
-  if (pipeline_controller_.IsSuspended())
-    return;
+  // After HaveMetadata, we know which tracks are present and the duration.
+  bool have_metadata = (ready_state_ >= WebMediaPlayer::ReadyStateHaveMetadata);

[DaleCurtis, 2016/03/26 01:12:55]

nit: no unnecessary parens. ditto for below.

[sandersd (OOO until July 31), 2016/03/28 21:31:58]

Done.

 
+  // After HaveFutureData, Blink will call play() if the state is not paused.
+  bool have_future_data =
+      (highest_ready_state_ >= WebMediaPlayer::ReadyStateHaveFutureData);
+
+  // Background suspend is not enabled for audio-only players.
+  bool backgrounded =
+      IsSuspendUponHiddenEnabled() && delegate_ && delegate_->IsHidden();
+  bool background_suspended = backgrounded && have_metadata && hasVideo();
+
+  // Idle suspend is enabled once there is future data. We don't want to idle
+  // suspend before that because play() may never be triggered to leave the idle
+  // state.
+  //
+  // TODO(sandersd): Make the delegate suspend idle players immediately when
+  // hidden.
+  // TODO(sandersd): If Blink told us the paused state sooner, we could
+  // idle suspend sooner.
+  bool idle_suspended = idle_suspend_ && have_future_data;
+
+  // Combined suspend state.
+  //
+  // |pending_suspend_resume_cycle_| is skipped here, mostly to keep it as
+  // separate as possible.
+  bool suspended =
+      casting || must_suspend_ || idle_suspended || background_suspended;
+
+  // We do not treat |playback_rate_| == 0 as paused. We could, but this
+  // interpretation keeps everything in sync with the media session. (It doesn't
+  // make sense to pause the media session because there is no way for the play
+  // button to resume playback.) Similarly, we don't consider |ended_|, since
+  // Blink will immediately either pause or seek.
+  //
+  // |is_playing| decides whether the memory usage reporting timer is enabled.
+  //
+  // |has_session| is used to decide when to create a media session. It is
+  // similer, but excludes idle suspension, because in the audio-only case we

[watk, 2016/03/29 00:47:53]

similar

[sandersd (OOO until July 31), 2016/03/30 23:46:00]

Acknowledged.

+  // expect that the notification controls to remain. We also require:

[watk, 2016/03/29 00:47:53]

s/that the/the

[sandersd (OOO until July 31), 2016/03/30 23:46:00]

Done.

+  //   - |have_metadata|, since the tracks and duration are passed to DidPlay().
+  //   - |have_future_data|, since we need to know whether we are paused to
+  //     correctly configure the session.
+  // These conditions are common with |is_playing|, but would need to be made
+  // explicit if the definition of |is_playing| changes.
+  //
+  // TODO(sandersd): If Blink told us the paused state sooner, we could create
+  // the media session sooner.
+  bool can_play = !has_error && !casting && have_future_data;
+  bool is_playing = can_play && !suspended && !paused_;
+  bool has_session = can_play && !must_suspend_ && !background_suspended;
+
+  // If there is a delegate, let it know what to do with the media session (and
+  // implicitly the idle timer as well).
   if (delegate_) {
-    delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
-                       pipeline_.GetMediaDuration());
+    if (!has_session) {
+      UpdatePlayState_SetPlayState(PlayState::GONE);
+    } else if (paused_) {
+      UpdatePlayState_SetPlayState(ended_ ? PlayState::ENDED
+                                          : PlayState::PAUSED);
+    } else {
+      UpdatePlayState_SetPlayState(PlayState::PLAYING);
+    }
   }
-  if (!memory_usage_reporting_timer_.IsRunning()) {
+
+  // Make sure that suspend state is in sync, unless there was an error (in that
+  // case we don't want to change the state).
+  //
+  // Suspend() and Resume() are idempotent, so we don't need to worry about
+  // calling them multiple times.
+  if (!has_error) {
+    if (suspended || pending_suspend_resume_cycle_) {
+      pipeline_controller_.Suspend();
+    } else {
+      pipeline_controller_.Resume();
+    }
+  }
+
+  // Make sure that the memory usage reporting timer is running whenever we are
+  // playing. It's not critical if some cases where memory usage can change are
+  // missed, since media memory changes are usually gradual.
+  if (is_playing && !memory_usage_reporting_timer_.IsRunning()) {
     memory_usage_reporting_timer_.Start(FROM_HERE,
                                         base::TimeDelta::FromSeconds(2), this,
                                         &WebMediaPlayerImpl::ReportMemoryUsage);
+  } else if (memory_usage_reporting_timer_.IsRunning()) {

[watk, 2016/03/29 00:47:53]

Should this be: else if (!is_playing &&
memory_usage_reporting_timer.IsRunning())?

[sandersd (OOO until July 31), 2016/03/30 23:46:00]

Acknowledged.

+    memory_usage_reporting_timer_.Stop();
+    ReportMemoryUsage();
   }
 }
 
-void WebMediaPlayerImpl::NotifyPlaybackPaused() {
-#if defined(OS_ANDROID)  // WMPI_CAST
-  if (isRemote())
-    return;
-#endif
+void WebMediaPlayerImpl::UpdatePlayState_SetPlayState(PlayState new_state) {
+  DCHECK(delegate_);
 
-  // Same as above, NotifyPlaybackPaused() may be called by interactions while
-  // suspended, but those actions won't have any effect until the pipeline is
-  // resumed.
-  if (pipeline_controller_.IsSuspended())
+  if (play_state_ == new_state)
     return;
 
-  if (delegate_)
-    delegate_->DidPause(delegate_id_, ended_);
-  memory_usage_reporting_timer_.Stop();
-  ReportMemoryUsage();
+  play_state_ = new_state;
+
+  switch (new_state) {
+    case PlayState::GONE:
+      delegate_->PlayerGone(delegate_id_);
+      break;
+    case PlayState::PLAYING:
+      // TODO(sandersd): Do we need to call this again on duration change?
+      delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
+                         pipeline_.GetMediaDuration());
+      break;
+    case PlayState::PAUSED:
+      delegate_->DidPause(delegate_id_, false);
+      break;
+    case PlayState::ENDED:
+      delegate_->DidPause(delegate_id_, true);
+      break;
+  }
 }
 
 void WebMediaPlayerImpl::ReportMemoryUsage() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // About base::Unretained() usage below: We destroy |demuxer_| on the main
   // thread.  Before that, however, ~WebMediaPlayerImpl() posts a task to the
   // media thread and waits for it to finish.  Hence, the GetMemoryUsage() task
   // posted here must finish earlier.
 
@@ skipping 22 matching lines @@
   DVLOG(2) << "Memory Usage -- Audio: " << stats.audio_memory_usage
            << ", Video: " << stats.video_memory_usage << ", DataSource: "
            << (data_source_ ? data_source_->GetMemoryUsage() : 0)
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
 }
 
-bool WebMediaPlayerImpl::IsAutomaticResumeAllowed() {
-#if defined(OS_ANDROID)
-  return !hasVideo() || (delegate_ && !delegate_->IsHidden());
-#else
-  // On non-Android platforms Resume() is always allowed.
-  return true;
-#endif
-}
-
 }  // namespace media