[Cleanup] Rename Hidden to Background in WMPI.

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 188 matching lines @@
                      base::Unretained(this)),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSeeked, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSuspended, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnBeforePipelineResume, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineResumed, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnError, AsWeakPtr())),
       load_type_(LoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
-      paused_when_hidden_(false),
+      paused_when_background_(false),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       should_notify_time_changed_(false),
       overlay_enabled_(false),
       decoder_requires_restart_for_overlay_(false),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
       delegate_id_(0),
@@ skipping 226 matching lines @@
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // We update the paused state even when casting, since we expect pause() to be
   // called when casting begins, and when we exit casting we should end up in a
   // paused state.
   paused_ = true;
 
-  // No longer paused because it was hidden.
-  paused_when_hidden_ = false;
+  // No longer paused because it was backgrounded.
+  paused_when_background_ = false;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
     cast_impl_.pause();
     return;
   }
 #endif
 
   pipeline_.SetPlaybackRate(0.0);
 
@@ skipping 642 matching lines @@
     DCHECK(watch_time_reporter_);
     watch_time_reporter_->OnPlaying();
   }
   if (time_updated)
     should_notify_time_changed_ = true;
 
   // Reset underflow count upon seek; this prevents looping videos and user
   // actions from artificially inflating the underflow count.
   underflow_count_ = 0;
 
-  // Background video optimizations are delayed when shown/hidden if pipeline
-  // is seeking.
+  // Background video optimizations are delayed when if pipeline
+  // is seeking when the video goes to the background or the foreground.
   UpdateBackgroundVideoOptimizationState();
 }
 
 void WebMediaPlayerImpl::OnPipelineSuspended() {
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame)
       compositor_->PaintSingleFrame(frame);
   }
@@ skipping 266 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();
 
-  // OnFrameHidden() can be called when frame is closed, then IsHidden() will
-  // return false, so check explicitly.
-  if (IsHidden()) {
-    if (ShouldPauseVideoWhenHidden()) {
+  if (IsBackgrounded()) {
+    if (ShouldPauseVideoWhenBackground()) {
       PauseVideoIfNeeded();
       return;
     } else {
       DisableVideoTrackIfNeeded();
     }
   }
 
   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::OnFrameClosed() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnFrameShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   background_pause_timer_.Stop();
 
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
   // 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.
+  // of being foregrounded and only for videos we would optimize background
+  // playback for.
   if ((!paused_ && IsBackgroundOptimizationCandidate()) ||
-      paused_when_hidden_) {
+      paused_when_background_) {
     VideoFrameCompositor::OnNewProcessedFrameCB new_processed_frame_cb =
         BIND_TO_RENDER_LOOP1(
             &WebMediaPlayerImpl::ReportTimeFromForegroundToFirstFrame,
             base::TimeTicks::Now());
     compositor_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VideoFrameCompositor::SetOnNewProcessedFrameCallback,
                    base::Unretained(compositor_), new_processed_frame_cb));
   }
 
-  if (paused_when_hidden_) {
-    paused_when_hidden_ = false;
+  if (paused_when_background_) {
+    paused_when_background_ = false;
     OnPlay();  // Calls UpdatePlayState() so return afterwards.
     return;
   }
 
   EnableVideoTrackIfNeeded();
 
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnIdleTimeout() {
@@ skipping 332 matching lines @@
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   bool is_remote = isRemote();
   bool is_streaming = false;
 #else
   bool is_remote = false;
   bool is_streaming = IsStreaming();
 #endif
 
   bool is_suspended = pipeline_controller_.IsSuspended();
-  bool is_backgrounded = IsBackgroundedSuspendEnabled() && IsHidden();
+  bool is_backgrounded = IsBackgroundedSuspendEnabled() && IsBackgrounded();
   PlayState state = UpdatePlayState_ComputePlayState(
       is_remote, is_streaming, is_suspended, is_backgrounded);
   SetDelegateState(state.delegate_state, state.is_idle);
   SetMemoryReportingState(state.is_memory_reporting_enabled);
   SetSuspendState(state.is_suspended || pending_suspend_resume_cycle_);
 }
 
 void WebMediaPlayerImpl::SetDelegateState(DelegateState new_state,
                                           bool is_idle) {
   DCHECK(delegate_);
@@ skipping 124 matching lines @@
   bool background_suspended = !is_streaming && is_backgrounded_video &&
                               !(can_play_backgrounded && is_background_playing);
   bool background_pause_suspended =
       !is_streaming && is_backgrounded && paused_ && have_future_data;
 
   // Idle suspension is allowed prior to have future data since there exist
   // mechanisms to exit the idle state when the player is capable of reaching
   // the have future data state; see didLoadingProgress().
   //
   // TODO(sandersd): Make the delegate suspend idle players immediately when
-  // hidden.
+  // in the background.
   bool idle_suspended =
       !is_streaming && is_stale && paused_ && !seeking_ && !overlay_enabled_;
 
   // If we're already suspended, see if we can wait for user interaction. Prior
   // to HaveFutureData, we require |is_stale| to remain suspended. |is_stale|
   // will be cleared when we receive data which may take us to HaveFutureData.
   bool can_stay_suspended =
       (is_stale || have_future_data) && is_suspended && paused_ && !seeking_;
 
   // Combined suspend state.
@@ skipping 133 matching lines @@
       hasAudio(), hasVideo(), !!chunk_demuxer_, is_encrypted_, media_log_,
       pipeline_metadata_.natural_size,
       base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_->IsFrameHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
-bool WebMediaPlayerImpl::IsHidden() const {
+bool WebMediaPlayerImpl::IsBackgrounded() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
+  // Nothing related to the media being in the background should matter if the
+  // frame is closed. However, the delegate might call OnFrameHidden() when
+  // closed so specifically exclude this case.
   return delegate_->IsFrameHidden() && !delegate_->IsFrameClosed();
 }
 
 bool WebMediaPlayerImpl::IsStreaming() const {
   return data_source_ && data_source_->IsStreaming();
 }
 
 bool WebMediaPlayerImpl::DoesOverlaySupportMetadata() const {
   return pipeline_metadata_.video_rotation == VIDEO_ROTATION_0;
 }
 
 void WebMediaPlayerImpl::ActivateViewportIntersectionMonitoring(bool activate) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   client_->activateViewportIntersectionMonitoring(activate);
 }
 
-bool WebMediaPlayerImpl::ShouldPauseVideoWhenHidden() const {
+bool WebMediaPlayerImpl::ShouldPauseVideoWhenBackground() const {
 #if !defined(OS_ANDROID)
   // On desktop, this behavior is behind the feature flag.
   if (!IsBackgroundVideoTrackOptimizationEnabled())
     return false;
 #endif
 
   // Pause video-only players that match the criteria for being optimized.
   return !hasAudio() && IsBackgroundOptimizationCandidate();
 }
 
-bool WebMediaPlayerImpl::ShouldDisableVideoWhenHidden() const {
+bool WebMediaPlayerImpl::ShouldDisableVideoWhenBackground() const {
   // This optimization is behind the flag on all platforms.
   if (!IsBackgroundVideoTrackOptimizationEnabled())
     return false;
 
   // Disable video track only for players with audio that match the criteria for
   // being optimized.
   return hasAudio() && IsBackgroundOptimizationCandidate();
 }
 
 bool WebMediaPlayerImpl::IsBackgroundOptimizationCandidate() const {
@@ skipping 19 matching lines @@
   if (duration < max_keyframe_distance_to_disable_background_video_)
     return true;
 
   // Otherwise, only optimize videos with shorter average keyframe distance.
   PipelineStatistics stats = GetPipelineStatistics();
   return stats.video_keyframe_distance_average <
          max_keyframe_distance_to_disable_background_video_;
 }
 
 void WebMediaPlayerImpl::UpdateBackgroundVideoOptimizationState() {
-  if (IsHidden()) {
-    if (ShouldPauseVideoWhenHidden())
+  if (IsBackgrounded()) {
+    if (ShouldPauseVideoWhenBackground())
       PauseVideoIfNeeded();
     else
       DisableVideoTrackIfNeeded();
   } else {
     EnableVideoTrackIfNeeded();
   }
 }
 
 void WebMediaPlayerImpl::PauseVideoIfNeeded() {
-  DCHECK(IsHidden());
+  DCHECK(IsBackgrounded());
 
   // Don't pause video while the pipeline is stopped, resuming or seeking.
   // Also if the video is paused already.
   if (!pipeline_.IsRunning() || is_pipeline_resuming_ || seeking_ || paused_)
     return;
 
-  // OnPause() will set |paused_when_hidden_| to false and call
+  // OnPause() will set |paused_when_background_| to false and call
   // UpdatePlayState(), so set the flag to true after and then return.
   OnPause();
-  paused_when_hidden_ = true;
+  paused_when_background_ = true;
 }
 
 void WebMediaPlayerImpl::EnableVideoTrackIfNeeded() {
   // Don't change video track while the pipeline is stopped, resuming or
   // seeking.
   if (!pipeline_.IsRunning() || 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());
+  DCHECK(IsBackgrounded());
 
   // 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_ && ShouldDisableVideoWhenBackground()) {
     video_track_disabled_ = true;
     selectedVideoTrackChanged(nullptr);
   }
 }
 
 void WebMediaPlayerImpl::SetPipelineStatisticsForTest(
     const PipelineStatistics& stats) {
   pipeline_statistics_for_test_ = base::make_optional(stats);
 }
 
@@ skipping 23 matching lines @@
     UMA_HISTOGRAM_TIMES(
         "Media.Video.TimeFromForegroundToFirstFrame.DisableTrack",
         time_to_first_frame);
   } else {
     UMA_HISTOGRAM_TIMES("Media.Video.TimeFromForegroundToFirstFrame.Paused",
                         time_to_first_frame);
   }
 }
 
 }  // namespace media