Expand suspension of idle media players to all platforms.

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 88 matching lines @@
                             const url::Origin& security_origin,
                             const SwitchOutputDeviceCB& callback) {
   if (sink->GetOutputDevice()) {
     sink->GetOutputDevice()->SwitchOutputDevice(device_id, security_origin,
                                                 callback);
   } else {
     callback.Run(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
   }
 }
 
+bool IsBackgroundSuspendResumeEnabled() {
+#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
+}
+
 }  // 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);
 
@@ skipping 62 matching lines @@
           compositor_task_runner_,
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       is_cdm_attached_(false),
 #if defined(OS_ANDROID)  // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
+      background_playback_state_(
+          BackgroundPlaybackState::PLAY_FORBIDDEN_NEVER_CALLED_IN_FOREGROUND),
       surface_manager_(params.surface_manager()),
       suppress_destruction_errors_(false) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
@@ skipping 132 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;
   pipeline_.SetPlaybackRate(playback_rate_);
 
   if (data_source_)
     data_source_->MediaIsPlaying();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PLAY));
 
-  if (playback_rate_ > 0) {
+  if (background_playback_state_ ==
+          BackgroundPlaybackState::PLAY_FORBIDDEN_NEVER_CALLED_IN_FOREGROUND &&

[sandersd (OOO until July 31), 2016/03/07 23:27:51]

The existence of this check isn't immediately necessary from the names, which
probably means that the enum names need work. (It's still true in this case that
play() was never called in the foreground, so why would it change?)

I'm no better at naming than you are, though.

[DaleCurtis, 2016/03/09 02:56:14]

Removed.

+      delegate_ && !delegate_->IsHidden()) {
+    background_playback_state_ =
+        hasVideo() ? BackgroundPlaybackState::PLAY_FORBIDDEN_WHEN_SUSPENDED
+                   : BackgroundPlaybackState::PLAY_ALLOWED_WHEN_SUSPENDED;

[mlamouri (slow - plz ping), 2016/03/05 22:37:36]

Should this include IsBackgroundSuspendResumeEnabled()?

[DaleCurtis, 2016/03/09 02:56:13]

No, as indicated below. I've also renamed it to IsSuspendUponHiddenEnabled() for
clarity.

+  }
+
+  if (playback_rate_ > 0 && was_paused) {
     NotifyPlaybackStarted();

[sandersd (OOO until July 31), 2016/03/07 23:27:51]

Add a comment here that this method won't do anything when suspended. I get the
feeling it's not obvious due to the name, but I'm not going to ask for a rename
in this CL.

-
-    // Resume the player if playback was initiated in the foreground. Resume()
-    // will do nothing if the pipeline is not suspended state, but will clear
-    // some internal pending state, so it should always be called.
-    if (delegate_ && !delegate_->IsHidden())
+    if (IsResumeAllowed())
       pipeline_controller_.Resume();
   }
 }
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
@@ skipping 68 matching lines @@
     }
     return;
   }
 
   seeking_ = true;
   seek_time_ = time;
   if (paused_)
     paused_time_ = time;
   pipeline_controller_.Seek(time, time_updated);
 
-  // Resume the pipeline if the seek is initiated in the foreground so that
-  // the correct frame is displayed. If the pipeline is not suspended, Resume()
-  // will do nothing but clear some pending state.
-  if (delegate_ && !delegate_->IsHidden())
+  if (IsResumeAllowed())
     pipeline_controller_.Resume();
 }
 
 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)
@@ skipping 390 matching lines @@
 void WebMediaPlayerImpl::OnPipelineSuspended() {
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame) {
       compositor_->PaintFrameUsingOldRenderingPath(frame);
     }
   }
 #endif
 
-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
   memory_usage_reporting_timer_.Stop();
   ReportMemoryUsage();
 
   if (pending_suspend_resume_cycle_) {
     pending_suspend_resume_cycle_ = false;
     pipeline_controller_.Resume();
     return;
   }
 }
 
@@ skipping 56 matching lines @@
     }
 
     video_weblayer_.reset(new cc_blink::WebLayerImpl(layer));
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
     video_weblayer_->SetContentsOpaqueIsFixed(true);
     client_->setWebLayer(video_weblayer_.get());
 
     // If there is video and the frame is hidden, then it may be time to suspend
     // playback.
     if (delegate_ && delegate_->IsHidden())
-      OnHidden(false);
+      OnHidden();
   }
 }
 
 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())
@@ skipping 40 matching lines @@
 
   scoped_ptr<WebInbandTextTrackImpl> web_inband_text_track(
       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(bool must_suspend) {
+void WebMediaPlayerImpl::OnHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
+  if (!IsBackgroundSuspendResumeEnabled())
+    return;
 
-#if !defined(OS_ANDROID)
-  // Suspend/Resume is enabled by default on Android.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableMediaSuspend)) {
-    return;
-  }
-#endif  // !defined(OS_ANDROID)
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableMediaSuspend)) {
-    return;
-  }
-
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID)  // WMPI_CAST
   // If we're remote, the pipeline should already be suspended.
   if (isRemote())
     return;
 #endif
 
-  if (must_suspend || (paused_ && ended_) || hasVideo())
-    pipeline_controller_.Suspend();
+  // Don't suspend players which started playback in the foreground, only have
+  // audio, and have not completed playback.  The user can still control these
+  // players via the MediaSession UI.
+  if (background_playback_state_ >
+          BackgroundPlaybackState::PLAY_FORBIDDEN_NEVER_CALLED_IN_FOREGROUND &&
+      !hasVideo() && !ended_) {
+    return;
+  }
+
+  pipeline_controller_.Suspend();
+  if (delegate_)
+    delegate_->PlayerGone(delegate_id_);
 }
 
 void WebMediaPlayerImpl::OnShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
+  if (!IsBackgroundSuspendResumeEnabled())
+    return;
 
-#if !defined(OS_ANDROID)
-  // Suspend/Resume is enabled by default on Android.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableMediaSuspend)) {
-    return;
-  }
-#endif  // !defined(OS_ANDROID)
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableMediaSuspend)) {
-    return;
-  }
-
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID)  // WMPI_CAST
   // If we're remote, the pipeline should stay suspended.
   if (isRemote())
     return;
 #endif
 
   if (!ended_ && !paused_)
     pipeline_controller_.Resume();
 }
 
+void WebMediaPlayerImpl::OnSuspend(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
+
+  // Suspend should never be sent unless always required or we're already in a
+  // paused or ended state.
+  DCHECK(must_suspend || paused_ || ended_);
+
+  NotifyPlaybackPaused();
+
+  // 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_);
+}
+
 void WebMediaPlayerImpl::OnPlay() {
   play();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerImpl::OnPause() {
   pause();
   client_->playbackStateChanged();
 }
 
@@ skipping 356 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::IsResumeAllowed() {
+#if defined(OS_ANDROID)
+  return background_playback_state_ ==
+             BackgroundPlaybackState::PLAY_ALLOWED_WHEN_SUSPENDED ||
+         (delegate_ && !delegate_->IsHidden());

[mlamouri (slow - plz ping), 2016/03/05 22:37:36]

Should this include IsBackgroundSuspendResumeEnabled()?

[DaleCurtis, 2016/03/07 19:08:06]

No, I tried to make it clear that IsBackgroundSuspendResumeEnabled() is _only_
for enabling automatic suspension (with clearing of MediaSession) on
backgrounding. I.e., it's not for suspending idle players as the opportunity
arises. Let me know if there's any way I can make this clearer. Thanks!

+#else
+  // On non-Android platforms Resume() is always allowed.
+  return true;
+#endif
+}
+
 }  // namespace media