Split media::DemuxerAndroid implementation of BrowserMediaPlayerManager to BrowserDemuxerAndroid.

content/browser/android/browser_media_player_manager.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/android/browser_media_player_manager.h"
 
 #include "base/command_line.h"
+#include "content/browser/android/browser_demuxer_android.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/media_resource_getter_impl.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "media/base/android/media_drm_bridge.h"
@@ skipping 54 matching lines @@
   }
 
   NOTREACHED();
   return NULL;
 }
 #endif
 
 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host),
+      browser_demuxer_(new BrowserDemuxerAndroid(render_view_host)),
       fullscreen_player_id_(-1),
       web_contents_(WebContents::FromRenderViewHost(render_view_host)) {
 }
 
 BrowserMediaPlayerManager::~BrowserMediaPlayerManager() {}
 
 bool BrowserMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserMediaPlayerManager, msg)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_EnterFullscreen, OnEnterFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_ExitFullscreen, OnExitFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_Initialize, OnInitialize)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_Start, OnStart)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_Seek, OnSeek)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_Pause, OnPause)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_SetVolume, OnSetVolume)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_Release, OnReleaseResources)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyMediaPlayer, OnDestroyPlayer)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyAllMediaPlayers,
                         DestroyAllMediaPlayers)
-    IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DemuxerReady, OnDemuxerReady)
-    IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_ReadFromDemuxerAck,
-                        OnReadFromDemuxerAck)
-    IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DurationChanged,
-                        OnDurationChanged)
-    IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaSeekRequestAck,
-                        OnMediaSeekRequestAck)
     IPC_MESSAGE_HANDLER(MediaKeysHostMsg_InitializeCDM,
                         OnInitializeCDM)
     IPC_MESSAGE_HANDLER(MediaKeysHostMsg_GenerateKeyRequest,
                         OnGenerateKeyRequest)
     IPC_MESSAGE_HANDLER(MediaKeysHostMsg_AddKey, OnAddKey)
     IPC_MESSAGE_HANDLER(MediaKeysHostMsg_CancelKeyRequest,
                         OnCancelKeyRequest)
 #if defined(GOOGLE_TV)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_NotifyExternalSurface,
                         OnNotifyExternalSurface)
@@ skipping 99 matching lines @@
 }
 
 void BrowserMediaPlayerManager::OnVideoSizeChanged(
     int player_id, int width, int height) {
   Send(new MediaPlayerMsg_MediaVideoSizeChanged(routing_id(), player_id,
       width, height));
   if (fullscreen_player_id_ != -1)
     video_view_->OnVideoSizeChanged(width, height);
 }
 
-void BrowserMediaPlayerManager::AddDemuxerClient(
-    int demuxer_client_id,
-    media::DemuxerAndroidClient* client) {
-  demuxer_clients_.AddWithID(client, demuxer_client_id);
-}
-
-void BrowserMediaPlayerManager::RemoveDemuxerClient(int demuxer_client_id) {
-  demuxer_clients_.Remove(demuxer_client_id);
-}
-
-void BrowserMediaPlayerManager::RequestDemuxerData(
-    int demuxer_client_id, media::DemuxerStream::Type type) {
-  DCHECK(demuxer_clients_.Lookup(demuxer_client_id)) << demuxer_client_id;
-  Send(new MediaPlayerMsg_ReadFromDemuxer(
-      routing_id(), demuxer_client_id, type));
-}
-
 void BrowserMediaPlayerManager::RequestMediaResources(int player_id) {
   int num_active_player = 0;
   ScopedVector<MediaPlayerAndroid>::iterator it;
   for (it = players_.begin(); it != players_.end(); ++it) {
     if (!(*it)->IsPlayerReady())
       continue;
 
     // The player is already active, ignore it.
     if ((*it)->player_id() == player_id)
       return;
@@ skipping 56 matching lines @@
 }
 
 void BrowserMediaPlayerManager::DestroyAllMediaPlayers() {
   players_.clear();
   if (fullscreen_player_id_ != -1) {
     video_view_.reset();
     fullscreen_player_id_ = -1;
   }
 }
 
-void BrowserMediaPlayerManager::RequestDemuxerSeek(int demuxer_client_id,
-                                                   base::TimeDelta time_to_seek,
-                                                   unsigned seek_request_id) {
-  DCHECK(demuxer_clients_.Lookup(demuxer_client_id)) << demuxer_client_id;
-  Send(new MediaPlayerMsg_MediaSeekRequest(
-      routing_id(), demuxer_client_id, time_to_seek, seek_request_id));
-}
-
-void BrowserMediaPlayerManager::RequestDemuxerConfigs(int demuxer_client_id) {
-  DCHECK(demuxer_clients_.Lookup(demuxer_client_id)) << demuxer_client_id;
-  Send(new MediaPlayerMsg_MediaConfigRequest(routing_id(), demuxer_client_id));
-}
-
 void BrowserMediaPlayerManager::OnProtectedSurfaceRequested(int player_id) {
   if (fullscreen_player_id_ == player_id)
     return;
   if (fullscreen_player_id_ != -1) {
     // TODO(qinmin): Determine the correct error code we should report to WMPA.
     OnError(player_id, MediaPlayerAndroid::MEDIA_ERROR_DECODE);
     return;
   }
   OnEnterFullscreen(player_id);
 }
@@ skipping 80 matching lines @@
 void BrowserMediaPlayerManager::OnInitialize(
     int player_id,
     const GURL& url,
     MediaPlayerHostMsg_Initialize_Type type,
     const GURL& first_party_for_cookies) {
   RemovePlayer(player_id);
 
   RenderProcessHost* host = render_view_host()->GetProcess();
   AddPlayer(CreateMediaPlayer(
       player_id, url, type, first_party_for_cookies,
-      host->GetBrowserContext()->IsOffTheRecord(), this, this));
+      host->GetBrowserContext()->IsOffTheRecord(), this, browser_demuxer_));
 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->Start();
 }
 
 void BrowserMediaPlayerManager::OnSeek(int player_id, base::TimeDelta time) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
@@ skipping 28 matching lines @@
     view->NotifyExternalSurface(player_id, false, gfx::RectF());
 #endif
 }
 
 void BrowserMediaPlayerManager::OnDestroyPlayer(int player_id) {
   RemovePlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
-void BrowserMediaPlayerManager::OnDemuxerReady(
-    int player_id,
-    const media::DemuxerConfigs& configs) {
-  // TODO(scherkus): Rename |player_id| to |demuxer_client_id| after splitting
-  // demuxer IPC messages into their own group.
-  media::DemuxerAndroidClient* client = demuxer_clients_.Lookup(player_id);
-  if (client)
-    client->OnDemuxerConfigsAvailable(configs);
-}
-
-void BrowserMediaPlayerManager::OnReadFromDemuxerAck(
-    int player_id,
-    const media::DemuxerData& data) {
-  // TODO(scherkus): Rename |player_id| to |demuxer_client_id| after splitting
-  // demuxer IPC messages into their own group.
-  media::DemuxerAndroidClient* client = demuxer_clients_.Lookup(player_id);
-  if (client)
-    client->OnDemuxerDataAvailable(data);
-}
-
-void BrowserMediaPlayerManager::OnMediaSeekRequestAck(
-    int player_id, unsigned seek_request_id) {
-  // TODO(scherkus): Rename |player_id| to |demuxer_client_id| after splitting
-  // demuxer IPC messages into their own group.
-  media::DemuxerAndroidClient* client = demuxer_clients_.Lookup(player_id);
-  if (client)
-    client->OnDemuxerSeeked(seek_request_id);
-}
-
 void BrowserMediaPlayerManager::OnInitializeCDM(
     int media_keys_id,
     const std::vector<uint8>& uuid) {
   AddDrmBridge(media_keys_id, uuid);
   // In EME v0.1b MediaKeys lives in the media element. So the |media_keys_id|
   // is the same as the |player_id|.
   OnSetMediaKeys(media_keys_id, media_keys_id);
 }
 
 void BrowserMediaPlayerManager::OnGenerateKeyRequest(
@@ skipping 24 matching lines @@
 }
 
 void BrowserMediaPlayerManager::OnCancelKeyRequest(
     int media_keys_id,
     const std::string& session_id) {
   MediaDrmBridge* drm_bridge = GetDrmBridge(media_keys_id);
   if (drm_bridge)
     drm_bridge->CancelKeyRequest(session_id);
 }
 
-void BrowserMediaPlayerManager::OnDurationChanged(
-    int player_id, const base::TimeDelta& duration) {
-  // TODO(scherkus): Rename |player_id| to |demuxer_client_id| after splitting
-  // demuxer IPC messages into their own group.
-  media::DemuxerAndroidClient* client = demuxer_clients_.Lookup(player_id);
-  if (client)
-    client->OnDemuxerDurationChanged(duration);
-}
-
 void BrowserMediaPlayerManager::AddPlayer(MediaPlayerAndroid* player) {
   DCHECK(!GetPlayer(player->player_id()));
   players_.push_back(player);
 }
 
 void BrowserMediaPlayerManager::RemovePlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       players_.erase(it);
@@ skipping 40 matching lines @@
   if (!player || !drm_bridge) {
     DVLOG(1) << "OnSetMediaKeys(): Player and MediaKeys must be present.";
     return;
   }
   // TODO(qinmin): add the logic to decide whether we should create the
   // fullscreen surface for EME lv1.
   player->SetDrmBridge(drm_bridge);
 }
 
 }  // namespace content