Enable SurfaceView fullscreen video on Android with WebMediaPlayerImpl

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>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/pipeline.h"
 #include "media/base/renderer_factory.h"
+#include "media/base/surface_manager.h"
 #include "media/base/text_track.h"
 #include "media/blink/buffered_data_source.h"
 #include "media/blink/buffered_data_source_host_impl.h"
 #include "media/blink/encrypted_media_player_support.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/multibuffer_data_source.h"
 #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"
@@ skipping 18 matching lines @@
 namespace base {
 class SingleThreadTaskRunner;
 class TaskRunner;
 }
 
 namespace cc_blink {
 class WebLayerImpl;
 }
 
 namespace media {
-
 class AudioHardwareConfig;
 class ChunkDemuxer;
 class GpuVideoAcceleratorFactories;
 class MediaLog;
 class UrlIndex;
 class VideoFrameCompositor;
 class WebAudioSourceProviderImpl;
 class WebMediaPlayerDelegate;
 class WebTextTrackImpl;
 
@@ skipping 101 matching lines @@
                            const blink::WebString& session_id) override;
 
   MediaKeyException cancelKeyRequest(
       const blink::WebString& key_system,
       const blink::WebString& session_id) override;
 
   void setContentDecryptionModule(
       blink::WebContentDecryptionModule* cdm,
       blink::WebContentDecryptionModuleResult result) override;
 
+  void enterFullscreen() override;
+  void exitedFullscreen() override;
+
   void OnPipelineSeeked(bool time_changed, PipelineStatus status);
   void OnPipelineSuspended(PipelineStatus status);
   void OnPipelineEnded();
   void OnPipelineError(PipelineStatus error);
   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;
   void OnPlay() override;
   void OnPause() override;
   void OnVolumeMultiplierUpdate(double multiplier) override;
 
-#if defined(OS_ANDROID)  // WMPI_CAST
+#if defined(OS_ANDROID)
+  void SetSurfaceManager(SurfaceManager* surface_manager);
+
+  // WMPI_CAST
   bool isRemote() const override;
   void requestRemotePlayback() override;
   void requestRemotePlaybackControl() override;
 
   void SetMediaPlayerManager(
       RendererMediaPlayerManagerInterface* media_player_manager);
   void OnRemotePlaybackEnded();
   void OnDisconnectedFromRemoteDevice(double t);
   void SuspendForRemote();
   void DisplayCastFrameAfterSuspend(const scoped_refptr<VideoFrame>& new_frame,
@@ skipping 10 matching lines @@
   // Initiate suspending the pipeline.
   void Suspend();
 
   // Ask for the pipeline to be resumed, will call Resume() when ready.
   // (Possibly immediately.)
   void ScheduleResume();
 
   // Initiate resuming the pipeline.
   void Resume();
 
+  // Ask for the renderer to be restarted (destructed and recreated).
+  void ScheduleRestart();
+
   // 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,
               const blink::WebURL& url,
               CORSMode cors_mode);
 
   // Called after asynchronous initialization of a data source completed.
   void DataSourceInitialized(bool success);
 
   // Called when the data source is downloading or paused.
   void NotifyDownloading(bool is_downloading);
 
+  void OnSurfaceRequested(const SurfaceCreatedCB& surface_created_cb);

[liberato (no reviews please), 2016/02/05 22:09:46]

probably want to #if android this, since the definition is already compiled out.

+
   // Creates a Renderer via the |renderer_factory_|.
   scoped_ptr<Renderer> CreateRenderer();
 
   // Finishes starting the pipeline due to a call to load().
   void StartPipeline();
 
   // Helpers that set the network/ready state and notifies the client if
   // they've changed.
   void SetNetworkState(blink::WebMediaPlayer::NetworkState state);
   void SetReadyState(blink::WebMediaPlayer::ReadyState state);
@@ skipping 108 matching lines @@
 
   // Set for the entire period between suspend starting and resume completing.
   bool suspending_;
 
   // Set while suspending to detect double-suspend.
   bool suspended_;
 
   // Set while resuming to detect double-resume.
   bool resuming_;
 
+  // Set when doing both a suspend and resume in sequence in order to restart
+  // the pipeline, and specifically the decoders.
+  bool pending_suspend_resume_cycle_;
+
   // TODO(scherkus): Replace with an explicit ended signal to HTMLMediaElement,
   // see http://crbug.com/409280
   bool ended_;
 
   // Indicates that a seek is queued after the current seek completes or, if the
   // pipeline is suspended, after it resumes. Only the last queued seek will
   // have any effect.
   bool pending_seek_;
 
   // |pending_seek_time_| is meaningless when |pending_seek_| is false.
   base::TimeDelta pending_seek_time_;
 
   // Tracks whether to issue time changed notifications during buffering state
   // changes.
   bool should_notify_time_changed_;
 
+  bool fullscreen_;
+
+  // Whether the current decoder requires a restart on fullscreen transitions.
+  bool decoder_requires_restart_for_fullscreen_;
+
   blink::WebMediaPlayerClient* client_;
   blink::WebMediaPlayerEncryptedMediaClient* encrypted_client_;
 
   // WebMediaPlayer notifies the |delegate_| of playback state changes using
   // |delegate_id_|; an id provided after registering with the delegate.  The
   // WebMediaPlayer may also receive directives (play, pause) from the delegate
   // via the WebMediaPlayerDelegate::Observer interface after registration.
   base::WeakPtr<WebMediaPlayerDelegate> delegate_;
   int delegate_id_;
 
@@ skipping 33 matching lines @@
   // playback.
   scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   EncryptedMediaPlayerSupport encrypted_media_support_;
 
   scoped_ptr<blink::WebContentDecryptionModuleResult> set_cdm_result_;
 
   // Whether a CDM has been successfully attached.
   bool is_cdm_attached_;
 
-#if defined(OS_ANDROID)  // WMPI_CAST
+#if defined(OS_ANDROID)
+  // For requesting surfaces on behalf of the Android H/W decoder in fullscreen.

[DaleCurtis, 2016/02/06 00:17:39]

Lets avoid the OS_ANDROID #define where possible and instead just let this be a
nullptr.

[watk, 2016/02/11 23:03:25]

Done.

+  SurfaceManager* surface_manager_;
+
+  // WMPI_CAST
   WebMediaPlayerCast cast_impl_;
 #endif
 
   // The last volume received by setVolume() and the last volume multiplier from
   // OnVolumeMultiplierUpdate().  The multiplier is typical 1.0, but may be less
   // if the WebMediaPlayerDelegate has requested a volume reduction (ducking)
   // for a transient sound.  Playout volume is derived by volume * multiplier.
   double volume_;
   double volume_multiplier_;
 
   scoped_ptr<RendererFactory> renderer_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_