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

content/renderer/media/android/webmediaplayer_android.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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 43 matching lines @@
 #include "third_party/WebKit/public/platform/WebEncryptedMediaTypes.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3DProvider.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.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/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 static const uint32_t kGLTextureExternalOES = 0x8D65;
@@ skipping 96 matching lines @@
       media_log_(params.media_log()),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       frame_id_(frame_id),
       enable_texture_copy_(enable_texture_copy),
       suppress_deleting_texture_(false),
       playback_completed_(false),
       volume_(1.0),
       volume_multiplier_(1.0),
+      video_locked_when_paused_when_hidden_(false),
       weak_factory_(this) {
   DCHECK(player_manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (delegate_) {
     delegate_id_ = delegate_->AddObserver(this);
     delegate_->SetIdle(delegate_id_, true);
   }
 
@@ skipping 96 matching lines @@
       !host.compare("[::1]")) {
     return true;
   }
 
   return false;
 }
 
 void WebMediaPlayerAndroid::play() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
+  if (blink::WebUserGestureIndicator::isProcessingUserGesture())
+    video_locked_when_paused_when_hidden_ = false;
+
   if (hasVideo() && player_manager_->render_frame()->IsHidden()) {
     bool can_video_play_in_background =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableMediaSuspend) ||
-        (IsBackgroundVideoCandidate() && delegate_ &&
-         delegate_->IsBackgroundVideoPlaybackUnlocked());
+        (IsBackgroundVideoCandidate() &&
+         !video_locked_when_paused_when_hidden_);
     if (!can_video_play_in_background) {
       is_play_pending_ = true;
       return;
     }
   }
   is_play_pending_ = false;
 
   TryCreateStreamTextureProxyIfNeeded();
   // There is no need to establish the surface texture peer for fullscreen
   // video.
   if ((hasVideo() || IsHLSStream()) && needs_establish_peer_ &&
       !is_fullscreen_) {
     EstablishSurfaceTexturePeer();
   }
 
   // UpdatePlayingState() must be run before calling Start() to ensure that the
   // browser side MediaPlayerAndroid values for hasAudio() and hasVideo() take
   // precedent over the guesses that we make based on mime type.
   const bool is_paused = paused();
   UpdatePlayingState(true);
   if (is_paused)
     player_manager_->Start(player_id_);
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
 }
 
 void WebMediaPlayerAndroid::pause() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
+
+  if (blink::WebUserGestureIndicator::isProcessingUserGesture()) {
+    video_locked_when_paused_when_hidden_ = true;
+    is_play_pending_ = false;
+  }
+
   Pause(true);
 }
 
 void WebMediaPlayerAndroid::requestRemotePlayback() {
   player_manager_->RequestRemotePlayback(player_id_);
 }
 
 void WebMediaPlayerAndroid::requestRemotePlaybackControl() {
   player_manager_->RequestRemotePlaybackControl(player_id_);
 }
@@ skipping 884 matching lines @@
         delegate_->PlayerGone(delegate_id_);
       } else {
         delegate_->DidPause(delegate_id_);
       }
       delegate_->SetIdle(delegate_id_, true);
     }
   }
 }
 
 void WebMediaPlayerAndroid::OnFrameHidden() {
+  video_locked_when_paused_when_hidden_ = true;
+
   // Pause audible video preserving its session.
   if (hasVideo() && IsBackgroundVideoCandidate() && !paused()) {
     Pause(false);
     is_play_pending_ = true;
     return;
   }
 
   OnIdleTimeout();
 }
 
 void WebMediaPlayerAndroid::OnFrameClosed() {
   SuspendAndReleaseResources();
 }
 
 void WebMediaPlayerAndroid::OnFrameShown() {
+  video_locked_when_paused_when_hidden_ = false;
   if (is_play_pending_)
     play();
 }
 
 void WebMediaPlayerAndroid::OnIdleTimeout() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return;
   }
 
@@ skipping 81 matching lines @@
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
          hasAudio() && !isRemote() && delegate_ && delegate_->IsFrameHidden() &&
          !delegate_->IsFrameClosed();
 }
 
 }  // namespace content