src/content/browser/media/android/browser_media_player_manager.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_MEDIA_ANDROID_BROWSER_MEDIA_PLAYER_MANAGER_H_
   6 #define CONTENT_BROWSER_MEDIA_ANDROID_BROWSER_MEDIA_PLAYER_MANAGER_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/callback.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/scoped_vector.h"
  17 #include "base/time/time.h"
  18 #include "content/browser/android/content_video_view.h"
  19 #include "content/common/media/cdm_messages_enums.h"
  20 #include "content/common/media/media_player_messages_enums_android.h"
  21 #include "content/public/browser/web_contents_observer.h"
  22 #include "media/base/android/media_player_android.h"
  23 #include "media/base/android/media_player_manager.h"
  24 #include "ui/gfx/rect_f.h"
  25 #include "url/gurl.h"
  26
  27 namespace media {
  28 class DemuxerAndroid;
  29 class MediaDrmBridge;
  30 }
  31
  32 namespace content {
  33 class BrowserDemuxerAndroid;
  34 class ContentViewCoreImpl;
  35 class ExternalVideoSurfaceContainer;
  36 class WebContents;
  37
  38 // This class manages all the MediaPlayerAndroid objects. It receives
  39 // control operations from the the render process, and forwards
  40 // them to corresponding MediaPlayerAndroid object. Callbacks from
  41 // MediaPlayerAndroid objects are converted to IPCs and then sent to the
  42 // render process.
  43 class CONTENT_EXPORT BrowserMediaPlayerManager
  44     : public WebContentsObserver,
  45       public media::MediaPlayerManager {
  46  public:
  47   // Permits embedders to provide an extended version of the class.
  48   typedef BrowserMediaPlayerManager* (*Factory)(RenderViewHost*);
  49   static void RegisterFactory(Factory factory);
  50
  51   // Returns a new instance using the registered factory if available.
  52   static BrowserMediaPlayerManager* Create(RenderViewHost* rvh);
  53
  54   ContentViewCoreImpl* GetContentViewCore() const;
  55
  56   virtual ~BrowserMediaPlayerManager();
  57
  58   // WebContentsObserver overrides.
  59   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  60
  61   // Fullscreen video playback controls.
  62   virtual void FullscreenPlayerPlay();
  63   virtual void FullscreenPlayerPause();
  64   virtual void FullscreenPlayerSeek(int msec);
  65   virtual void ExitFullscreen(bool release_media_player);
  66   virtual void SetVideoSurface(gfx::ScopedJavaSurface surface);
  67
  68   // Called when browser player wants the renderer media element to seek.
  69   // Any actual seek started by renderer will be handled by browser in OnSeek().
  70   void OnSeekRequest(int player_id, const base::TimeDelta& time_to_seek);
  71
  72   // media::MediaPlayerManager overrides.
  73   virtual void OnTimeUpdate(
  74       int player_id, base::TimeDelta current_time) OVERRIDE;
  75   virtual void OnMediaMetadataChanged(
  76       int player_id,
  77       base::TimeDelta duration,
  78       int width,
  79       int height,
  80       bool success) OVERRIDE;
  81   virtual void OnPlaybackComplete(int player_id) OVERRIDE;
  82   virtual void OnMediaInterrupted(int player_id) OVERRIDE;
  83   virtual void OnBufferingUpdate(int player_id, int percentage) OVERRIDE;
  84   virtual void OnSeekComplete(
  85       int player_id,
  86       const base::TimeDelta& current_time) OVERRIDE;
  87   virtual void OnError(int player_id, int error) OVERRIDE;
  88   virtual void OnVideoSizeChanged(
  89       int player_id, int width, int height) OVERRIDE;
  90   virtual media::MediaResourceGetter* GetMediaResourceGetter() OVERRIDE;
  91   virtual media::MediaPlayerAndroid* GetFullscreenPlayer() OVERRIDE;
  92   virtual media::MediaPlayerAndroid* GetPlayer(int player_id) OVERRIDE;
  93   virtual media::MediaDrmBridge* GetDrmBridge(int cdm_id) OVERRIDE;
  94   virtual void DestroyAllMediaPlayers() OVERRIDE;
  95   virtual void RequestFullScreen(int player_id) OVERRIDE;
  96   virtual void OnSessionCreated(int cdm_id,
  97                                 uint32 session_id,
  98                                 const std::string& web_session_id) OVERRIDE;
  99   virtual void OnSessionMessage(int cdm_id,
 100                                 uint32 session_id,
 101                                 const std::vector<uint8>& message,
 102                                 const GURL& destination_url) OVERRIDE;
 103   virtual void OnSessionReady(int cdm_id, uint32 session_id) OVERRIDE;
 104   virtual void OnSessionClosed(int cdm_id, uint32 session_id) OVERRIDE;
 105   virtual void OnSessionError(int cdm_id,
 106                               uint32 session_id,
 107                               media::MediaKeys::KeyError error_code,
 108                               uint32 system_code) OVERRIDE;
 109
 110 #if defined(VIDEO_HOLE)
 111   void AttachExternalVideoSurface(int player_id, jobject surface);
 112   void DetachExternalVideoSurface(int player_id);
 113   void OnFrameInfoUpdated();
 114 #endif  // defined(VIDEO_HOLE)
 115
 116  protected:
 117   // Clients must use Create() or subclass constructor.
 118   explicit BrowserMediaPlayerManager(RenderViewHost* render_view_host);
 119
 120   // Message handlers.
 121   virtual void OnEnterFullscreen(int player_id);
 122   virtual void OnExitFullscreen(int player_id);
 123   virtual void OnInitialize(
 124       MediaPlayerHostMsg_Initialize_Type type,
 125       int player_id,
 126       const GURL& url,
 127       const GURL& first_party_for_cookies,
 128       int demuxer_client_id);
 129   virtual void OnStart(int player_id);
 130   virtual void OnSeek(int player_id, const base::TimeDelta& time);
 131   virtual void OnPause(int player_id, bool is_media_related_action);
 132   virtual void OnSetVolume(int player_id, double volume);
 133   virtual void OnSetPoster(int player_id, const GURL& poster);
 134   virtual void OnReleaseResources(int player_id);
 135   virtual void OnDestroyPlayer(int player_id);
 136   virtual void ReleaseFullscreenPlayer(media::MediaPlayerAndroid* player);
 137   void OnInitializeCdm(int cdm_id,
 138                        const std::string& key_system,
 139                        const GURL& frame_url);
 140   void OnCreateSession(int cdm_id,
 141                        uint32 session_id,
 142                        CdmHostMsg_CreateSession_ContentType content_type,
 143                        const std::vector<uint8>& init_data);
 144   void OnUpdateSession(int cdm_id,
 145                        uint32 session_id,
 146                        const std::vector<uint8>& response);
 147   void OnReleaseSession(int cdm_id, uint32 session_id);
 148   void OnSetCdm(int player_id, int cdm_id);
 149   void OnDestroyCdm(int cdm_id);
 150
 151   // Cancels all pending session creations associated with |cdm_id|.
 152   void CancelAllPendingSessionCreations(int cdm_id);
 153
 154   // Adds a given player to the list.
 155   void AddPlayer(media::MediaPlayerAndroid* player);
 156
 157   // Removes the player with the specified id.
 158   void RemovePlayer(int player_id);
 159
 160   // Replaces a player with the specified id with a given MediaPlayerAndroid
 161   // object. This will also return the original MediaPlayerAndroid object that
 162   // was replaced.
 163   scoped_ptr<media::MediaPlayerAndroid> SwapPlayer(
 164       int player_id,
 165       media::MediaPlayerAndroid* player);
 166
 167   // Adds a new MediaDrmBridge for the given |key_system|, |cdm_id|, and
 168   // |frame_url|.
 169   void AddDrmBridge(int cdm_id,
 170                     const std::string& key_system,
 171                     const GURL& frame_url);
 172
 173   // Removes the DRM bridge with the specified id.
 174   void RemoveDrmBridge(int cdm_id);
 175
 176  private:
 177   // If |permitted| is false, it does nothing but send
 178   // |CdmMsg_SessionError| IPC message.
 179   // The primary use case is infobar permission callback, i.e., when infobar
 180   // can decide user's intention either from interacting with the actual info
 181   // bar or from the saved preference.
 182   void CreateSessionIfPermitted(int cdm_id,
 183                                 uint32 session_id,
 184                                 const std::string& content_type,
 185                                 const std::vector<uint8>& init_data,
 186                                 bool permitted);
 187
 188   // Constructs a MediaPlayerAndroid object.
 189   media::MediaPlayerAndroid* CreateMediaPlayer(
 190       MediaPlayerHostMsg_Initialize_Type type,
 191       int player_id,
 192       const GURL& url,
 193       const GURL& first_party_for_cookies,
 194       int demuxer_client_id,
 195       bool hide_url_log,
 196       media::MediaPlayerManager* manager,
 197       BrowserDemuxerAndroid* demuxer);
 198
 199   // MediaPlayerAndroid must call this before it is going to decode
 200   // media streams. This helps the manager object maintain an array
 201   // of active MediaPlayerAndroid objects and release the resources
 202   // when needed. Currently we only count video resources as they are
 203   // constrained by hardware and memory limits.
 204   virtual void OnMediaResourcesRequested(int player_id);
 205
 206   // Similar to the above call, MediaPlayerAndroid must call this method when
 207   // releasing all the decoding resources.
 208   virtual void OnMediaResourcesReleased(int player_id);
 209
 210 #if defined(VIDEO_HOLE)
 211   void OnNotifyExternalSurface(
 212       int player_id, bool is_request, const gfx::RectF& rect);
 213   void OnRequestExternalSurface(int player_id, const gfx::RectF& rect);
 214 #endif  // defined(VIDEO_HOLE)
 215
 216   // An array of managed players.
 217   ScopedVector<media::MediaPlayerAndroid> players_;
 218
 219   // An array of managed media DRM bridges.
 220   ScopedVector<media::MediaDrmBridge> drm_bridges_;
 221
 222   // Map from DrmBridge cdm_id to MediaPlayerAndroid player_id to indicate that
 223   // the DrmBridge is set on the MediaPlayerAndroid object.
 224   typedef std::map<int, int> DrmBridgePlayerMap;
 225   DrmBridgePlayerMap drm_bridge_player_map_;
 226
 227   // The fullscreen video view object or NULL if video is not played in
 228   // fullscreen.
 229   scoped_ptr<ContentVideoView> video_view_;
 230
 231 #if defined(VIDEO_HOLE)
 232   scoped_ptr<ExternalVideoSurfaceContainer> external_video_surface_container_;
 233 #endif
 234
 235   // Player ID of the fullscreen media player.
 236   int fullscreen_player_id_;
 237
 238   // Whether the fullscreen player has been Release()-d.
 239   bool fullscreen_player_is_released_;
 240
 241   WebContents* web_contents_;
 242
 243   // Object for retrieving resources media players.
 244   scoped_ptr<media::MediaResourceGetter> media_resource_getter_;
 245
 246   // NOTE: Weak pointers must be invalidated before all other member variables.
 247   base::WeakPtrFactory<BrowserMediaPlayerManager> weak_ptr_factory_;
 248
 249   DISALLOW_COPY_AND_ASSIGN(BrowserMediaPlayerManager);
 250 };
 251
 252 }  // namespace content
 253
 254 #endif  // CONTENT_BROWSER_MEDIA_ANDROID_BROWSER_MEDIA_PLAYER_MANAGER_H_