Revert of Extract state management from WebMediaPlayerImpl.

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 <string>
@@ skipping 12 matching lines @@
 #include "media/base/surface_manager.h"
 #include "media/base/text_track.h"
 #include "media/blink/buffered_data_source.h"
 #include "media/blink/buffered_data_source_host_impl.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/multibuffer_data_source.h"
 #include "media/blink/video_frame_compositor.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "media/blink/webmediaplayer_util.h"
-#include "media/filters/pipeline_controller.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProvider.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)  // WMPI_CAST
 // Delete this file when WMPI_CAST is no longer needed.
 #include "media/blink/webmediaplayer_cast_android.h"
 #endif
@@ skipping 115 matching lines @@
 
   blink::WebAudioSourceProvider* audioSourceProvider() override;
 
   void setContentDecryptionModule(
       blink::WebContentDecryptionModule* cdm,
       blink::WebContentDecryptionModuleResult result) override;
 
   void enteredFullscreen() override;
   void exitedFullscreen() override;
 
+  void OnPipelineSeeked(bool time_changed, PipelineStatus status);
+  void OnPipelineSuspended(PipelineStatus status);
+  void OnPipelineEnded();
+  void OnPipelineError(PipelineStatus error);
+  void OnPipelineMetadata(PipelineMetadata metadata);
+  void OnPipelineBufferingStateChanged(BufferingState buffering_state);
+  void OnDemuxerOpened();
+  void OnAddTextTrack(const TextTrackConfig& config,
+                      const AddTextTrackDoneCB& done_cb);
+
   // WebMediaPlayerDelegate::Observer implementation.
   void OnHidden(bool must_suspend) override;
   void OnShown() override;
   void OnPlay() override;
   void OnPause() override;
   void OnVolumeMultiplierUpdate(double multiplier) override;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   bool isRemote() const override;
   void requestRemotePlayback() override;
   void requestRemotePlaybackControl() override;
 
   void SetMediaPlayerManager(
       RendererMediaPlayerManagerInterface* media_player_manager);
   void OnRemotePlaybackEnded();
   void OnDisconnectedFromRemoteDevice(double t);
   void SuspendForRemote();
   void DisplayCastFrameAfterSuspend(const scoped_refptr<VideoFrame>& new_frame,
                                     PipelineStatus status);
   gfx::Size GetCanvasSize() const;
   void SetDeviceScaleFactor(float scale_factor);
 #endif
 
-  // Called from WebMediaPlayerCast.
-  // TODO(hubbe): WMPI_CAST make private.
-  void OnPipelineSeeked(bool time_updated);
+ private:
+  // Ask for the pipeline to be suspended, will call Suspend() when ready.
+  // (Possibly immediately.)
+  void ScheduleSuspend();
 
- private:
-  void OnPipelineSuspended();
-  void OnPipelineResumed();
-  void OnPipelineEnded();
-  void OnPipelineError(PipelineStatus error);
-  void OnPipelineMetadata(PipelineMetadata metadata);
-  void OnPipelineBufferingStateChanged(BufferingState buffering_state);
-  void OnDemuxerOpened();
-  void OnAddTextTrack(const TextTrackConfig& config,
-                      const AddTextTrackDoneCB& done_cb);
+  // Initiate suspending the pipeline.
+  void Suspend();
 
-  // Actually seek. Avoids causing |should_notify_time_changed_| to be set when
-  // |time_updated| is false.
-  void DoSeek(base::TimeDelta time, bool time_updated);
+  // Ask for the pipeline to be resumed, will call Resume() when ready.
+  // (Possibly immediately.)
+  void ScheduleResume();
+
+  // Initiate resuming the pipeline.
+  void Resume();
 
   // Ask for the renderer to be restarted (destructed and recreated).
   void ScheduleRestart();
 
   // Called after |defer_load_cb_| has decided to allow the load. If
   // |defer_load_cb_| is null this is called immediately.
   void DoLoad(LoadType load_type,
               const blink::WebURL& url,
               CORSMode cors_mode);
 
@@ skipping 40 matching lines @@
   // is not available.
   void OnWaitingForDecryptionKey();
 
   // Sets |cdm_context| on the pipeline and fires |cdm_attached_cb| when done.
   // Parameter order is reversed for easy binding.
   void SetCdm(const CdmAttachedCB& cdm_attached_cb, CdmContext* cdm_context);
 
   // Called when a CDM has been attached to the |pipeline_|.
   void OnCdmAttached(bool success);
 
+  // Updates |paused_time_| to the current media time with consideration for the
+  // |ended_| state by clamping current time to duration upon |ended_|.
+  void UpdatePausedTime();
+
   // Notifies |delegate_| that playback has started or was paused; also starts
   // or stops the memory usage reporting timer respectively.
   void NotifyPlaybackStarted();
   void NotifyPlaybackPaused();
 
   // 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();
@@ skipping 12 matching lines @@
   // setBufferingStrategy().
   BufferedDataSource::BufferingStrategy buffering_strategy_;
 
   // Task runner for posting tasks on Chrome's main thread. Also used
   // for DCHECKs so methods calls won't execute in the wrong thread.
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   scoped_refptr<base::TaskRunner> worker_task_runner_;
   scoped_refptr<MediaLog> media_log_;
-
-  // |pipeline_controller_| references |pipeline_| and therefore must be
-  // constructed after and destructed before |pipeline_|.
   PipelineImpl pipeline_;
-  PipelineController pipeline_controller_;
 
   // The LoadType passed in the |load_type| parameter of the load() call.
   LoadType load_type_;
 
   // Cache of metadata for answering hasAudio(), hasVideo(), and naturalSize().
   PipelineMetadata pipeline_metadata_;
 
   // Whether the video is known to be opaque or not.
   bool opaque_;
 
   // Playback state.
   //
   // TODO(scherkus): we have these because Pipeline favours the simplicity of a
   // single "playback rate" over worrying about paused/stopped etc...  It forces
   // all clients to manage the pause+playback rate externally, but is that
   // really a bad thing?
   //
   // TODO(scherkus): since SetPlaybackRate(0) is asynchronous and we don't want
   // 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_;
+  bool seeking_;
 
-  // Set when starting, seeking, and resuming (all of which require a Pipeline
-  // seek). |seek_time_| is only valid when |seeking_| is true.
-  bool seeking_;
+  // Set when seeking (|seeking_| is true) or resuming.
   base::TimeDelta seek_time_;
 
+  // Set when a suspend is required but another suspend or seek is in progress.
+  bool pending_suspend_;
+
+  // Set when suspending immediately after a seek. The time change will happen
+  // after Resume().
+  bool pending_time_change_;
+
+  // Set when a resume is required but suspending is in progress.
+  bool pending_resume_;
+
+  // Set for the entire period between suspend starting and resume completing.
+  bool suspending_;
+
+  // Set while suspending to detect double-suspend.
+  bool suspended_;
+
+  // Set while resuming to detect double-resume.
+  bool resuming_;
+
   // 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.
   // TODO(sandersd,watk): Create a simpler interface for a pipeline restart.
   bool pending_suspend_resume_cycle_;
 
   // TODO(scherkus): Replace with an explicit ended signal to HTMLMediaElement,
   // see http://crbug.com/409280
   bool ended_;
 
+  // Indicates that a seek is queued after the current seek completes or, if the
+  // pipeline is suspended, after it resumes. Only the last queued seek will
+  // have any effect.
+  bool pending_seek_;
+
+  // |pending_seek_time_| is meaningless when |pending_seek_| is false.
+  base::TimeDelta pending_seek_time_;
+
   // Tracks whether to issue time changed notifications during buffering state
   // changes.
   bool should_notify_time_changed_;
 
   bool fullscreen_;
 
   // Whether the current decoder requires a restart on fullscreen transitions.
   bool decoder_requires_restart_for_fullscreen_;
 
   blink::WebMediaPlayerClient* client_;
@@ skipping 68 matching lines @@
   // started; prevents us from spuriously logging errors that are transient or
   // unimportant.
   bool suppress_destruction_errors_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_