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 ||

[DaleCurtis, 2016/04/01 18:25:48]

Remove unnecessary parens.

[sandersd (OOO until July 31), 2016/04/01 21:22:11]

Done.

+                 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),
+      delegate_state_(DelegateState::GONE),
+      is_idle_(false),
+      must_suspend_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
+      highest_ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       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;
+  is_idle_ = 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.
+  is_idle_ = 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();
+
+  // We don't actually want this to run until |client_| calls seek() or pause(),
+  // but that should have already happened in timeChanged() and so this is
+  // expected to be a no-op.
+  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;
-  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)

[DaleCurtis, 2016/04/01 18:25:48]

This was dropped.

[sandersd (OOO until July 31), 2016/04/01 21:22:11]

Done.

-  // 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 {
+    is_idle_ = 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_.IsPipelineSuspended()) {
     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_.IsPipelineSuspended()) {
     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): We should call delegate_->DidPlay() with the new duration,
+  // especially if it changed from  <5s to >5s.
   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() {
 #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 is_remote = isRemote();
+#else
+  bool is_remote = false;
 #endif
+  bool is_backgrounded =

[DaleCurtis, 2016/04/01 18:25:48]

Naming is a bit confusing when you mix in IsSuspendUponHiddenEnabled()

[sandersd (OOO until July 31), 2016/04/01 21:22:11]

Done.

+      IsSuspendUponHiddenEnabled() && delegate_ && delegate_->IsHidden();
+  PlayState state =
+      UpdatePlayState_ComputePlayState(is_remote, is_backgrounded);
+  SetDelegateState(state.delegate_state);
+  SetMemoryReportingState(state.is_memory_reporting_enabled);
+  SetSuspendState(state.is_suspended || pending_suspend_resume_cycle_);
+}
 
-  // 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())
+void WebMediaPlayerImpl::SetDelegateState(DelegateState new_state) {
+  if (!delegate_ || delegate_state_ == new_state)
     return;
 
-  if (delegate_) {
-    delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
-                       pipeline_.GetMediaDuration());
+  delegate_state_ = new_state;
+
+  switch (delegate_state_) {
+    case DelegateState::GONE:
+      delegate_->PlayerGone(delegate_id_);
+      break;
+    case DelegateState::PLAYING:
+      delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
+                         pipeline_.GetMediaDuration());
+      break;
+    case DelegateState::PAUSED:
+      delegate_->DidPause(delegate_id_, false);
+      break;
+    case DelegateState::ENDED:
+      delegate_->DidPause(delegate_id_, true);
+      break;
   }
-  if (!memory_usage_reporting_timer_.IsRunning()) {
+}
+
+void WebMediaPlayerImpl::SetMemoryReportingState(
+    bool is_memory_reporting_enabled) {
+  if (memory_usage_reporting_timer_.IsRunning() ==
+      is_memory_reporting_enabled) {
+    return;
+  }
+
+  if (is_memory_reporting_enabled) {
     memory_usage_reporting_timer_.Start(FROM_HERE,
                                         base::TimeDelta::FromSeconds(2), this,
                                         &WebMediaPlayerImpl::ReportMemoryUsage);
+  } else {
+    memory_usage_reporting_timer_.Stop();
+    ReportMemoryUsage();
   }
 }
 
-void WebMediaPlayerImpl::NotifyPlaybackPaused() {
-#if defined(OS_ANDROID)  // WMPI_CAST
-  if (isRemote())
-    return;
-#endif
-
-  // 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())
+void WebMediaPlayerImpl::SetSuspendState(bool is_suspended) {
+  // Do not change the state after an error has occurred.
+  // TODO(sandersd): Update PipelineController to remove the need for this.
+  if (IsNetworkStateError(network_state_))
     return;
 
-  if (delegate_)
-    delegate_->DidPause(delegate_id_, ended_);
-  memory_usage_reporting_timer_.Stop();
-  ReportMemoryUsage();
+  if (is_suspended) {
+    pipeline_controller_.Suspend();
+  } else {
+    pipeline_controller_.Resume();
+  }
+}
+
+WebMediaPlayerImpl::PlayState
+WebMediaPlayerImpl::UpdatePlayState_ComputePlayState(bool is_remote,
+                                                     bool is_backgrounded) {
+  PlayState result;
+
+  // This includes both data source (before pipeline startup) and pipeline
+  // errors.
+  bool has_error = IsNetworkStateError(network_state_);
+
+  // After HaveMetadata, we know which tracks are present and the duration.
+  bool have_metadata = ready_state_ >= WebMediaPlayer::ReadyStateHaveMetadata;
+
+  // 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 background_suspended = is_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. There could be other theoretical problems if the page is waiting for
+  // other events before actually calling play(), but at least we don't break
+  // Blink.
+  //
+  // 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 = is_idle_ && have_future_data;
+
+  // Combined suspend state.
+  result.is_suspended =
+      is_remote || must_suspend_ || idle_suspended || background_suspended;
+
+  // We do not treat |playback_rate_| == 0 as paused. For the media session,
+  // being paused implies displaying a play button, which is incorrect in this
+  // case. For memory usage reporting, we just use the same definition (but we
+  // don't have to).
+  //
+  // Similarly, we don't consider |ended_| to be paused. Blink will immediately
+  // call pause() or seek(), so |ended_| should not affect the computation.
+  // Despite that, |ended_| does result in a separate paused state, to simplfy
+  // the contract for SetDelegateState().
+  //
+  // |has_session| is used to decide when to create a media session. Idle
+  // suspension does not destroy the media session, because we expect that the
+  // notification controls (and audio focus) remain. We also require:
+  //   - |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.
+  //
+  // TODO(sandersd): If Blink told us the paused state sooner, we could create
+  // the media session sooner.
+  bool can_play = !has_error && !is_remote && have_future_data;
+  bool has_session = can_play && !must_suspend_ && !background_suspended;
+
+  if (!has_session) {
+    result.delegate_state = DelegateState::GONE;
+  } else if (paused_) {
+    // TODO(sandersd): There should be a paused+seeking state, during which

[DaleCurtis, 2016/04/01 18:25:48]

Should OnSuspend() just ignore the request if it's in the seeking state? Calling
DidPause() a second time will readd the delegate to the idle list.

[sandersd (OOO until July 31), 2016/04/01 21:22:10]

This is a plausible option, I'll implement it (or the full solution) in a
followup.

+    // the idle timer is disabled. Without that, idle suspending before or
+    // during seeking will have bad results.
+    result.delegate_state =
+        ended_ ? DelegateState::ENDED : DelegateState::PAUSED;
+  } else {
+    result.delegate_state = DelegateState::PLAYING;
+  }
+
+  // It's not  critical if some cases where memory usage can change are missed,
+  // since media memory changes are usually gradual.
+  result.is_memory_reporting_enabled =
+      can_play && !result.is_suspended && !paused_;
+
+  return result;
 }
 
 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