Delete browser MSE implementation.

content/renderer/media/android/webmediaplayer_android.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 CONTENT_RENDERER_MEDIA_ANDROID_WEBMEDIAPLAYER_ANDROID_H_
 #define CONTENT_RENDERER_MEDIA_ANDROID_WEBMEDIAPLAYER_ANDROID_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "cc/layers/video_frame_provider.h"
 #include "content/renderer/media/android/media_info_loader.h"
-#include "content/renderer/media/android/media_source_delegate.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/media/android/stream_texture_factory.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "media/base/android/media_player_android.h"
-#include "media/base/cdm_context.h"
-#include "media/base/demuxer_stream.h"
-#include "media/base/eme_constants.h"
-#include "media/base/media_keys.h"
 #include "media/base/time_delta_interpolator.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebSetSinkIdCallbacks.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace base {
@@ skipping 148 matching lines @@
 
   // Media player callback handlers.
   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;
-  void OnDurationChanged(const base::TimeDelta& duration);
 
   // Called to update the current time.
   void OnTimeUpdate(base::TimeDelta current_timestamp,
                     base::TimeTicks current_time_ticks) override;
 
   // Functions called when media player status changes.
   void OnConnectedToRemoteDevice(const std::string& remote_playback_message)
       override;
   void OnDisconnectedFromRemoteDevice() override;
   void OnCancelledRemotePlaybackRequest() override;
   void OnDidExitFullscreen() override;
   void OnMediaPlayerPlay() override;
   void OnMediaPlayerPause() override;
   void OnRemoteRouteAvailabilityChanged(bool routes_available) override;
 
   // Called when the player is released.
   void OnPlayerReleased() 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 SuspendAndReleaseResources() override;
 
   void setContentDecryptionModule(
       blink::WebContentDecryptionModule* cdm,
       blink::WebContentDecryptionModuleResult result) override;
 
-  void OnMediaSourceOpened(blink::WebMediaSource* web_media_source);
-
-  void OnEncryptedMediaInitData(media::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() override;
-
   // WebMediaPlayerDelegate::Observer implementation.
   void OnHidden() override;
   void OnShown() override;
   void OnSuspendRequested(bool must_suspend) override;
   void OnPlay() override;
   void OnPause() override;
   void OnVolumeMultiplierUpdate(double multiplier) override;
 
  protected:
   // Helper method to update the playing state.
   void UpdatePlayingState(bool is_playing_);
 
   // Helper methods for posting task for setting states and update WebKit.
   void UpdateNetworkState(blink::WebMediaPlayer::NetworkState state);
   void UpdateReadyState(blink::WebMediaPlayer::ReadyState state);
   void TryCreateStreamTextureProxyIfNeeded();
   void DoCreateStreamTexture();
 
   // Helper method to reestablish the surface texture peer for android
   // media player.
   void EstablishSurfaceTexturePeer();
 
   // Requesting whether the surface texture peer needs to be reestablished.
   void SetNeedsEstablishPeer(bool needs_establish_peer);
 
  private:
   void InitializePlayer(const GURL& url,
                         const GURL& first_party_for_cookies,
-                        bool allowed_stored_credentials,
-                        int demuxer_client_id);
+                        bool allowed_stored_credentials);
   void Pause(bool is_media_related_action);
   void DrawRemotePlaybackText(const std::string& remote_playback_message);
   void ReallocateVideoFrame();
   void SetCurrentFrameInternal(scoped_refptr<media::VideoFrame>& frame);
   void RemoveSurfaceTextureAndProxy();
   void DidLoadMediaInfo(MediaInfoLoader::Status status,
                         const GURL& redirected_url,
                         const GURL& first_party_for_cookies,
                         bool allow_stored_credentials);
-  bool IsKeySystemSupported(const std::string& key_system);
   bool IsLocalResource();
 
   // Called whenever we create a new StreamTextureProxy and had a VFP::Client,
   // or when we get a new VFP::Client and had a StreamTextureProxy.
   // Sets |stream_texture_proxy_|'s OnFrameAvailable() to call |client|'s
   // DidReceiveFrame().
   // Passing nullptr to this method will clear the previous callback.
   void UpdateStreamTextureProxyCallback(cc::VideoFrameProvider::Client* client);
 
-  // Called when |cdm_context| is ready.
-  void OnCdmContextReady(media::CdmContext* cdm_context);
-
-  // Sets the CDM. Should only be called when |is_player_initialized_| is true
-  // and a new non-null |cdm_context_| is available. Fires |cdm_attached_cb_| on
-  // the main thread with the result after the CDM is attached.
-  void SetCdmInternal(const media::CdmAttachedCB& cdm_attached_cb);
-
-  // Called when the CDM is attached.
-  void OnCdmAttached(const media::CdmAttachedCB& cdm_attached_cb, bool success);
-
-  // Requests that this object notifies when a CDM is ready through the
-  // |cdm_ready_cb| provided.
-  // If |cdm_ready_cb| is null, the existing callback will be fired with
-  // NULL immediately and reset.
-  void SetCdmReadyCB(const MediaSourceDelegate::CdmReadyCB& cdm_ready_cb);
-
-  // Called when the ContentDecryptionModule has been attached to the
-  // pipeline/decoders.
-  void ContentDecryptionModuleAttached(
-      blink::WebContentDecryptionModuleResult result,
-      bool success);
-
   bool IsHLSStream() const;
   // Report whether the loaded url, after following redirects, points to a HLS
   // playlist, and record the origin of the player.
   void ReportHLSMetrics() const;
 
   // 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);
 
   // Returns if this video can be resumed in the background.
   bool IsBackgroundVideoCandidate() const;
 
   blink::WebFrame* const frame_;
 
   blink::WebMediaPlayerClient* const client_;
-  blink::WebMediaPlayerEncryptedMediaClient* const 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<media::WebMediaPlayerDelegate> delegate_;
   int delegate_id_;
 
   // Callback responsible for determining if loading of media should be deferred
   // for external reasons; called during load().
@@ skipping 107 matching lines @@
 
   MediaPlayerHostMsg_Initialize_Type player_type_;
 
   // Whether the browser is currently connected to a remote media player.
   bool is_remote_;
 
   scoped_refptr<media::MediaLog> media_log_;
 
   std::unique_ptr<MediaInfoLoader> info_loader_;
 
-  // Non-owned pointer to the CdmContext. Updated in the constructor,
-  // generateKeyRequest() or setContentDecryptionModule().
-  media::CdmContext* cdm_context_;
-
-  // This is only Used by Clear Key key system implementation, where a renderer
-  // side CDM will be used. This is similar to WebMediaPlayerImpl. For other key
-  // systems, a browser side CDM will be used and we set CDM by calling
-  // player_manager_->SetCdm() directly.
-  MediaSourceDelegate::CdmReadyCB cdm_ready_cb_;
-
   // Whether stored credentials are allowed to be passed to the server.
   bool allow_stored_credentials_;
 
   // Whether the resource is local.
   bool is_local_resource_;
 
   // base::TickClock used by |interpolator_|.
   base::DefaultTickClock default_tick_clock_;
 
   // Tracks the most recent media time update and provides interpolated values
   // as playback progresses.
   media::TimeDeltaInterpolator interpolator_;
 
-  std::unique_ptr<MediaSourceDelegate> media_source_delegate_;
-
   int frame_id_;
 
   // Whether to require that surface textures are copied in order to support
   // sharing between render and gpu threads in WebView.
   bool enable_texture_copy_;
 
   // Whether to delete the existing texture and re-create it.
   bool suppress_deleting_texture_;
 
   // Whether OnPlaybackComplete() has been called since the last playback.
   bool playback_completed_;
 
   // 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_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<WebMediaPlayerAndroid> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerAndroid);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_ANDROID_WEBMEDIAPLAYER_ANDROID_H_