Implement out-of-band video compositing on Android: Step 1

content/browser/android/media_player_manager_android.cc

 // Copyright (c) 2012 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/media_player_manager_android.h"
 
 #include "base/bind.h"
 #include "content/browser/android/cookie_getter_impl.h"
 #include "content/common/media/media_player_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 
 using media::MediaPlayerBridge;
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
 static const int kMediaPlayerThreshold = 1;
 
 namespace content {
 
 MediaPlayerManagerAndroid::MediaPlayerManagerAndroid(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host),
       ALLOW_THIS_IN_INITIALIZER_LIST(video_view_(this)),
-      fullscreen_player_id_(-1) {
+      fullscreen_player_id_(-1),
+      external_video_surface_user_id_(-1) {
 }
 
 MediaPlayerManagerAndroid::~MediaPlayerManagerAndroid() {}
 
 bool MediaPlayerManagerAndroid::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaPlayerManagerAndroid, msg)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_EnterFullscreen, OnEnterFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_ExitFullscreen, OnExitFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerInitialize, OnInitialize)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerStart, OnStart)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerSeek, OnSeek)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerPause, OnPause)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerRelease,
                         OnReleaseResources)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyMediaPlayer, OnDestroyPlayer)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyAllMediaPlayers,
                         DestroyAllMediaPlayers)
+    IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_RequestExternalSurface,
+                        OnRequestExternalSurface)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MediaPlayerManagerAndroid::FullscreenPlayerPlay() {
   MediaPlayerBridge* player = GetFullscreenPlayer();
   if (player) {
     player->Start();
     Send(new MediaPlayerMsg_DidMediaPlayerPlay(
@@ skipping 123 matching lines @@
 void MediaPlayerManagerAndroid::OnDestroyPlayer(int player_id) {
   for (ScopedVector<MediaPlayerBridge>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       players_.erase(it);
       break;
     }
   }
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
+  if (external_video_surface_user_id_ == player_id)
+    external_video_surface_user_id_ = -1;
 }
 
 void MediaPlayerManagerAndroid::DestroyAllMediaPlayers() {
   players_.clear();
   if (fullscreen_player_id_ != -1) {
     video_view_.DestroyContentVideoView();
     fullscreen_player_id_ = -1;
   }
+  external_video_surface_user_id_ = -1;
+}
+
+void MediaPlayerManagerAndroid::OnRequestExternalSurface(int player_id) {
+  if (external_video_surface_user_id_ != -1) {
+    MediaPlayerBridge* player = GetPlayer(player_id);
+    player->SetVideoSurface(NULL);
+  }
+  external_video_surface_user_id_ = player_id;
 }
 
 MediaPlayerBridge* MediaPlayerManagerAndroid::GetPlayer(int player_id) {
   for (ScopedVector<MediaPlayerBridge>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id)
       return *it;
   }
   return NULL;
 }
 
 MediaPlayerBridge* MediaPlayerManagerAndroid::GetFullscreenPlayer() {
   return GetPlayer(fullscreen_player_id_);
 }
 
+void MediaPlayerManagerAndroid::SetExternalVideoSurface(jobject surface) {
+  MediaPlayerBridge* player = GetPlayer(external_video_surface_user_id_);
+  if (player)
+    player->SetVideoSurface(surface);
+}
+
 void MediaPlayerManagerAndroid::OnPrepared(int player_id,
                                            base::TimeDelta duration) {
   Send(new MediaPlayerMsg_MediaPrepared(routing_id(), player_id, duration));
   if (fullscreen_player_id_ != -1)
     video_view_.UpdateMediaMetadata();
 }
 
 void MediaPlayerManagerAndroid::OnPlaybackComplete(int player_id) {
   Send(new MediaPlayerMsg_MediaPlaybackCompleted(routing_id(), player_id));
   if (fullscreen_player_id_ != -1)
@@ skipping 71 matching lines @@
     }
   }
 }
 
 void MediaPlayerManagerAndroid::ReleaseMediaResources(
     MediaPlayerBridge* player) {
   // Nothing needs to be done.
 }
 
 }  // namespace content