Disable background video track behind a feature flag

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 106 matching lines @@
 #else
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableMediaSuspend);
 #endif
 }
 
 bool IsResumeBackgroundVideosEnabled() {
   return base::FeatureList::IsEnabled(kResumeBackgroundVideo);
 }
 
+bool IsBackgroundVideoTrackOptimizationEnabled() {
+  return base::FeatureList::IsEnabled(kBackgroundVideoTrackOptimization);
+}
+
 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 507 matching lines @@
                               << "]";
   pipeline_.OnEnabledAudioTracksChanged(enabledMediaTrackIds);
 }
 
 void WebMediaPlayerImpl::selectedVideoTrackChanged(
     blink::WebMediaPlayer::TrackId* selectedTrackId) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   std::ostringstream logstr;
   std::vector<MediaTrack::Id> selectedVideoMediaTrackId;
-  if (selectedTrackId) {
+  bool canAddVideoTrack =
+      !IsBackgroundVideoTrackOptimizationEnabled() || !IsHidden();
+  if (selectedTrackId && canAddVideoTrack) {
     selectedVideoMediaTrackId.push_back(selectedTrackId->utf8().data());
     logstr << selectedVideoMediaTrackId[0];
   }
   MEDIA_LOG(INFO, media_log_) << "Selected video track: [" << logstr.str()
                               << "]";
   pipeline_.OnSelectedVideoTrackChanged(selectedVideoMediaTrackId);
 }
 
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 637 matching lines @@
 
   opaque_ = opaque;
   // Modify content opaqueness of cc::Layer directly so that
   // SetContentsOpaqueIsFixed is ignored.
   if (video_weblayer_)
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
 }
 
 void WebMediaPlayerImpl::OnHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  if (IsBackgroundVideoTrackOptimizationEnabled())
+    selectedVideoTrackChanged(nullptr);
+
   if (watch_time_reporter_)
     watch_time_reporter_->OnHidden();
 
   UpdatePlayState();
 
   // Schedule suspended playing media to be paused if the user doesn't come back
   // to it within some timeout period to avoid any autoplay surprises.
   ScheduleIdlePauseTimer();
 }
 
 void WebMediaPlayerImpl::OnShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
+  if (IsBackgroundVideoTrackOptimizationEnabled() &&
+      client_->hasSelectedVideoTrack()) {
+    WebMediaPlayer::TrackId trackId = client_->getSelectedVideoTrackId();
+    selectedVideoTrackChanged(&trackId);
+  }
+
   must_suspend_ = false;
   background_pause_timer_.Stop();
 
   UpdatePlayState();
 }
 
 bool WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (must_suspend) {
@@ skipping 356 matching lines @@
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   bool is_remote = isRemote();
   bool is_streaming = false;
 #else
   bool is_remote = false;
   bool is_streaming = data_source_ && data_source_->IsStreaming();
 #endif
 
   bool is_suspended = pipeline_controller_.IsSuspended();
-  bool is_backgrounded =
-      IsBackgroundedSuspendEnabled() && delegate_ && delegate_->IsHidden();
+  bool is_backgrounded = IsBackgroundedSuspendEnabled() && IsHidden();
   PlayState state = UpdatePlayState_ComputePlayState(
       is_remote, is_streaming, is_suspended, is_backgrounded);
   SetDelegateState(state.delegate_state);
   SetMemoryReportingState(state.is_memory_reporting_enabled);
   SetSuspendState(state.is_suspended || pending_suspend_resume_cycle_);
 }
 
 void WebMediaPlayerImpl::SetDelegateState(DelegateState new_state) {
   if (!delegate_)
     return;
@@ skipping 238 matching lines @@
                                 this, &WebMediaPlayerImpl::OnPause);
 }
 
 void WebMediaPlayerImpl::CreateWatchTimeReporter() {
   // Create the watch time reporter and synchronize its initial state.
   watch_time_reporter_.reset(new WatchTimeReporter(
       hasAudio(), hasVideo(), !!chunk_demuxer_, is_encrypted_, media_log_,
       pipeline_metadata_.natural_size,
       base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
-  if (delegate_ && delegate_->IsHidden())
+  if (IsHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
+bool WebMediaPlayerImpl::IsHidden() const {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  return delegate_ && delegate_->IsHidden();
+}
+
 }  // namespace media