Remove prefixed EME.

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 <string>
@@ skipping 12 matching lines @@
 #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/media_keys.h"
 #include "media/base/time_delta_interpolator.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
-#include "media/cdm/proxy_decryptor.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.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 "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ skipping 11 matching lines @@
 namespace cc_blink {
 class WebLayerImpl;
 }
 
 namespace gpu {
 struct MailboxHolder;
 }
 
 namespace media {
 class CdmContext;
-class CdmFactory;
 class MediaLog;
-class MediaPermission;
 class WebContentDecryptionModuleImpl;
 }
 
 namespace content {
 
-class RendererCdmManager;
 class RendererMediaPlayerManager;
 
 // This class implements blink::WebMediaPlayer by keeping the android
 // media player in the browser process. It listens to all the status changes
 // sent from the browser process and sends playback controls to the media
 // player.
 class WebMediaPlayerAndroid
     : public blink::WebMediaPlayer,
       public cc::VideoFrameProvider,
       public StreamTextureFactoryContextObserver,
       public media::RendererMediaPlayerInterface,
       public NON_EXPORTED_BASE(media::WebMediaPlayerDelegate::Observer) {
  public:
   // Construct a WebMediaPlayerAndroid object. This class communicates with the
   // MediaPlayerAndroid object in the browser process through |proxy|.
   // TODO(qinmin): |frame| argument is used to determine whether the current
   // player can enter fullscreen. This logic should probably be moved into
   // blink, so that enteredFullscreen() will not be called if another video is
   // already in fullscreen.
   WebMediaPlayerAndroid(
       blink::WebFrame* frame,
       blink::WebMediaPlayerClient* client,
       blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
       base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
       RendererMediaPlayerManager* player_manager,
-      media::CdmFactory* cdm_factory,
       scoped_refptr<StreamTextureFactory> factory,
       int frame_id,
       bool enable_texture_copy,
       const media::WebMediaPlayerParams& params);
   ~WebMediaPlayerAndroid() override;
 
   // blink::WebMediaPlayer implementation.
   bool supportsOverlayFullscreenVideo() override;
   void enteredFullscreen() override;
 
@@ skipping 118 matching lines @@
 
 #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  // defined(VIDEO_HOLE)
 
-  MediaKeyException generateKeyRequest(const blink::WebString& key_system,
-                                       const unsigned char* init_data,
-                                       unsigned init_data_length) override;
-  MediaKeyException addKey(const blink::WebString& key_system,
-                           const unsigned char* key,
-                           unsigned key_length,
-                           const unsigned char* init_data,
-                           unsigned init_data_length,
-                           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 OnKeyAdded(const std::string& session_id);
-  void OnKeyError(const std::string& session_id,
-                  media::MediaKeys::KeyError error_code,
-                  uint32_t system_code);
-  void OnKeyMessage(const std::string& session_id,
-                    const std::vector<uint8_t>& message,
-                    const GURL& destination_url);
-
   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.
@@ skipping 30 matching lines @@
   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();
 
-  // Actually do the work for generateKeyRequest/addKey so they can easily
-  // report results to UMA.
-  MediaKeyException GenerateKeyRequestInternal(const std::string& key_system,
-                                               const unsigned char* init_data,
-                                               unsigned init_data_length);
-  MediaKeyException AddKeyInternal(const std::string& key_system,
-                                   const unsigned char* key,
-                                   unsigned key_length,
-                                   const unsigned char* init_data,
-                                   unsigned init_data_length,
-                                   const std::string& session_id);
-  MediaKeyException CancelKeyRequestInternal(const std::string& key_system,
-                                             const std::string& session_id);
-
   // 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);
@@ skipping 77 matching lines @@
   bool seeking_;
   base::TimeDelta seek_time_;
 
   // Whether loading has progressed since the last call to didLoadingProgress.
   bool did_loading_progress_;
 
   // Manages this object and delegates player calls to the browser process.
   // Owned by RenderFrameImpl.
   RendererMediaPlayerManager* const player_manager_;
 
-  // TODO(xhwang): Remove |cdm_factory_| when prefixed EME is deprecated. See
-  // http://crbug.com/249976
-  media::CdmFactory* const cdm_factory_;
-
-  media::MediaPermission* media_permission_;
-
   // Player ID assigned by the |player_manager_|.
   int player_id_;
 
   // Current player states.
   blink::WebMediaPlayer::NetworkState network_state_;
   blink::WebMediaPlayer::ReadyState ready_state_;
 
   // GL texture ID allocated to the video.
   unsigned int texture_id_;
 
@@ skipping 54 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_;
 
   scoped_ptr<MediaInfoLoader> info_loader_;
 
-  // The currently selected key system. Empty string means that no key system
-  // has been selected.
-  std::string current_key_system_;
-
-  // Temporary for EME v0.1. Not needed for unprefixed EME, and can be removed
-  // when prefixed EME is removed.
-  media::EmeInitDataType init_data_type_;
-
-  // Manages decryption keys and decrypts encrypted frames.
-  scoped_ptr<media::ProxyDecryptor> proxy_decryptor_;
-
   // 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.
   media::CdmReadyCB cdm_ready_cb_;
 
@@ skipping 35 matching lines @@
 
   // 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_