Refactor WebMediaPlayerDelegate interface.

content/renderer/media/webmediaplayer_ms.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/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 277 matching lines @@
 
   compositor_->StartRendering();
 
   if (audio_renderer_)
     audio_renderer_->Play();
 
   if (delegate_) {
     // TODO(perkj, magjed): We use OneShot focus type here so that it takes
     // audio focus once it starts, and then will not respond to further audio
     // focus changes. See http://crbug.com/596516 for more details.
-    delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
+    delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(),
                        media::MediaContentType::OneShot);
+    delegate_->SetIdle(delegate_id_, false);
   }
 
   paused_ = false;
 }
 
 void WebMediaPlayerMS::pause() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   should_play_upon_shown_ = false;
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
   if (paused_)
     return;
 
   if (video_frame_provider_)
     video_frame_provider_->Pause();
 
   compositor_->StopRendering();
   compositor_->ReplaceCurrentFrameWithACopy();
 
   if (audio_renderer_)
     audio_renderer_->Pause();
 
-  if (delegate_)
-    delegate_->DidPause(delegate_id_, false);
+  if (delegate_) {
+    delegate_->DidPause(delegate_id_);
+    delegate_->SetIdle(delegate_id_, true);
+  }
 
   paused_ = true;
 }
 
 bool WebMediaPlayerMS::supportsSave() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 void WebMediaPlayerMS::seek(double seconds) {
@@ skipping 161 matching lines @@
   NOTIMPLEMENTED();
   return 0;
 }
 
 size_t WebMediaPlayerMS::videoDecodedByteCount() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
   return 0;
 }
 
-void WebMediaPlayerMS::OnHidden() {
+void WebMediaPlayerMS::OnFrameHidden() {
 #if defined(OS_ANDROID)
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Method called when the RenderFrame is sent to background and suspended
   // (android). Substitute the displayed VideoFrame with a copy to avoid
   // holding on to it unnecessarily.
   //
   // During undoable tab closures OnHidden() may be called back to back, so we
   // can't rely on |render_frame_suspended_| being false here.
   if (frame_deliverer_) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), true));
   }
 
   if (!paused_)
     compositor_->ReplaceCurrentFrameWithACopy();
 #endif  // defined(OS_ANDROID)
 }
 
-void WebMediaPlayerMS::OnShown() {
+void WebMediaPlayerMS::OnFrameClosed() {
+#if defined(OS_ANDROID)
+  if (!paused_) {
+    pause();
+    should_play_upon_shown_ = true;
+  }
+
+  if (delegate_)
+    delegate_->PlayerGone(delegate_id_);
+
+  if (frame_deliverer_) {
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
+                              base::Unretained(frame_deliverer_.get()), true));
+  }
+#endif  // defined(OS_ANDROID)
+}
+
+void WebMediaPlayerMS::OnFrameShown() {
 #if defined(OS_ANDROID)
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (frame_deliverer_) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), false));
   }
 
   // Resume playback on visibility. play() clears |should_play_upon_shown_|.
   if (should_play_upon_shown_)
     play();
 #endif  // defined(OS_ANDROID)
 }
 
-bool WebMediaPlayerMS::OnSuspendRequested(bool must_suspend) {
-#if defined(OS_ANDROID)
-  if (!must_suspend)
-    return false;
-
-  if (!paused_) {
-    pause();
-    should_play_upon_shown_ = true;
-  }
-
-  if (delegate_)
-    delegate_->PlayerGone(delegate_id_);
-
-  if (frame_deliverer_) {
-    io_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
-                              base::Unretained(frame_deliverer_.get()), true));
-  }
-#endif  // defined(OS_ANDROID)
-  return true;
-}
+void WebMediaPlayerMS::OnIdleTimeout() {}
 
 void WebMediaPlayerMS::OnPlay() {
   // TODO(perkj, magjed): It's not clear how WebRTC should work with an
   // MediaSession, until these issues are resolved, disable session controls.
   // http://crbug.com/595297.
 }
 
 void WebMediaPlayerMS::OnPause() {
   // TODO(perkj, magjed): See TODO in OnPlay().
 }
@@ skipping 128 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content