Implementation of MediaCodecPlayer stage 1

media/base/android/media_codec_player_state.cc

+#include "media/base/android/media_codec_player_state.h"
+#include "media/base/android/media_codec_player.h"
+#include "media/base/buffers.h"
+
+namespace media {
+
+// Every method is called on the Media thread
+
+// MediaCodecPlayerState (superclass)
+
+// By default, set configs for the future use
+void MediaCodecPlayerState::EventDemuxerConfigsAvailable(
+    MediaCodecPlayer* player, const DemuxerConfigs& configs) {
+  player->SetDemuxerConfigs(configs);
+}
+
+// By default, set the Error state that blocks all events
+void MediaCodecPlayerState::EventError(MediaCodecPlayer* player) {
+  player->SetState(StateError::Instance());
+}
+
+// Stop decoders synchronously.
+// TODO: as it seems to work for every state, consider moving Release()
+//       out of the state machine.
+void MediaCodecPlayerState::EventRelease(MediaCodecPlayer* player) {
+  player->SetState(StatePaused::Instance());
+  player->ReleaseDecoderResources();
+}
+
+
+// StatePaused
+
+void StatePaused::EventStart(MediaCodecPlayer* player) {
+  player->SetState(StatePrefetching::Instance());
+  player->StartPrefetchDecoders();
+}
+
+
+// StatePrefetching
+
+void StatePrefetching::EventPause(MediaCodecPlayer* player) {
+  player->SetState(StatePaused::Instance());

[qinmin, 2015/05/14 19:52:58]

I have bad feelings about these call sequences, and all the functions here has
the same issue.

Player calls EventPause() when the state == StatePrefetching. And inside this
call, we call SetState(StatePaused), and then call player->xxxx(). 
So when player->xxxx() executes, the state is already changed.
From the player's perspective, it is very wierd that calling state->EventPause()
will incur an reentrance call.

[Tima Vaisburd, 2015/05/15 00:12:40]

Yes, it does look somewhat weird. The code like
    void StatePlaying::EventPause(MediaCodecPlayer* player) {
        player->RequestToStopDecoders();
        player->SetState(StateStopping::Instance());
    }
would look more natural.

I did it for a theoretical possibility that an operation sends another event,
e.g.
        // in StatePlaying
        player->RequestToStopDecoders();
             // calls state_->EventStart(); State machine thinks we are playing
             // so there is nothing to do
        player->SetState(StateStopping::Instance());

As long as we post all events this problem should not arise.
I can change the order everywhere but it feels to me a little bit safer now.

+  player->StopDecoders();
+}
+
+void StatePrefetching::EventPrefetchDone(MediaCodecPlayer* player) {
+  if (!player->HasAudio() && !player->HasVideo()) {
+    // No configuration at all, let's wait for it.
+    // Although it probably should never happen here,
+    // after the data has come from demuxer.
+    player->SetState(StateWaitingForConfig::Instance());
+    return;
+  }
+
+  if (player->HasVideo() && !player->HasPendingSurface()) {
+    player->SetState(StateWaitingForSurface::Instance());
+    return;
+  }
+
+  player->SetState(StatePlaying::Instance());
+  player->StartPlaybackDecoders();
+}
+
+
+// StateWaitingForConfig
+
+void StateWaitingForConfig::EventDemuxerConfigsAvailable(
+    MediaCodecPlayer* player, const DemuxerConfigs& configs) {
+
+  player->SetDemuxerConfigs(configs);
+
+  if (player->HasVideo() && !player->HasPendingSurface()) {
+    player->SetState(StateWaitingForSurface::Instance());
+    return;
+  }
+
+  player->SetState(StatePlaying::Instance());
+  player->StartPlaybackDecoders();
+}
+
+void StateWaitingForConfig::EventPause(MediaCodecPlayer* player) {
+  player->SetState(StatePaused::Instance());
+}
+
+
+// StateWaitingForSurface
+
+void StateWaitingForSurface::EventSetVideoSurface(MediaCodecPlayer* player) {
+  player->SetState(StatePlaying::Instance());
+  player->StartPlaybackDecoders();
+}
+
+void StateWaitingForSurface::EventPause(MediaCodecPlayer* player) {
+  player->SetState(StatePaused::Instance());
+  player->StopDecoders();
+}
+
+
+// StatePlaying
+
+void StatePlaying::EventPause(MediaCodecPlayer* player) {
+  player->SetState(StateStopping::Instance());
+  player->RequestToStopDecoders();
+}
+
+void StatePlaying::EventStarvation(MediaCodecPlayer* player) {
+  player->SetState(StateStopping::Instance());
+  player->RequestToStopDecoders();
+  player->SetPendingStart(true);
+}
+
+void StatePlaying::EventStopDone(MediaCodecPlayer* player) {
+  // Unexpected stop means completion
+  player->SetState(StatePaused::Instance());
+}
+
+void StatePlaying::EventError(MediaCodecPlayer* player) {
+  player->SetState(StateError::Instance());
+  player->ReleaseDecoderResources();
+}
+
+
+// StateStopping
+
+void StateStopping::EventStart(MediaCodecPlayer* player) {
+  player->SetPendingStart(true);
+}
+
+void StateStopping::EventStopDone(MediaCodecPlayer* player) {
+  if (player->HasPendingStart()) {
+    player->SetState(StatePrefetching::Instance());
+    player->StartPrefetchDecoders();
+  } else {
+    player->SetState(StatePaused::Instance());
+  }
+}
+
+}  // namespace media