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);
 
@@ skipping 25 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);
+
   // 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_;
 
   base::WeakPtr<WebMediaPlayerDelegate> delegate_;
 
   WebMediaPlayerParams::DeferLoadCB defer_load_cb_;
   WebMediaPlayerParams::Context3DCB context_3d_cb_;
 
   // Members for notifying upstream clients about internal memory usage.  The
   // |adjust_allocated_memory_cb_| must only be called on |main_task_runner_|.
@@ skipping 34 matching lines @@
 
   // Whether a CDM has been successfully attached.
   bool is_cdm_attached_;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   WebMediaPlayerCast cast_impl_;
 #endif
 
   scoped_ptr<RendererFactory> renderer_factory_;
 
+  SurfaceManager* surface_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_