Re-land extract state management from WebMediaPlayerImpl.

media/blink/pipeline_state.h

+// Copyright 2015 The Chromium Authors. All rights reserved.

[xhwang, 2016/02/01 21:16:44]

nit: 2016

[sandersd (OOO until July 31), 2016/02/01 23:19:26]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BLINK_PIPELINE_STATE_H_
+#define MEDIA_BLINK_PIPELINE_STATE_H_

[xhwang, 2016/02/01 21:16:44]

Can we put this file in the same folder as the pipeline.*? It seems it doesn't
depend on anything related to blink.

Note that pipeline.* is currently in media/base which probably isn't the ideal
place. But that's a separate issue.

[sandersd (OOO until July 31), 2016/02/01 23:19:26]

It depends on media/filters; I wasn't sure if that is allowed.

[xhwang, 2016/02/01 23:26:00]

Then probably we should put this under media/filters, and then move pipeline.*
over in the future as well. +dalecurtis

+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "media/base/pipeline.h"
+#include "media/base/renderer.h"
+
+namespace media {
+
+class ChunkDemuxer;
+class Demuxer;
+
+// PipelineState wraps a Pipeline to expose the one-at-a-time operations
+// (Seek(), Suspend(), and Resume()) with a simpler API. Internally it tracks
+// pending operations and dispatches them when possible. Duplicate requests
+// (such as seeking twice to the same time) may be elided.
+//
+// "Stable state", used in comments below, means that |state_| is PLAYING and
+// there are no pending operations. When the state is not stable, it means that
+// |pipeline_| is processing an operation and that incoming requests will be
+// queued. (Exception: even though SUSPENDED is not a stable state, a Resume()
+// request while suspended is processed immediately.)
+//
+// TODO(sandersd):
+//   - Expose an operation that restarts via suspend+resume.
+//   - Block invalid calls after an error occurs.
+class PipelineState {

[xhwang, 2016/02/01 21:16:44]

Can we hide this in the Pipeline so that WMPI only need to deal with one
Pipeline which has this simpler API?

Actually it seems the PipelineState is the new Pipeline, and the Pipeline is
more like a PipelineImpl. Do we really need to expose the old Pipeline to WMPI?

[sandersd (OOO until July 31), 2016/02/01 23:19:26]

That's exactly the plan (pending some changes to the Demuxer interface so that
we can drop the ChunkDemuxer dependency).

However, I only wanted to tackle one refactor at a time, and so I have this
in-between CL.

+ public:
+  enum class State {
+    PLAYING,
+    SEEKING,
+    SUSPENDING,
+    SUSPENDED,
+    RESUMING,
+  };
+
+  typedef base::Callback<scoped_ptr<Renderer>(void)> RendererFactoryCB;
+  typedef base::Callback<void(bool time_updated)> SeekedCB;
+  typedef base::Callback<void()> SuspendedCB;
+
+  PipelineState(Pipeline* pipeline,
+                const RendererFactoryCB& renderer_factory_cb,
+                const SeekedCB& seeked_cb,
+                const SuspendedCB& suspended_cb,
+                const PipelineStatusCB& error_cb);
+  ~PipelineState();
+
+  // Start |pipeline_|. If provided, |chunk_demuxer| will be stored and
+  // StartWaitingForSeek()/CancelPendingSeek() will be issued to it as
+  // necessary. Other parameters are just passed directly to |pipeline_|.
+  void Start(ChunkDemuxer* chunk_demuxer,
+             Demuxer* demuxer,
+             const base::Closure& ended_cb,
+             const PipelineMetadataCB& metadata_cb,
+             const BufferingStateCB& buffering_state_cb,
+             const base::Closure& duration_change_cb,
+             const AddTextTrackCB& add_text_track_cb,
+             const base::Closure& waiting_for_decryption_key_cb);
+
+  void Seek(base::TimeDelta time, bool time_updated);
+  void Suspend();
+  void Resume();
+
+  // Returns true if the current state is stable.
+  bool IsPlaying();
+
+  // Returns true if |pipeline_| is suspended. Specifically, it is false while
+  // suspending and true while resuming. (The compositor is expected to not
+  // render any new frames while IsSuspended() returns true.)
+  bool IsSuspended();
+
+ private:
+  // Attempts to make progress from the current state to the target state.
+  void Dispatch();
+
+  // PipelineStaus callback that also carries the target state.
+  void OnPipelineStatus(State state, PipelineStatus pipeline_status);
+
+  // The Pipeline we are managing state for.
+  Pipeline* pipeline_ = nullptr;
+
+  // Factory for Renderers, used for Start() and Resume().
+  RendererFactoryCB renderer_factory_cb_;
+
+  // Called after seeks (which includes Start()) upon reaching a stable state.
+  // Multiple seeks result in only one callback if no stable state occurs
+  // between them.
+  SeekedCB seeked_cb_;
+
+  // Called immediately when |pipeline_| completes a suspend operation.
+  SuspendedCB suspended_cb_;
+
+  // Called immediately when any operation on |pipeline_| results in an error.
+  PipelineStatusCB error_cb_;
+
+  // State for handling StartWaitingForSeek()/CancelPendingSeek().
+  ChunkDemuxer* chunk_demuxer_ = nullptr;
+  bool waiting_for_seek_ = false;
+
+  // Tracks the current state of |pipeline_|.
+  State state_ = State::PLAYING;
+
+  // Indicates that a seek has occurred. When set, a seeked callback will be
+  // issued at the next stable state.
+  bool pending_seeked_ = true;
+
+  // Indicates that time has been changed by a seek, which will be reported at
+  // the next seeked callback.
+  bool pending_time_update_ = false;
+
+  // The target time of the active seek; valid while SEEKING or RESUMING.
+  base::TimeDelta seek_time_;
+
+  // Target state which we will work to achieve. |pending_seek_time_| is only
+  // valid when |pending_seek_| is true.
+  bool pending_seek_ = false;
+  base::TimeDelta pending_seek_time_;
+  bool pending_suspend_ = false;
+  bool pending_resume_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(PipelineState);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BLINK_PIPELINE_STATE_H_