[Video] Only start tracking foreground time if the video was resumed.

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 110 matching lines @@
 }
 
 bool IsResumeBackgroundVideosEnabled() {
   return base::FeatureList::IsEnabled(kResumeBackgroundVideo);
 }
 
 bool IsBackgroundVideoTrackOptimizationEnabled() {
   return base::FeatureList::IsEnabled(kBackgroundVideoTrackOptimization);
 }
 
+bool IsBackgroundVideoPauseEnabled() {
+#if defined(OS_ANDROID)
+  return true;
+#else
+  return IsBackgroundVideoTrackOptimizationEnabled();
+#endif
+}
+
 bool IsNetworkStateError(blink::WebMediaPlayer::NetworkState state) {
   bool result = state == blink::WebMediaPlayer::NetworkStateFormatError ||
                 state == blink::WebMediaPlayer::NetworkStateNetworkError ||
                 state == blink::WebMediaPlayer::NetworkStateDecodeError;
   DCHECK_EQ(state > blink::WebMediaPlayer::NetworkStateLoaded, result);
   return result;
 }
 
 gfx::Size GetRotatedVideoSize(VideoRotation rotation, gfx::Size natural_size) {
   if (rotation == VIDEO_ROTATION_90 || rotation == VIDEO_ROTATION_270)
@@ skipping 1262 matching lines @@
   if (video_weblayer_)
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
 }
 
 void WebMediaPlayerImpl::OnFrameHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (watch_time_reporter_)
     watch_time_reporter_->OnHidden();
 
-  if (ShouldPauseWhenHidden()) {
+  if (IsBackgroundVideoPauseEnabled() && ShouldPauseWhenHidden()) {
     if (!paused_when_hidden_) {
       // OnPause() will set |paused_when_hidden_| to false and call
       // UpdatePlayState(), so set the flag to true after and then return.
       OnPause();
       paused_when_hidden_ = true;
       return;
     }
   } else {
     DisableVideoTrackIfNeeded();
   }
@@ skipping 10 matching lines @@
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnFrameShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   background_pause_timer_.Stop();
 
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
-  compositor_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoFrameCompositor::SetForegroundTime,
-                 base::Unretained(compositor_), base::TimeTicks::Now()));
+  // Only track the time to the first frame if playing or about to play because
+  // of being shown and only for videos we would optimize background playback
+  // for.
+  if (!paused_ && ShouldDisableVideoWhenHidden()) {
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &VideoFrameCompositor::SetForegroundTime,
+            base::Unretained(compositor_), base::TimeTicks::Now(),
+            VideoFrameCompositor::BackgroundVideoOptimization::DisabledTrack));
+  } else if (paused_when_hidden_ && ShouldPauseWhenHidden()) {
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoFrameCompositor::SetForegroundTime,
+                   base::Unretained(compositor_), base::TimeTicks::Now(),
+                   VideoFrameCompositor::BackgroundVideoOptimization::Paused));
+  }
 
   if (paused_when_hidden_) {
     paused_when_hidden_ = false;
     OnPlay();  // Calls UpdatePlayState() so return afterwards.
     return;
   }
 
   EnableVideoTrackIfNeeded();
 
   UpdatePlayState();
@@ skipping 658 matching lines @@
   return pipeline_metadata_.video_rotation == VIDEO_ROTATION_0;
 }
 
 void WebMediaPlayerImpl::ActivateViewportIntersectionMonitoring(bool activate) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   client_->activateViewportIntersectionMonitoring(activate);
 }
 
 bool WebMediaPlayerImpl::ShouldPauseWhenHidden() const {
-  DCHECK(IsHidden());
-// Don't pause videos being Cast (Android only) or if the background video
-// optimizations are off (desktop only).
+// Don't pause videos being Cast (Android only).
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote())
     return false;
-#else   // defined(OS_ANDROID)
-  if (!IsBackgroundVideoTrackOptimizationEnabled())
-    return false;
 #endif  // defined(OS_ANDROID)
 
   return hasVideo() && !hasAudio();
 }
 
 bool WebMediaPlayerImpl::ShouldDisableVideoWhenHidden() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  DCHECK(IsHidden());
 
-  if (!IsBackgroundVideoTrackOptimizationEnabled() || !hasVideo() ||
-      !hasAudio() || IsStreaming()) {
+// Don't disable video track for videos being Cast (Android only).
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (isRemote())
     return false;
-  }
+#endif  // defined(OS_ANDROID)
+
+  if (!hasVideo() || !hasAudio() || IsStreaming())
+    return false;
 
   PipelineStatistics stats = GetPipelineStatistics();
   return stats.video_keyframe_distance_average <
          max_keyframe_distance_to_disable_background_video_;
 }
 
 void WebMediaPlayerImpl::EnableVideoTrackIfNeeded() {
   DCHECK(!IsHidden());
 
   // Don't change video track while the pipeline is resuming or seeking.
   if (is_pipeline_resuming_ || seeking_)
     return;
 
   if (video_track_disabled_) {
     video_track_disabled_ = false;
     if (client_->hasSelectedVideoTrack()) {
       WebMediaPlayer::TrackId trackId = client_->getSelectedVideoTrackId();
       selectedVideoTrackChanged(&trackId);
     }
   }
 }
 
 void WebMediaPlayerImpl::DisableVideoTrackIfNeeded() {
   DCHECK(IsHidden());
 
   // Don't change video track while the pipeline is resuming or seeking.
   if (is_pipeline_resuming_ || seeking_)
     return;
 
-  if (!video_track_disabled_ && ShouldDisableVideoWhenHidden()) {
+  if (!video_track_disabled_ && IsBackgroundVideoTrackOptimizationEnabled() &&
+      ShouldDisableVideoWhenHidden()) {
     video_track_disabled_ = true;
     selectedVideoTrackChanged(nullptr);
   }
 }
 
 void WebMediaPlayerImpl::SetPipelineStatisticsForTest(
     const PipelineStatistics& stats) {
   pipeline_statistics_for_test_ = base::make_optional(stats);
 }
 
 PipelineStatistics WebMediaPlayerImpl::GetPipelineStatistics() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_statistics_for_test_.value_or(pipeline_.GetStatistics());
 }
 
 }  // namespace media