[Video] MediaSession API event handlers can resume background video.

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 45 matching lines @@
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_util.h"
 #endif
 
 using blink::WebCanvas;
 using blink::WebMediaPlayer;
 using blink::WebRect;
 using blink::WebSize;
@@ skipping 1879 matching lines @@
   bool have_future_data =
       highest_ready_state_ >= WebMediaPlayer::ReadyStateHaveFutureData;
 
   // Background suspend is not enabled for audio-only players unless paused,
   // though in the case of audio-only the session should be kept.
   // Videos are not suspended if the user resumed the playback via the remote
   // controls earlier and it's still playing.
   bool is_backgrounded_video = is_backgrounded && have_metadata && hasVideo();
   bool can_play_backgrounded = is_backgrounded_video && !is_remote &&
                                hasAudio() && IsResumeBackgroundVideosEnabled();
-  bool is_background_playing = delegate_->IsBackgroundVideoPlaybackUnlocked();
-  bool background_suspended = !is_streaming && is_backgrounded_video &&
-                              !(can_play_backgrounded && is_background_playing);
+  bool is_background_playing_allowed =

[DaleCurtis, 2017/02/13 22:44:54]

Needs a comment explaining use of the user gesture here.

[sandersd (OOO until July 31), 2017/02/13 22:56:20]

Indeed; the entire design goal of this function is to be stateless, and this is
explicitly stateful. This state should be saved by the caller so that we can
query it without consequence at any time in the future.

[whywhat, 2017/02/14 01:36:28]

Something like play_called_with_user_gesture_ set in play() and then reset in
any other method if there's no user gesture? And call UPS again. This kind of
states are hard to add to WMPI or at least I still haven't wrapped my head
around it :)

[whywhat, 2017/02/15 17:13:12]

I simplified the whole background logic in ComputePlayState now (at the expense
of blocking play() if IsHidden() and ShouldPauseVideoWhenHidden() are both
true).

+      blink::WebUserGestureIndicator::isProcessingUserGesture() ||
+      delegate_->IsBackgroundVideoPlaybackUnlocked();
+  bool background_suspended =
+      !is_streaming && is_backgrounded_video &&
+      !(can_play_backgrounded && is_background_playing_allowed);
   bool background_pause_suspended =
       !is_streaming && is_backgrounded && paused_ && have_future_data;
 
   // Idle suspension is allowed prior to have future data since there exist
   // mechanisms to exit the idle state when the player is capable of reaching
   // the have future data state; see didLoadingProgress().
   //
   // TODO(sandersd): Make the delegate suspend idle players immediately when
   // hidden.
   bool idle_suspended =
@@ skipping 114 matching lines @@
     UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.DataSource",
                             data_source_memory_usage / 1024);
   }
   if (demuxer_) {
     UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.Demuxer",
                             demuxer_memory_usage / 1024);
   }
 }
 
 void WebMediaPlayerImpl::ScheduleIdlePauseTimer() {
-  // Only schedule the pause timer if we're playing and are suspended.
-  if (paused_ || !pipeline_controller_.IsSuspended())
+  // Only schedule the pause timer if we're not paused or paused but going to
+  // resume when foregrounded, and are suspended.
+  if ((paused_ && !paused_when_hidden_) || !pipeline_controller_.IsSuspended())
     return;
 
 #if defined(OS_ANDROID)
   // Remote players will be suspended and locally paused.
   if (isRemote())
     return;
 #endif
 
   // Idle timeout chosen arbitrarily.
   background_pause_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
@@ skipping 27 matching lines @@
   return pipeline_metadata_.video_rotation == VIDEO_ROTATION_0;
 }
 
 void WebMediaPlayerImpl::ActivateViewportIntersectionMonitoring(bool activate) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   client_->activateViewportIntersectionMonitoring(activate);
 }
 
 bool WebMediaPlayerImpl::ShouldPauseVideoWhenHidden() const {
-#if !defined(OS_ANDROID)
-  // On desktop, this behavior is behind the feature flag.
-  if (!IsBackgroundVideoTrackOptimizationEnabled())
-    return false;
-#endif
+  if (IsBackgroundedSuspendEnabled()) {
+    // If we intend to pause background videos, pause them as long as
+    // they're not remote or audible and unlocked for background
+    // playback.
+    return hasVideo() && !isRemote() &&
+           (!hasAudio() || !delegate_->IsBackgroundVideoPlaybackUnlocked());
+  }
 
-  // Pause video-only players that match the criteria for being optimized.
-  return !hasAudio() && IsBackgroundOptimizationCandidate();
+  // Otherwise only pause if the optimization is on and it's a video-only
+  // optimization candidate.
+  return IsBackgroundVideoTrackOptimizationEnabled() && !hasAudio() &&
+         IsBackgroundOptimizationCandidate();
 }
 
 bool WebMediaPlayerImpl::ShouldDisableVideoWhenHidden() const {
   // This optimization is behind the flag on all platforms.
   if (!IsBackgroundVideoTrackOptimizationEnabled())
     return false;
 
   // Disable video track only for players with audio that match the criteria for
   // being optimized.
   return hasAudio() && IsBackgroundOptimizationCandidate();
@@ skipping 112 matching lines @@
     UMA_HISTOGRAM_TIMES(
         "Media.Video.TimeFromForegroundToFirstFrame.DisableTrack",
         time_to_first_frame);
   } else {
     UMA_HISTOGRAM_TIMES("Media.Video.TimeFromForegroundToFirstFrame.Paused",
                         time_to_first_frame);
   }
 }
 
 }  // namespace media