Added stub MediaSourcePlayer for developing behind the flag

content/browser/media/android/browser_demuxer_android.cc

 // 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.
 
 #include "content/browser/media/android/browser_demuxer_android.h"
 
+#include "base/command_line.h"
 #include "content/common/media/media_player_messages_android.h"
+#include "media/base/android/media_source_player.h"
+#include "media/base/media_switches.h"
 
 namespace content {
 
 class BrowserDemuxerAndroid::Internal : public media::DemuxerAndroid {
  public:
   Internal(const scoped_refptr<BrowserDemuxerAndroid>& demuxer,
            int demuxer_client_id)
       : demuxer_(demuxer),
         demuxer_client_id_(demuxer_client_id) {}
 
@@ skipping 17 matching lines @@
   void RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
                           bool is_browser_seek) override {
     DCHECK(ClientIDExists()) << demuxer_client_id_;
     demuxer_->Send(new MediaPlayerMsg_DemuxerSeekRequest(
         demuxer_client_id_, time_to_seek, is_browser_seek));
   }
 
  private:
   // Helper for DCHECKing that the ID is still registered.
   bool ClientIDExists() {
-    return demuxer_->demuxer_clients_.Lookup(demuxer_client_id_);
+    return demuxer_->Lookup(demuxer_client_id_);
   }
 
   scoped_refptr<BrowserDemuxerAndroid> demuxer_;
   int demuxer_client_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Internal);
 };
 
 BrowserDemuxerAndroid::BrowserDemuxerAndroid()
-    : BrowserMessageFilter(MediaPlayerMsgStart) {}
+    : BrowserMessageFilter(MediaPlayerMsgStart) {
+  enable_media_thread_for_media_playback_ =
+      base::CommandLine::ForCurrentProcess()->
+      HasSwitch(switches::kEnableMediaThreadForMediaPlayback);
+
+}
 
 BrowserDemuxerAndroid::~BrowserDemuxerAndroid() {}
 
 void BrowserDemuxerAndroid::OverrideThreadForMessage(
     const IPC::Message& message,
     BrowserThread::ID* thread) {
+  if (enable_media_thread_for_media_playback_)
+    return; // keep default BrowserThread::IO
+
   switch (message.type()) {
     case MediaPlayerHostMsg_DemuxerReady::ID:
     case MediaPlayerHostMsg_ReadFromDemuxerAck::ID:
     case MediaPlayerHostMsg_DurationChanged::ID:
     case MediaPlayerHostMsg_DemuxerSeekDone::ID:
       *thread = BrowserThread::UI;
       return;
   }
 }
 
 bool BrowserDemuxerAndroid::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
+
+  if (enable_media_thread_for_media_playback_) {
+    // Redirect demuxer messages to Media thread
+    if (!media::GetMediaTaskRunner()->BelongsToCurrentThread()) {
+      media::GetMediaTaskRunner()->PostTask(
+          FROM_HERE,
+          base::Bind(
+              base::IgnoreResult(&BrowserDemuxerAndroid::OnMessageReceived),
+              this, message));

[xhwang, 2015/04/24 05:04:13]

Can you use OverrideTaskRunnerForMessage() return the media thread task runner
directly? Then all messages will be redirected to the media thread.

Actually in that case, just use OverrideTaskRunnerForMessage() for both cases.
In the new code, return media thread task runner, in the old code, return UI
thread task runner.

+
+      switch(message.type()) {
+        case MediaPlayerHostMsg_DemuxerReady::ID:
+        case MediaPlayerHostMsg_ReadFromDemuxerAck::ID:
+        case MediaPlayerHostMsg_DurationChanged::ID:
+        case MediaPlayerHostMsg_DemuxerSeekDone::ID:
+          break;
+        default:
+          handled = false;
+          break;
+      }
+      return handled;
+    }
+  }
+
   IPC_BEGIN_MESSAGE_MAP(BrowserDemuxerAndroid, message)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DemuxerReady, OnDemuxerReady)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_ReadFromDemuxerAck,
                         OnReadFromDemuxerAck)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DurationChanged,
                         OnDurationChanged)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DemuxerSeekDone,
                         OnDemuxerSeekDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 scoped_ptr<media::DemuxerAndroid> BrowserDemuxerAndroid::CreateDemuxer(
     int demuxer_client_id) {
   return scoped_ptr<media::DemuxerAndroid>(
       new Internal(this, demuxer_client_id));
 }
 
 void BrowserDemuxerAndroid::AddDemuxerClient(
     int demuxer_client_id,
     media::DemuxerAndroidClient* client) {
   DVLOG(1) << __FUNCTION__ << " peer_pid=" << peer_pid()
            << " demuxer_client_id=" << demuxer_client_id;
+
+  base::AutoLock lock(lock_);

[xhwang, 2015/04/24 05:04:13]

This whole class should still live on one single thread, either the media
thread, or the UI thread. I don't quite follow why we need a lock here....

[timav, 2015/04/24 18:55:32]

Xiaohan, thank you for looking into this!
In this stub (and admittedly not very interesting) implementation the methods
AddDemuxerClient() and RemoveDemuxerClient() are called on the UI thread, while
others - on the Media thread. That's why I added the lock.
In the real implementation we destroy the player (which is the demuxer client)
on the Media thread, and thus call RemoveDemuxerClient on the Media thread. But
construction and the call to Add still happens on the UI thread.
Can we call AddDemuxerClient() later without a danger to skip demuxer messages?

   demuxer_clients_.AddWithID(client, demuxer_client_id);
 }
 
 void BrowserDemuxerAndroid::RemoveDemuxerClient(int demuxer_client_id) {
   DVLOG(1) << __FUNCTION__ << " peer_pid=" << peer_pid()
            << " demuxer_client_id=" << demuxer_client_id;
+
+  base::AutoLock lock(lock_);
   demuxer_clients_.Remove(demuxer_client_id);
 }
 
+media::DemuxerAndroidClient*
+BrowserDemuxerAndroid::Lookup(int demuxer_client_id) {
+  base::AutoLock lock(lock_);
+  return demuxer_clients_.Lookup(demuxer_client_id);
+}
+
 void BrowserDemuxerAndroid::OnDemuxerReady(
     int demuxer_client_id,
     const media::DemuxerConfigs& configs) {
-  media::DemuxerAndroidClient* client =
-      demuxer_clients_.Lookup(demuxer_client_id);
+  media::DemuxerAndroidClient* client = Lookup(demuxer_client_id);
   if (client)
     client->OnDemuxerConfigsAvailable(configs);
 }
 
 void BrowserDemuxerAndroid::OnReadFromDemuxerAck(
     int demuxer_client_id,
     const media::DemuxerData& data) {
-  media::DemuxerAndroidClient* client =
-      demuxer_clients_.Lookup(demuxer_client_id);
+  media::DemuxerAndroidClient* client = Lookup(demuxer_client_id);
   if (client)
     client->OnDemuxerDataAvailable(data);
 }
 
 void BrowserDemuxerAndroid::OnDemuxerSeekDone(
     int demuxer_client_id,
     const base::TimeDelta& actual_browser_seek_time) {
-  media::DemuxerAndroidClient* client =
-      demuxer_clients_.Lookup(demuxer_client_id);
+  media::DemuxerAndroidClient* client = Lookup(demuxer_client_id);
   if (client)
     client->OnDemuxerSeekDone(actual_browser_seek_time);
 }
 
 void BrowserDemuxerAndroid::OnDurationChanged(int demuxer_client_id,
                                               const base::TimeDelta& duration) {
-  media::DemuxerAndroidClient* client =
-      demuxer_clients_.Lookup(demuxer_client_id);
+  media::DemuxerAndroidClient* client = Lookup(demuxer_client_id);
   if (client)
     client->OnDemuxerDurationChanged(duration);
 }
 
 }  // namespace content