Refactor WebMediaPlayerDelegate interface.

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 164 matching lines @@
       enable_texture_copy_(enable_texture_copy),
       suppress_deleting_texture_(false),
       playback_completed_(false),
       volume_(1.0),
       volume_multiplier_(1.0),
       weak_factory_(this) {
   DCHECK(player_manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  if (delegate_)
+  if (delegate_) {
     delegate_id_ = delegate_->AddObserver(this);
+    delegate_->SetIdle(delegate_id_, true);
+  }
 
   player_id_ = player_manager_->RegisterMediaPlayer(this);
 
   TryCreateStreamTextureProxyIfNeeded();
   interpolator_.SetUpperBound(base::TimeDelta());
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
@@ skipping 91 matching lines @@
   return false;
 }
 
 void WebMediaPlayerAndroid::play() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (hasVideo() && player_manager_->render_frame()->IsHidden()) {
     bool can_video_play_in_background =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableMediaSuspend) ||
-        (IsBackgroundVideoCandidate() &&
-            delegate_ && delegate_->IsPlayingBackgroundVideo());
+        (IsBackgroundVideoCandidate() && delegate_ &&
+         delegate_->IsBackgroundVideoPlaybackUnlocked());
     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.
@@ skipping 506 matching lines @@
 
   // Lazily allocate compositing layer.
   if (!video_weblayer_) {
     video_weblayer_.reset(new cc_blink::WebLayerImpl(
         cc::VideoLayer::Create(this, media::VIDEO_ROTATION_0)));
     client_->setWebLayer(video_weblayer_.get());
 
     // If we're paused after we receive metadata for the first time, tell the
     // delegate we can now be safely suspended due to inactivity if a subsequent
     // play event does not occur.
-    if (paused() && delegate_)
-      delegate_->DidPause(delegate_id_, false);
+    if (paused() && delegate_) {
+      delegate_->DidPause(delegate_id_);
+      delegate_->SetIdle(delegate_id_, true);
+    }
   }
 }
 
 void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_timestamp,
                                          base::TimeTicks current_time_ticks) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (seeking())
     return;
 
@@ skipping 354 matching lines @@
     interpolator_.StartInterpolating();
   else
     interpolator_.StopInterpolating();
 
   if (delegate_) {
     if (is_playing) {
       // We must specify either video or audio to the delegate, but neither may
       // be known at this point -- there are no video only containers, so only
       // send audio if we know for sure its audio.  The browser side player will
       // fill in the correct value later for media sessions.
-      delegate_->DidPlay(delegate_id_, hasVideo(), !hasVideo(), isRemote(),
-                         media::DurationToMediaContentType(duration_));
+      if (isRemote()) {
+        delegate_->PlayerGone(delegate_id_);
+      } else {
+        delegate_->DidPlay(delegate_id_, !hasVideo(), hasVideo(),
+                           media::DurationToMediaContentType(duration_));
+      }
+      delegate_->SetIdle(delegate_id_, false);
     } else {
       // Even if OnPlaybackComplete() has not been called yet, Blink may have
       // already fired the ended event based on current time relative to
       // duration -- so we need to check both possibilities here.
-      delegate_->DidPause(delegate_id_,
-                          playback_completed_ || currentTime() >= duration());
+      if (playback_completed_ || currentTime() >= duration()) {
+        delegate_->PlayerGone(delegate_id_);
+      } else {
+        delegate_->DidPause(delegate_id_);
+      }
+      delegate_->SetIdle(delegate_id_, true);
     }
   }
 }
 
-void WebMediaPlayerAndroid::OnHidden() {
+void WebMediaPlayerAndroid::OnFrameHidden() {
   // Pause audible video preserving its session.
   if (hasVideo() && IsBackgroundVideoCandidate() && !paused()) {
     Pause(false);
     is_play_pending_ = true;
     return;
   }
 
-  OnSuspendRequested(false);
+  OnIdleTimeout();
 }
 
-void WebMediaPlayerAndroid::OnShown() {
+void WebMediaPlayerAndroid::OnFrameClosed() {
+  SuspendAndReleaseResources();
+}
+
+void WebMediaPlayerAndroid::OnFrameShown() {
   if (is_play_pending_)
     play();
 }
 
-bool WebMediaPlayerAndroid::OnSuspendRequested(bool must_suspend) {
-  if (!must_suspend &&
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
+void WebMediaPlayerAndroid::OnIdleTimeout() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
-    return true;
+    return;
   }
 
-  // If we're idle or playing video, pause and release resources; audio only
-  // players are allowed to continue unless indicated otherwise by the call.
-  if (must_suspend || (paused() && playback_completed_) ||
-      (hasVideo() && !IsBackgroundVideoCandidate())) {
+  // If we're playing video or ended, pause and release resources; audio only
+  // players are allowed to continue.
+  if ((hasVideo() && !IsBackgroundVideoCandidate()) ||
+      (paused() && playback_completed_)) {
     SuspendAndReleaseResources();
   }
-
-  return true;
 }
 
 void WebMediaPlayerAndroid::OnPlay() {
   play();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerAndroid::OnPause() {
   pause();
   client_->playbackStateChanged();
@@ skipping 60 matching lines @@
 
 bool WebMediaPlayerAndroid::IsBackgroundVideoCandidate() const {
   DCHECK(hasVideo());
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
-      hasAudio() && !isRemote() && delegate_ && delegate_->IsHidden();
+         hasAudio() && !isRemote() && delegate_ && delegate_->IsFrameHidden() &&
+         !delegate_->IsFrameClosed();
 }
 
 }  // namespace content