Upstream implementation for embedded video for WebMediaPlayerAndroid

webkit/media/android/webmediaplayer_manager_android.h

Index: webkit/media/android/webmediaplayer_manager_android.h
diff --git a/webkit/media/android/webmediaplayer_manager_android.h b/webkit/media/android/webmediaplayer_manager_android.h
new file mode 100644
index 0000000000000000000000000000000000000000..7aa3a4187e2fc49ca44f9a958ef44a78aac7d006
--- /dev/null
+++ b/webkit/media/android/webmediaplayer_manager_android.h
@@ -0,0 +1,58 @@
+// 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.
+
+#ifndef WEBKIT_MEDIA_ANDROID_WEBMEDIAPLAYER_MANAGER_ANDROID_H_
+#define WEBKIT_MEDIA_ANDROID_WEBMEDIAPLAYER_MANAGER_ANDROID_H_
+
+#include <jni.h>
+#include <map>
+
+#include "base/basictypes.h"
+
+namespace webkit_media {
+
+class WebMediaPlayerAndroid;
+
+// Class for managing all the WebMediaPlayerAndroid objects in a renderer
+// process.
+class WebMediaPlayerManagerAndroid {

[scherkus (not reviewing), 2012/05/23 22:45:46]

ISTM this class is mostly here for two purposes:
  1) Notifying content when WMPA is created/deleted
  2) Forward messages from content to WMPA

Since WMPA implements WeakPtr<T>, could you replace this class with:

std::vector<WeakPtr<WebMediaPlayerAndroid> > media_players_;

Inside createMediaPlayer():
WMPA* media_player = new WMPA(...);
media_players_.push_back(media_player);


Then to dispatch messages you can do:

for (...) {
  if (media_players_[i]) {
    media_players_[i]->Foo();
  }
}

[qinmin, 2012/05/24 20:30:28]

I think we need this class for as it has more functions that haven't been
upstreamed. We need it for resource management purpose so that the number of
active players won't exceed a certain threshold. When a mediaplayer wants to
start decoding, it will send a request to this class. The class will free up all
the currently paused mediaplayers based on that request. And keeping track of
all the active players in the same renderer process.


On 2012/05/23 22:45:46, scherkus wrote:

[scherkus (not reviewing), 2012/05/24 21:36:32]

Hrmm... I think we're going to have to sort out some layering stuff. In general
src/webkit/ code isn't multiprocess (src/content/ code is!) so the sign that we
want a routing_id here is a hint that we might have to restructure some things

[qinmin, 2012/05/25 01:04:20]

we still have only 1 render process and 1 browser process in this case. But the
passing the surface from the browser process to the renderer process is through
Java Binder, not the chromium IPCs. This is probably the only object that we are
not able to pass through IPC.

On 2012/05/24 21:36:32, scherkus wrote:

+ public:
+  WebMediaPlayerManagerAndroid(int32 routing_id);
+  virtual ~WebMediaPlayerManagerAndroid();
+
+  // Register and unregister a WebMediaPlayerAndroid object.
+  virtual int RegisterMediaPlayer(WebMediaPlayerAndroid* player);

[scherkus (not reviewing), 2012/05/23 22:45:46]

do we need to return an int ID or can we use the player pointer itself?

for example, who who calls SetVideoSurface()? would they have a pointer?

[qinmin, 2012/05/24 20:30:28]

So the whole process of getting a video surface works like this:
We pass the player_id to the browser process. browser proess will create an
video surface in the java code, and passing it back to the java sandboxed
process. The sandboxed process will then find the correct mediaplayer using this
player_id and routing id.

So if we pass an address to the java process, we are actually treating it as an
integer due to conversion. The address pretty much becomes an ID in that sense
and we have to deal with 64bit/32bit address space later on.

On 2012/05/23 22:45:46, scherkus wrote:

+  virtual void UnRegisterMediaPlayer(int player_id);
+
+  // Release all the media resources on the renderer process.
+  virtual void ReleaseMediaResources();
+
+  // Pass the video surface to a particular WebMediaPlayerAndroid object given
+  // by the player_id.
+  // TODO(qinmin): Upstream the code for passing Java surface object to the
+  // renderer thread
+  virtual void SetVideoSurface(jobject j_surface, int player_id);
+
+ private:
+  // Information needed to manage WebMediaPlayerAndroid.
+  // TODO(qinmin): more informations will be added here for resource management.
+  struct MediaPlayerInfo {
+    webkit_media::WebMediaPlayerAndroid* player;
+  };
+
+  // Info for all available WebMediaPlayerAndroid on a page; kept so that
+  // we can enumerate them to send updates about tab focus and visibily.
+  std::map<int32, MediaPlayerInfo> media_players_;
+
+  // ID used to create the next media player for passing the Surface.
+  int32 next_media_player_id_;
+
+  int32 routing_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerManagerAndroid);
+};
+
+}  // namespace webkit_media
+
+#endif  // WEBKIT_MEDIA_ANDROID_WEBMEDIAPLAYER_MANAGER_ANDROID_H_