Added stub MediaSourcePlayer for developing behind the flag

media/base/android/media_codec_player.cc

Index: media/base/android/media_codec_player.cc
diff --git a/media/base/android/media_codec_player.cc b/media/base/android/media_codec_player.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5e7b6b536ec7f23c6b723bb5afa7e46cdb9cb6f5
--- /dev/null
+++ b/media/base/android/media_codec_player.cc
@@ -0,0 +1,213 @@
+#include "media/base/android/media_codec_player.h"
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+
+#define POST_TO_MEDIA_THREAD(closure) \

[xhwang, 2015/05/06 17:42:44]

This doesn't always "post". How about POST_TO_MEDIA_THREAD_IF_NEEDED? 

Actually I am not sure whether this improves readability. Please see comments
below.

[Tima Vaisburd, 2015/05/08 07:30:54]

I tried to make it better. Please see the comments below and the code.

+  do {                                                        \
+    if (!GetMediaTaskRunner()->BelongsToCurrentThread()) {    \
+      GetMediaTaskRunner()->PostTask(FROM_HERE, closure);     \
+      return;                                                 \
+    }                                                         \
+  } while(0)
+
+
+namespace media {
+
+class MediaThread : public base::Thread {
+ public:
+  MediaThread() : base::Thread("BrowserMediaThread") {
+    Start();
+  }
+};
+
+// Create media thread
+base::LazyInstance<MediaThread>::Leaky
+    g_media_thread = LAZY_INSTANCE_INITIALIZER;
+
+
+scoped_refptr<base::SingleThreadTaskRunner> GetMediaTaskRunner() {
+  return g_media_thread.Pointer()->task_runner();
+}
+
+// MediaCodecPlayer implementation.
+
+MediaCodecPlayer::MediaCodecPlayer(
+    int player_id,
+    MediaPlayerManager* manager,
+    const RequestMediaResourcesCB& request_media_resources_cb,
+    scoped_ptr<DemuxerAndroid> demuxer,
+    const GURL& frame_url)
+    : MediaPlayerAndroid(player_id,
+                         manager,
+                         request_media_resources_cb,
+                         frame_url),
+      ui_task_runner_(base::MessageLoopProxy::current()),
+      demuxer_(demuxer.Pass()),
+      weak_factory_(this) {
+  // UI thread
+  DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
+
+  weak_this_ = weak_factory_.GetWeakPtr();
+
+  // Finish initializaton on Media thread
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&MediaCodecPlayer::Initialize, weak_this_));
+}
+
+MediaCodecPlayer::~MediaCodecPlayer()
+{
+  // Media thread
+  DVLOG(1) << "MediaCodecPlayer::~MediaCodecPlayer";
+}
+
+void MediaCodecPlayer::Initialize() {
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+
+  demuxer_->Initialize(this);
+}
+
+// MediaPlayerAndroid implementation.
+
+void MediaCodecPlayer::DeleteOnCorrectThread() {
+  DVLOG(1) << __FUNCTION__;
+
+  if (ui_task_runner_->BelongsToCurrentThread()) {
+    DetachListener();
+    DestroyListener();
+  }
+
+  if (GetMediaTaskRunner()->BelongsToCurrentThread())
+    delete this;
+  else
+    GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
+}
+
+void MediaCodecPlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {

[xhwang, 2015/05/06 17:42:44]

Use NOTIMPLEMENTED() in these functions.

[Tima Vaisburd, 2015/05/08 07:30:54]

Done.

+  POST_TO_MEDIA_THREAD(

[xhwang, 2015/05/06 17:42:44]

I don't find this macro very readable, maybe because it's missing the "return",
especially when you have this in the middle of a function, e.g. on l.101...

[Tima Vaisburd, 2015/05/08 07:30:54]

Yes. I pulled the base::Bind into the macro, and use it only if it's at the
beginning of the method.
Changed the name to RUN_ON_MEDIA_THREAD. Please take another look. 

+      base::Bind(&MediaCodecPlayer::SetVideoSurface, weak_this_,
+                 base::Passed(&surface)));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+}
+
+void MediaCodecPlayer::Start() {
+  if (ui_task_runner_->BelongsToCurrentThread())
+    AttachListener(NULL);

[xhwang, 2015/05/06 17:42:44]

Seems to worth a comment.

[Tima Vaisburd, 2015/05/08 07:30:54]

A closer look at the AttachListener/DetachListener revealed that I use them
incorrectly here. They should be called from different places when we actually
start and stop playing. I removed them completely for now, it also helps to use
the macro uniformly.

+
+  POST_TO_MEDIA_THREAD(base::Bind(&MediaCodecPlayer::Start, weak_this_));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+}
+
+void MediaCodecPlayer::Pause(bool is_media_related_action) {
+  POST_TO_MEDIA_THREAD(
+      base::Bind(&MediaCodecPlayer::Pause, weak_this_,
+                 is_media_related_action));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+}
+
+void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
+  POST_TO_MEDIA_THREAD(
+      base::Bind(&MediaCodecPlayer::SeekTo, weak_this_, timestamp));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__ << " " << timestamp;
+}
+
+void MediaCodecPlayer::Release() {
+  POST_TO_MEDIA_THREAD(base::Bind(&MediaCodecPlayer::Release, weak_this_));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+}
+
+void MediaCodecPlayer::SetVolume(double volume) {
+  POST_TO_MEDIA_THREAD(
+      base::Bind(&MediaCodecPlayer::SetVolume, weak_this_, volume));
+
+  // Media thread
+  DVLOG(1) << __FUNCTION__ << " " << volume;
+}
+
+int MediaCodecPlayer::GetVideoWidth() {
+  // UI thread

[xhwang, 2015/05/06 17:42:44]

Here and below, DCHECK it's called on the correct thread so you don't need these
comments.

[Tima Vaisburd, 2015/05/08 07:30:54]

Done.

+  return 320;
+}
+
+int MediaCodecPlayer::GetVideoHeight() {
+  // UI thread
+  return 240;
+}
+
+base::TimeDelta MediaCodecPlayer::GetCurrentTime() {
+  // UI thread, Media thread
+  return base::TimeDelta();
+}
+
+base::TimeDelta MediaCodecPlayer::GetDuration() {
+  // UI thread
+  return base::TimeDelta();
+}
+
+bool MediaCodecPlayer::IsPlaying() {
+  // UI thread
+  return false;
+}
+
+bool MediaCodecPlayer::CanPause() {
+  // UI thread
+  return false;
+}
+
+bool MediaCodecPlayer::CanSeekForward() {
+  // UI thread
+  return false;
+}
+
+bool MediaCodecPlayer::CanSeekBackward() {
+  // UI thread
+  return false;
+}
+
+bool MediaCodecPlayer::IsPlayerReady() {
+  // UI thread
+  DVLOG(1) << __FUNCTION__;
+  return true;
+}
+
+void MediaCodecPlayer::SetCdm(BrowserCdm* cdm) {
+  DVLOG(1) << __FUNCTION__;
+}
+
+// Callbacks from Demuxer.
+
+void MediaCodecPlayer::OnDemuxerConfigsAvailable(
+    const DemuxerConfigs& configs) {
+  // Media thread
+  DVLOG(1) << __FUNCTION__;
+}
+
+void MediaCodecPlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
+  // Media thread
+}
+
+void MediaCodecPlayer::OnDemuxerSeekDone(
+    base::TimeDelta actual_browser_seek_time) {
+  // Media thread
+  DVLOG(1) << __FUNCTION__ << " actual_time:" << actual_browser_seek_time;
+}
+
+void MediaCodecPlayer::OnDemuxerDurationChanged(
+    base::TimeDelta duration) {
+  // Media thread
+  DVLOG(1) << __FUNCTION__ << " duration:" << duration;
+}
+
+}  // namespace media