1 files changed, 32 insertions, 61 deletions

diff --git a/chromium/content/renderer/media/android/renderer_media_player_manager.h b/chromium/content/renderer/media/android/renderer_media_player_manager.h
index 188d5425132..4bcb2888378 100644
--- a/chromium/content/renderer/media/android/renderer_media_player_manager.h
+++ b/chromium/content/renderer/media/android/renderer_media_player_manager.h
@@ -7,20 +7,14 @@
 
 #include <map>
 #include <string>
-#include <vector>
 
 #include "base/basictypes.h"
 #include "base/time/time.h"
 #include "content/common/media/media_player_messages_enums_android.h"
-#include "content/public/renderer/render_view_observer.h"
+#include "content/public/renderer/render_frame_observer.h"
 #include "media/base/android/media_player_android.h"
-#include "media/base/media_keys.h"
 #include "url/gurl.h"
 
-#if defined(GOOGLE_TV)
-#include "ui/gfx/rect_f.h"
-#endif
-
 namespace blink {
 class WebFrame;
 }
@@ -29,20 +23,20 @@ namespace gfx {
 class RectF;
 }
 
-namespace content {
+struct MediaPlayerHostMsg_Initialize_Params;
 
-class ProxyMediaKeys;
+namespace content {
 class WebMediaPlayerAndroid;
 
 // Class for managing all the WebMediaPlayerAndroid objects in the same
-// RenderView.
-class RendererMediaPlayerManager : public RenderViewObserver {
+// RenderFrame.
+class RendererMediaPlayerManager : public RenderFrameObserver {
  public:
-  // Constructs a RendererMediaPlayerManager object for the |render_view|.
-  RendererMediaPlayerManager(RenderView* render_view);
+  // Constructs a RendererMediaPlayerManager object for the |render_frame|.
+  explicit RendererMediaPlayerManager(RenderFrame* render_frame);
   virtual ~RendererMediaPlayerManager();
 
-  // RenderViewObserver overrides.
+  // RenderFrameObserver overrides.
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // Initializes a MediaPlayerAndroid object in browser process.
@@ -50,7 +44,8 @@ class RendererMediaPlayerManager : public RenderViewObserver {
                   int player_id,
                   const GURL& url,
                   const GURL& first_party_for_cookies,
-                  int demuxer_client_id);
+                  int demuxer_client_id,
+                  const GURL& frame_url);
 
   // Starts the player.
   void Start(int player_id);
@@ -68,6 +63,9 @@ class RendererMediaPlayerManager : public RenderViewObserver {
   // Sets the player volume.
   void SetVolume(int player_id, double volume);
 
+  // Sets the poster image.
+  void SetPoster(int player_id, const GURL& poster);
+
   // Releases resources for the player.
   void ReleaseResources(int player_id);
 
@@ -80,42 +78,27 @@ class RendererMediaPlayerManager : public RenderViewObserver {
   // Requests the player to exit fullscreen.
   void ExitFullscreen(int player_id);
 
+  // Requests the player with |player_id| to use the CDM with |cdm_id|.
+  // Does nothing if |cdm_id| is kInvalidCdmId.
+  // TODO(xhwang): Update this when we implement setCdm(0).
+  void SetCdm(int player_id, int cdm_id);
+
 #if defined(VIDEO_HOLE)
   // Requests an external surface for out-of-band compositing.
   void RequestExternalSurface(int player_id, const gfx::RectF& geometry);
 
-  // RenderViewObserver overrides.
+  // RenderFrameObserver overrides.
   virtual void DidCommitCompositorFrame() OVERRIDE;
-#endif  // defined(VIDEO_HOLE)
 
-  // Encrypted media related methods.
-  void InitializeCDM(int media_keys_id,
-                     ProxyMediaKeys* media_keys,
-                     const std::vector<uint8>& uuid,
-                     const GURL& frame_url);
-  void CreateSession(int media_keys_id,
-                     uint32 session_id,
-                     const std::string& type,
-                     const std::vector<uint8>& init_data);
-  void UpdateSession(int media_keys_id,
-                     uint32 session_id,
-                     const std::vector<uint8>& response);
-  void ReleaseSession(int media_keys_id, uint32 session_id);
+  // Returns true if a media player should use video-overlay for the embedded
+  // encrypted video.
+  bool ShouldUseVideoOverlayForEmbeddedEncryptedVideo();
+#endif  // defined(VIDEO_HOLE)
 
   // Registers and unregisters a WebMediaPlayerAndroid object.
   int RegisterMediaPlayer(WebMediaPlayerAndroid* player);
   void UnregisterMediaPlayer(int player_id);
 
-  // Registers a ProxyMediaKeys object. There must be a WebMediaPlayerAndroid
-  // object already registered for this id, and it is unregistered when the
-  // player is unregistered. For now |media_keys_id| is the same as player_id
-  // used in other methods.
-  void RegisterMediaKeys(int media_keys_id, ProxyMediaKeys* media_keys);
-
-  // Releases the media resources managed by this object when a video
-  // is playing.
-  void ReleaseVideoResources();
-
   // Checks whether a player can enter fullscreen.
   bool CanEnterFullscreen(blink::WebFrame* frame);
 
@@ -132,9 +115,6 @@ class RendererMediaPlayerManager : public RenderViewObserver {
   // Gets the pointer to WebMediaPlayerAndroid given the |player_id|.
   WebMediaPlayerAndroid* GetMediaPlayer(int player_id);
 
-  // Gets the pointer to ProxyMediaKeys given the |media_keys_id|.
-  ProxyMediaKeys* GetMediaKeys(int media_keys_id);
-
 #if defined(VIDEO_HOLE)
   // Gets the list of media players with video geometry changes.
   void RetrieveGeometryChanges(std::map<int, gfx::RectF>* changes);
@@ -155,35 +135,26 @@ class RendererMediaPlayerManager : public RenderViewObserver {
   void OnVideoSizeChanged(int player_id, int width, int height);
   void OnTimeUpdate(int player_id, base::TimeDelta current_time);
   void OnMediaPlayerReleased(int player_id);
-  void OnConnectedToRemoteDevice(int player_id);
+  void OnConnectedToRemoteDevice(int player_id,
+      const std::string& remote_playback_message);
   void OnDisconnectedFromRemoteDevice(int player_id);
   void OnDidExitFullscreen(int player_id);
   void OnDidEnterFullscreen(int player_id);
   void OnPlayerPlay(int player_id);
   void OnPlayerPause(int player_id);
   void OnRequestFullscreen(int player_id);
-  void OnSessionCreated(int media_keys_id,
-                        uint32 session_id,
-                        const std::string& web_session_id);
-  void OnSessionMessage(int media_keys_id,
-                        uint32 session_id,
-                        const std::vector<uint8>& message,
-                        const std::string& destination_url);
-  void OnSessionReady(int media_keys_id, uint32 session_id);
-  void OnSessionClosed(int media_keys_id, uint32 session_id);
-  void OnSessionError(int media_keys_id,
-                      uint32 session_id,
-                      media::MediaKeys::KeyError error_code,
-                      int system_code);
+  void OnPauseVideo();
+
+  // Release all video player resources.
+  // If something is in progress the resource will not be freed. It will
+  // only be freed once the tab is destroyed or if the user navigates away
+  // via WebMediaPlayerAndroid::Destroy.
+  void ReleaseVideoResources();
 
   // Info for all available WebMediaPlayerAndroid on a page; kept so that
   // we can enumerate them to send updates about tab focus and visibility.
   std::map<int, WebMediaPlayerAndroid*> media_players_;
 
-  // Info for all available ProxyMediaKeys. There must be at most one
-  // ProxyMediaKeys for each available WebMediaPlayerAndroid.
-  std::map<int, ProxyMediaKeys*> media_keys_;
-
   int next_media_player_id_;
 
   // WebFrame of the fullscreen video.