[Cleanup] Rename Hidden to Background in WMPI.

media/blink/webmediaplayer_impl.h

 // 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.
 
 #ifndef MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 #define MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 311 matching lines @@
 
   // Inspects the current playback state and:
   //   - notifies |delegate_|,
   //   - toggles the memory usage reporting timer, and
   //   - toggles suspend/resume as necessary.
   //
   // This method should be called any time its dependent values change. These
   // are:
   //   - isRemote(),
   //   - hasVideo(),
-  //   - delegate_->IsHidden(),
+  //   - delegate_->IsFrameHidden(),
   //   - network_state_, ready_state_,
   //   - is_idle_, must_suspend_,
   //   - paused_, ended_,
   //   - pending_suspend_resume_cycle_,
   void UpdatePlayState();
 
   // Methods internal to UpdatePlayState().
   PlayState UpdatePlayState_ComputePlayState(bool is_remote,
                                              bool is_streaming,
                                              bool is_suspended,
                                              bool is_backgrounded);
   void SetDelegateState(DelegateState new_state, bool is_idle);
   void SetMemoryReportingState(bool is_memory_reporting_enabled);
   void SetSuspendState(bool is_suspended);
 
   // Called at low frequency to tell external observers how much memory we're
   // using for video playback.  Called by |memory_usage_reporting_timer_|.
   // Memory usage reporting is done in two steps, because |demuxer_| must be
   // accessed on the media thread.
   void ReportMemoryUsage();
   void FinishMemoryUsageReport(int64_t demuxer_memory_usage);
 
-  // Called during OnHidden() when we want a suspended player to enter the
+  // Called during OnFrameHidden() when we want a suspended player to enter the
   // paused state after some idle timeout.
   void ScheduleIdlePauseTimer();
 
   // Returns |true| before HaveFutureData whenever there has been loading
   // progress and we have not been resumed for at least kLoadingToIdleTimeout
   // since then.
   //
   // This is used to delay suspension long enough for preroll to complete, which
   // is necessay because play() will not be called before HaveFutureData (and
   // thus we think we are idle forever).
   bool IsPrerollAttemptNeeded();
 
   void CreateWatchTimeReporter();
 
-  // Returns true if the player is hidden.
-  bool IsHidden() const;
+  // Returns true if the player is in the background.
+  bool IsBackgrounded() const;
 
   // Returns true if the player's source is streaming.
   bool IsStreaming() const;
 
   // Return whether |pipeline_metadata_| is compatible with an overlay. This
   // is intended for android.
   bool DoesOverlaySupportMetadata() const;
 
-  // Whether the video should be paused when hidden. Uses metadata so has
-  // meaning only after the pipeline has started, otherwise returns false.
+  // Whether the video should be paused when in the background. Uses metadata so
+  // has meaning only after the pipeline has started, otherwise returns false.
   // Doesn't check if the video can actually be paused depending on the
   // pipeline's state.
-  bool ShouldPauseVideoWhenHidden() const;
+  bool ShouldPauseVideoWhenBackground() const;
 
-  // Whether the video track should be disabled when hidden. Uses metadata so
-  // has meaning only after the pipeline has started, otherwise returns false.
-  // Doesn't check if the video track can actually be disabled depending on the
-  // pipeline's state.
-  bool ShouldDisableVideoWhenHidden() const;
+  // Whether the video track should be disabled when in the background. Uses
+  // metadata so has meaning only after the pipeline has started, otherwise
+  // returns false. Doesn't check if the video track can actually be disabled
+  // depending on the pipeline's state.
+  bool ShouldDisableVideoWhenBackground() const;
 
   // Whether the video is suitable for background playback optimizations (either
   // pausing it or disabling the video track). Uses metadata so has meaning only
   // after the pipeline has started, otherwise returns false.
   // The logical OR between the two methods above that is also used as their
   // common implementation.
   bool IsBackgroundOptimizationCandidate() const;
 
   // If enabling or disabling background video optimization has been delayed,
   // because of the pipeline not running, seeking or resuming, this method
   // needs to be called to update the optimization state.
   void UpdateBackgroundVideoOptimizationState();
 
-  // Pauses a hidden video only player to save power if possible.
+  // Pauses a background video only player to save power if possible.
   // Must be called when either of the following happens:
-  // - right after the video was hidden,
-  // - right ater the pipeline has resumed if the video is hidden.
+  // - right after the video was backgrounded,
+  // - right ater the pipeline has resumed if the video is in the background.
   void PauseVideoIfNeeded();
 
   // Disables the video track to save power if possible.
   // Must be called when either of the following happens:
-  // - right after the video was hidden,
+  // - right after the video was backgrounded,
   // - right after the pipeline has started (|seeking_| is used to detect the
-  //   when pipeline started) if the video is hidden,
-  // - right ater the pipeline has resumed if the video is hidden.
+  //   when pipeline started) if the video is in the background,
+  // - right ater the pipeline has resumed if the video is in the background.
   void DisableVideoTrackIfNeeded();
 
   // Enables the video track if it was disabled before to save power.
   // Must be called when either of the following happens:
-  // - right after the video was shown,
+  // - right after the video was put in the foreground,
   // - right before the pipeline is requested to resume
   //   (see https://crbug.com/678374),
-  // - right after the pipeline has resumed if the video is not hidden.
+  // - right after the pipeline has resumed if the video is not in the
+  //   background.
   void EnableVideoTrackIfNeeded();
 
   // Overrides the pipeline statistics returned by GetPiplineStatistics() for
   // tests.
   void SetPipelineStatisticsForTest(const PipelineStatistics& stats);
 
   // Returns the pipeline statistics or the value overridden by tests.
   PipelineStatistics GetPipelineStatistics() const;
 
   // Overrides the pipeline media duration returned by
@@ skipping 58 matching lines @@
   // to hang the render thread during pause(), we record the time at the same
   // time we pause and then return that value in currentTime().  Otherwise our
   // clock can creep forward a little bit while the asynchronous
   // SetPlaybackRate(0) is being executed.
   double playback_rate_;
 
   // Set while paused. |paused_time_| is only valid when |paused_| is true.
   bool paused_;
   base::TimeDelta paused_time_;
 
-  // Set if paused automatically when hidden and need to resume when visible.
-  // Reset if paused for any other reason.
-  bool paused_when_hidden_;
+  // Set if paused automatically when backgrounded and need to resume when
+  // foregrounded. Reset if paused for any other reason.
+  bool paused_when_background_;
 
   // Set when starting, seeking, and resuming (all of which require a Pipeline
   // seek). |seek_time_| is only valid when |seeking_| is true.
   bool seeking_;
   base::TimeDelta seek_time_;
 
   // Set when doing a restart (a suspend and resume in sequence) of the pipeline
   // in order to destruct and reinitialize the decoders. This is separate from
   // |pending_resume_| and |pending_suspend_| because they can be elided in
   // certain cases, whereas for a restart they must happen.
@@ skipping 171 matching lines @@
 
   // Pipeline media duration overridden by tests.
   base::Optional<base::TimeDelta> pipeline_media_duration_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_