media: Don't idle suspend the pipeline when in fullscreen

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 1066 matching lines @@
 #if defined(OS_MACOSX)
   // TODO(sandersd): Idle suspend is disabled on OSX since hardware decoded
   // frames are owned by the video decoder in the GPU process. A mechanism for
   // detaching ownership from the decoder is needed. http://crbug.com/595716.
   return;
 #endif
 
   if (must_suspend) {
     must_suspend_ = true;
   } else {
-    // TODO(sandersd): Remove this when |delegate_| becomes aware of this state.
-    if (delegate_state_ == DelegateState::PAUSED_SEEK)
+    // TODO(sandersd): Remove this when idleness is separate from play state.
+    if (delegate_state_ == DelegateState::PAUSED_BUT_NOT_IDLE)
       return;
     is_idle_ = true;
   }
 
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnPlay() {
   play();
   client_->playbackStateChanged();
@@ skipping 324 matching lines @@
     case DelegateState::GONE:
       delegate_->PlayerGone(delegate_id_);
       break;
     case DelegateState::PLAYING:
       delegate_->DidPlay(delegate_id_, hasVideo(), hasAudio(), false,
                          pipeline_.GetMediaDuration());
       break;
     case DelegateState::PAUSED:
       delegate_->DidPause(delegate_id_, false);
       break;
-    case DelegateState::PAUSED_SEEK:
+    case DelegateState::PAUSED_BUT_NOT_IDLE:
       // It doesn't really matter what happens when we enter this state, only
       // that we reset the idle timer when leaving it.
       //
-      // TODO(sandersd): Ideally |delegate_| would understand this state and not
-      // run the idle timer.
+      // TODO(sandersd): Ideally the delegate would consider idleness and play
+      // state as orthogonal properties so that we could avoid this.
       delegate_->DidPause(delegate_id_, false);
       break;
     case DelegateState::ENDED:
       delegate_->DidPause(delegate_id_, true);
       break;
   }
 }
 
 void WebMediaPlayerImpl::SetMemoryReportingState(
     bool is_memory_reporting_enabled) {
@@ skipping 78 matching lines @@
   //     correctly configure the session.
   //
   // TODO(sandersd): If Blink told us the paused state sooner, we could create
   // the media session sooner.
   bool can_play = !has_error && !is_remote && have_future_data;
   bool has_session = can_play && !must_suspend_ && !background_suspended;
 
   if (!has_session) {
     result.delegate_state = DelegateState::GONE;
   } else if (paused_) {
-    if (seeking()) {
-      result.delegate_state = DelegateState::PAUSED_SEEK;
+    if (seeking() || fullscreen_) {
+      result.delegate_state = DelegateState::PAUSED_BUT_NOT_IDLE;
     } else if (ended_) {
       result.delegate_state = DelegateState::ENDED;
     } else {
       result.delegate_state = DelegateState::PAUSED;
     }
   } else {
     result.delegate_state = DelegateState::PLAYING;
   }
 
   // It's not  critical if some cases where memory usage can change are missed,
@@ skipping 38 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