Suspend idle WebMediaPlayer instances after some time.

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 329 matching lines @@
 #endif
 
   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 (playback_rate_ > 0) {
+    // Resume the player if playback was initiated in the foreground.
+    if (suspended_ && !resuming_ && delegate_ && !delegate_->IsHidden()) {
+      Resume();
+      return;
+    }
+
     NotifyPlaybackStarted();
+  }
 }
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
@@ skipping 68 matching lines @@
 
     // Schedule a seek once the current suspend or seek finishes.
     pending_seek_ = true;
     pending_seek_time_ = new_seek_time;
 
     // In the case of seeking while suspended, the seek is considered to have
     // started immediately (but won't complete until the pipeline is resumed).
     if (is_suspended) {
       seeking_ = true;
       seek_time_ = new_seek_time;
+
+      // Resume the pipeline if the seek is initiated in the foreground so that
+      // the correct frame is displayed.
+      if (delegate_ && !delegate_->IsHidden())
+        Resume();
     }
 
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   // Update our paused time.
   // For non-MSE playbacks, in paused state ignore the seek operations to
   // current time if the loading is completed and generate
@@ skipping 430 matching lines @@
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
                                           PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << "(" << time_changed << ", " << status << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
-  // If we we're resuming into the playing state, notify the delegate.
-  if (resuming_ && playback_rate_ > 0 && !paused_)
-    NotifyPlaybackStarted();
-
   // Whether or not the seek was caused by a resume, we're not suspended now.
+  const bool was_resuming = resuming_;
   resuming_ = false;
   suspended_ = false;
 
+  // If we we're resuming into the playing state, notify the delegate.
+  if (was_resuming && playback_rate_ > 0 && !paused_)
+    NotifyPlaybackStarted();
+
   // If there is a pending suspend, the seek does not complete until after the
   // next resume.
   if (pending_suspend_) {
     pending_suspend_ = false;
     pending_time_change_ = time_changed;
     Suspend();
     return;
   }
 
   // Clear seek state. Note that if the seek was caused by a resume, then
@@ skipping 236 matching lines @@
           switches::kDisableMediaSuspend)) {
     return;
   }
 
 #if defined(OS_ANDROID)
   // If we're remote, the pipeline should stay suspended.
   if (isRemote())
     return;
 #endif
 
-  ScheduleResume();
+  if (!ended_ && !paused_)
+    ScheduleResume();
 }
 
 void WebMediaPlayerImpl::ScheduleResume() {
   if (!pipeline_.IsRunning())
     return;
 
   if (suspending_) {
     pending_resume_ = true;
     return;
   }
@@ skipping 350 matching lines @@
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackStarted() {
 #if defined(OS_ANDROID)  // WMPI_CAST
-  // We do not tell our delegates about remote playback, becuase that would
+  // We do not tell our delegates about remote playback, because that would
   // keep the device awake, which is not what we want.
   if (isRemote())
     return;
 #endif
+
+  // Don't send delegate notifications when suspended; upon suspend we send
+  // PlayerGone() to the delegate -- no more notifications should be sent until
+  // after resume.
+  if (suspended_)
+    return;
+
   if (delegate_) {
     delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
                        pipeline_.GetMediaDuration());
   }
   if (!memory_usage_reporting_timer_.IsRunning()) {
     memory_usage_reporting_timer_.Start(FROM_HERE,
                                         base::TimeDelta::FromSeconds(2), this,
                                         &WebMediaPlayerImpl::ReportMemoryUsage);
   }
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackPaused() {
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote())
     return;
 #endif
-  if (delegate_)
+  // Don't send delegate notifications when suspended; upon suspend we send
+  // PlayerGone() to the delegate -- no more notifications should be sent until
+  // after resume.
+  if (!suspended_ && delegate_)
     delegate_->DidPause(delegate_id_, ended_);
   memory_usage_reporting_timer_.Stop();
   ReportMemoryUsage();
 }
 
 void WebMediaPlayerImpl::ReportMemoryUsage() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // About base::Unretained() usage below: We destroy |demuxer_| on the main
   // thread.  Before that, however, ~WebMediaPlayerImpl() posts a task to the
@@ skipping 23 matching lines @@
            << ", 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);
 }
 
 }  // namespace media