Support CAST+WMPI on android

media/blink/webmediaplayer_impl.h

 // 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.
 
 #ifndef MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 #define MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 18 matching lines @@
 #include "media/blink/video_frame_compositor.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProvider.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "url/gurl.h"
 
+#if defined(OS_ANDROID)
+// Use WIMPI_CAST instead of OS_ANDROID to clearly mark the cast implementation
+// so that we can easily remove it later, see crbug/575276.
+#define WIMPI_CAST

[DaleCurtis, 2016/01/07 19:59:32]

Can we avoid setting this here. #define in header files are frowned upon.

[hubbe, 2016/01/07 20:31:03]

Hmm, so where should it go then?

I see two possible options:

1) add the defines in the build files
   (But this seems quite dangerous, what happens if different modules get
compiled with different defines??)

2) just use OS_ANDROID

[DaleCurtis, 2016/01/07 21:28:39]

I'd just use OS_ANDROID with a // WMPI_CAST comment for deletability later.

[hubbe, 2016/01/11 22:47:24]

Done.

+#endif
+
+#if defined(WIMPI_CAST)
+// Delete this file when WIMPI_CAST is no longer needed.
+#include "media/blink/renderer_media_player_interface.h"
+#endif
+
 namespace blink {
 class WebGraphicsContext3D;
 class WebLocalFrame;
 class WebMediaPlayerClient;
 class WebMediaPlayerEncryptedMediaClient;
 }
 
 namespace base {
 class SingleThreadTaskRunner;
 class TaskRunner;
@@ skipping 14 matching lines @@
 class WebAudioSourceProviderImpl;
 class WebMediaPlayerDelegate;
 class WebTextTrackImpl;
 
 // The canonical implementation of blink::WebMediaPlayer that's backed by
 // Pipeline. Handles normal resource loading, Media Source, and
 // Encrypted Media.
 class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
     : public NON_EXPORTED_BASE(blink::WebMediaPlayer),
       public NON_EXPORTED_BASE(WebMediaPlayerDelegate::Observer),
+#if defined(WIMPI_CAST)
+      public RendererMediaPlayerInterface,
+#endif
       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
  public:
   // Constructs a WebMediaPlayer implementation using Chromium's media stack.
   // |delegate| may be null. |renderer| may also be null, in which case an
   // internal renderer will be created.
   // TODO(xhwang): Drop the internal renderer path and always pass in a renderer
   // here.
   WebMediaPlayerImpl(
       blink::WebLocalFrame* frame,
       blink::WebMediaPlayerClient* client,
@@ skipping 100 matching lines @@
   void OnPipelineMetadata(PipelineMetadata metadata);
   void OnPipelineBufferingStateChanged(BufferingState buffering_state);
   void OnDemuxerOpened();
   void OnAddTextTrack(const TextTrackConfig& config,
                       const AddTextTrackDoneCB& done_cb);
 
   // WebMediaPlayerDelegate::Observer implementation.
   void OnHidden() override;
   void OnShown() override;
 
+#if defined(WIMPI_CAST)

[DaleCurtis, 2016/01/07 19:59:32]

Can you stick this all in another class instead that WMPI can inherit
conditionally based on defined(OS_ANDROID)? This would simply #define.

You can add IsRemote() and other helper methods that WMPI can call as necessary
for instances where a clean separation isn't possible.

[hubbe, 2016/01/07 20:31:03]

It's not a simple thing to do.
Some of these methods manipulate WIMI variables, also a couple of the methods
from RendererMediaPlayerInterface are not actually inside this  #if, since they
were already available in WebMediaPlayerImpl

[DaleCurtis, 2016/01/07 21:28:40]

Please give it some more thought. You're essentially gluing 900+ lines into WMPI
many of which are not using internal variables or functions; even for a
temporary change is ugly.

[DaleCurtis, 2016/01/07 21:29:09]

s/900/400/

[liberato (no reviews please), 2016/01/08 16:37:58]

many of the operations these things perform are on |client_|, or on member
variables that are specific to remote playback.

i think that one might be able to create a class that inherits from the
RendererMediaPlayerInterface, is given |client_|, and just notifies WMPI when
exiting or entering remote playback.  calls to WebMediaPlayer (e.g., play) can
be delegated.

[hubbe, 2016/01/11 22:47:24]

I think it might turn out messy, but I'm not sure.
I'll make a copy of this CL and try it.

+  void requestRemotePlayback() override;
+  void requestRemotePlaybackControl() override;
+
+  void set_media_player_manager(
+      RendererMediaPlayerManagerInterface* media_player_manager);
+
+  // RendererMediaPlayerInterface implementation
+  void OnMediaMetadataChanged(base::TimeDelta duration,
+                              int width,
+                              int height,
+                              bool success) override;
+  void OnPlaybackComplete() override;
+  void OnBufferingUpdate(int percentage) override;
+  void OnSeekRequest(const base::TimeDelta& time_to_seek) override;
+  void OnSeekComplete(const base::TimeDelta& current_time) override;
+  void OnMediaError(int error_type) override;
+  void OnVideoSizeChanged(int width, int height) override;
+
+  // Called to update the current time.
+  void OnTimeUpdate(base::TimeDelta current_timestamp,
+                    base::TimeTicks current_time_ticks) override;
+
+  // void OnWaitingForDecryptionKey() override;
+  void OnPlayerReleased() override;
+
+  // Functions called when media player status changes.
+  void OnConnectedToRemoteDevice(
+      const std::string& remote_playback_message) override;
+  void OnDisconnectedFromRemoteDevice() override;
+  void OnDidExitFullscreen() override;
+  void OnMediaPlayerPlay() override;
+  void OnMediaPlayerPause() override;
+  void OnRemoteRouteAvailabilityChanged(bool routes_available) override;
+
+  // Getters of playback state.
+  // bool paused() const override;
+
+  // True if the loaded media has a playable video track.
+  // bool hasVideo() const override;
+
+  // This function is called by the RendererMediaPlayerManager to pause the
+  // video and release the media player and surface texture when we switch tabs.
+  // However, the actual GlTexture is not released to keep the video screenshot.
+  void ReleaseMediaResources() override;
+
+#if defined(VIDEO_HOLE)
+  // Calculate the boundary rectangle of the media player (i.e. location and
+  // size of the video frame).
+  // Returns true if the geometry has been changed since the last call.
+  bool UpdateBoundaryRectangle() override;
+
+  const gfx::RectF GetBoundaryRectangle() override;
+#endif
+
+  void DrawRemotePlaybackText(const std::string& remote_playback_message);
+#endif
+
  private:
   // Initiate suspending the pipeline.
   void Suspend();
 
   // Initiate resuming the pipeline.
   void Resume();
 
   // Called after |defer_load_cb_| has decided to allow the load. If
   // |defer_load_cb_| is null this is called immediately.
   void DoLoad(LoadType load_type,
@@ skipping 32 matching lines @@
   // Returns the current video frame from |compositor_|. Blocks until the
   // compositor can return the frame.
   scoped_refptr<VideoFrame> GetCurrentFrameFromCompositor();
 
   // Called when the demuxer encounters encrypted streams.
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data);
 
   // Called when a decoder detects that the key needed to decrypt the stream
   // is not available.
-  void OnWaitingForDecryptionKey();
+  void OnWaitingForDecryptionKey() override;
 
   // Sets |cdm_context| on the pipeline and fires |cdm_attached_cb| when done.
   // Parameter order is reversed for easy binding.
   void SetCdm(const CdmAttachedCB& cdm_attached_cb, CdmContext* cdm_context);
 
   // Called when a CDM has been attached to the |pipeline_|.
   void OnCdmAttached(bool success);
 
   // Updates |paused_time_| to the current media time with consideration for the
   // |ended_| state by clamping current time to duration upon |ended_|.
@@ skipping 137 matching lines @@
   // The compositor layer for displaying the video content when using composited
   // playback.
   scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   EncryptedMediaPlayerSupport encrypted_media_support_;
 
   scoped_ptr<blink::WebContentDecryptionModuleResult> set_cdm_result_;
 
   scoped_ptr<RendererFactory> renderer_factory_;
 
+#if defined(WIMPI_CAST)
+  // Manages this object and delegates player calls to the browser process.
+  // Owned by RenderFrameImpl.
+  RendererMediaPlayerManagerInterface* player_manager_ = nullptr;
+
+  // Player ID assigned by the |player_manager_|.
+  int player_id_;
+
+  // Whether the browser is currently connected to a remote media player.
+  bool is_remote_ = false;
+
+  // Last reported playout time.
+  base::TimeDelta remote_time_;
+  base::TimeTicks remote_time_at_;
+
+  // Whether the media player has been initialized.
+  bool is_player_initialized_ = false;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_