Added stub MediaSourcePlayer for developing behind the flag

media/base/android/media_source_player_with_dedicated_thread.cc

+// Copyright 2015 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.
+
+#include "media/base/android/media_source_player_with_dedicated_thread.h"
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/threading/thread.h"
+
+#include "media/base/android/media_player_manager.h"
+#include "media/base/android/media_source_player_impl.h"
+
+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();
+}
+
+MediaSourcePlayerWithDedicatedThread::MediaSourcePlayerWithDedicatedThread(
+    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),
+      weak_factory_(this)
+{
+  // UI thread
+  DVLOG(1) << "MediaSourcePlayerWithDedicatedThread: player_id:" << player_id;
+
+  impl_ = new MediaSourcePlayerImpl(demuxer.Pass());
+}
+
+MediaSourcePlayerWithDedicatedThread::~MediaSourcePlayerWithDedicatedThread()
+{
+  // UI thread
+  DVLOG(1) << "~MediaSourcePlayerWithDedicatedThread: player_id:"
+           << player_id();
+
+  // Postpone the deletion of |impl_| until it is properly stopped
+  // on the Media thread.
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&MediaSourcePlayerImpl::DestroySelf,
+                            base::Unretained(impl_)));
+}
+
+// MediaPlayerAndroid implementation.
+// The methods are called on UI thread
+
+void MediaSourcePlayerWithDedicatedThread::SetVideoSurface(
+    gfx::ScopedJavaSurface surface) {
+  DVLOG(1) << __FUNCTION__;
+
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&MediaSourcePlayerImpl::SetVideoSurface,
+                            base::Unretained(impl_), base::Passed(&surface)));
+}

[xhwang, 2015/05/01 06:55:05]

Can you just do something like:

void MediaSourcePlayer::SetVideoSurface() {
  if (NotOnMediaTaskRunner()) {
    GetMediaTaskRunner()->PostTask(
        FROM_HERE, base::Bind(&MediaSourcePlayerImpl::SetVideoSurface,
                               weak_factory_.GetWeakPtr(),
base::Passed(&surface)));
    return;
  }

  // Do work.
}

Then you don't need MediaSourcePlayerWithDedicatedThread.

[timav, 2015/05/01 18:14:10]

Sorry, I did not understand your point here.

The main reason to have two classes (MSPWDT and MSPI, I agree with what you said
about the naming, they are actually PlayerFacade and Player) is the desire to
properly stop and destroy the Player on the Media thread. In the destructor of
the PlayerFacade I do not delete the |impl_|, the Player destruction is
postponed and it happens on Media thread (decoder threads stopped, then
MediaCodecs released, surface released, then we delete the Player).

Initially we wanted to use a scoped_ptr with Deleter, but first, we did not want
to modify BrowserMediaPlayerManager which uses std::vector<raw pointer>, and
second, I did not find a way to push a scoped_ptr into std::vector (no copy
constructor).

Another thing is that the current MediaSourcePlayer should remain, Grace advised
on gradually switching between them for some % of user base.

Did you mean to have the current MediaSourcePlayer redirect some calls to MSPI
when the command line flag is set?

[xhwang, 2015/05/01 20:26:35]

Sorry for the confusion. I was just proposing to merge
MediaSourcePlayerWithDedicatedThread and MediaSourcePlayerImpl. Your current CL
works but I wonder whether that's necessary. See comments inline:

On 2015/05/01 18:14:10, timav wrote:
Can you use DeleteSoon for delayed deletion on the media thread?
 
I am not following. But you can use ScopedVector if you want to store scoped_ptr
in a vector.
 
Totally agreed. We should keep MediaSourcePlayer, and have MediaCodecPlayer at
the same time (behind the flag).
No. I suggested to have MediaCodecPlayer posting tasks from UI to Media thread
by itself, instead having another MediaSourcePlayerWithDedicatedThread class.
You can see examples at:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

[timav, 2015/05/06 06:46:28]

Done.

+
+void MediaSourcePlayerWithDedicatedThread::Start() {

[xhwang, 2015/05/01 06:55:05]

I am not a fan of the name MediaSourcePlayerImpl and
MediaSourcePlayerWithDedicatedThread. It's really not an implementation of
MediaSourcePlayer :)

Actually if you think of it, it's not limited to MediaSource (MSE spec). If I
use a normal demuxer (instead of the ChunkDemuxer) at the render side and send
demuxed buffers to the browser, this player will still work. With that, maybe we
can just start with a new name. This is really just a MediaCodecBridge based
MediaPlayerAndroid implementation. How about MediaCodecPlayer? Or if you have
better names go for it!

[timav, 2015/05/01 18:14:10]

I completely agree :-)
I will get in agreement with Min about the naming and rename.

[qinmin, 2015/05/01 19:12:14]

MediaCodecPlayer sgtm

[timav, 2015/05/06 06:46:29]

Done.

+  DVLOG(1) << __FUNCTION__;
+
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MediaSourcePlayerImpl::Start, base::Unretained(impl_)));
+}
+
+void MediaSourcePlayerWithDedicatedThread::Pause(
+    bool /* is_media_related_action */) {
+  DVLOG(1) << __FUNCTION__;
+
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MediaSourcePlayerImpl::Pause, base::Unretained(impl_)));
+}
+
+void MediaSourcePlayerWithDedicatedThread::SeekTo(base::TimeDelta timestamp) {
+  DVLOG(1) << __FUNCTION__ << " " << timestamp;
+
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MediaSourcePlayerImpl::SeekTo,
+                 base::Unretained(impl_), timestamp));
+}
+
+void MediaSourcePlayerWithDedicatedThread::Release() {
+  DVLOG(1) << __FUNCTION__;
+
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MediaSourcePlayerImpl::Release, base::Unretained(impl_)));
+}
+
+void MediaSourcePlayerWithDedicatedThread::SetVolume(double volume) {
+  DVLOG(1) << __FUNCTION__ << " " << volume;
+  GetMediaTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MediaSourcePlayerImpl::SetVolume,
+                 base::Unretained(impl_), volume));
+}
+
+int MediaSourcePlayerWithDedicatedThread::GetVideoWidth() {
+  return impl_->GetVideoWidth();
+}
+
+int MediaSourcePlayerWithDedicatedThread::GetVideoHeight() {
+  return impl_->GetVideoHeight();
+}
+
+base::TimeDelta MediaSourcePlayerWithDedicatedThread::GetCurrentTime() {
+  return impl_->GetCurrentTime();
+}
+
+base::TimeDelta MediaSourcePlayerWithDedicatedThread::GetDuration() {
+  return impl_->GetDuration();
+}
+
+bool MediaSourcePlayerWithDedicatedThread::IsPlaying() {
+  return impl_->IsPlaying();
+}
+
+bool MediaSourcePlayerWithDedicatedThread::CanPause() {
+  return impl_->CanPause();
+}
+
+bool MediaSourcePlayerWithDedicatedThread::CanSeekForward() {
+  return impl_->CanSeekForward();
+}
+
+bool MediaSourcePlayerWithDedicatedThread::CanSeekBackward() {
+  return impl_->CanSeekBackward();
+}
+
+bool MediaSourcePlayerWithDedicatedThread::IsPlayerReady() {
+  return impl_->IsPlayerReady();
+}
+
+void MediaSourcePlayerWithDedicatedThread::SetCdm(BrowserCdm* cdm) {
+  DVLOG(1) << __FUNCTION__;
+}
+
+}  // namespace media