[media] Apply inside blink to renderer/platform/media

Move some more blink media code into platform/media from public/platform/media. This allows us to use KURL directly and
not go to a WebURL on some calls.

Apply INSIDE_BLINK macro to other code that is in platform/media so
it will use the internal types. This is necessary because this code uses
blink mojom types and we want to enforce that blink mojo headers are
only included inside blink. Fortunately this addresses some of the
discouraged type overrides in the media code.

BYPASS_LARGE_CHANGE_WARNING=File move

Change-Id: I712128d82bb7e1971548f22aaadfdf31a7393ad6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5962517
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1374973}

content/renderer/media/android/flinging_renderer_client_factory.cc

@@ -20,9 +20,9 @@ namespace content {
 
 FlingingRendererClientFactory::FlingingRendererClientFactory(
     std::unique_ptr<media::MojoRendererFactory> mojo_flinging_factory,
-    std::unique_ptr<media::RemotePlaybackClientWrapper> remote_playback_client)
+    media::RemotePlaybackClientWrapper* remote_playback_client)
     : mojo_flinging_factory_(std::move(mojo_flinging_factory)),
-      remote_playback_client_(std::move(remote_playback_client)) {}
+      remote_playback_client_(remote_playback_client) {}
 
 FlingingRendererClientFactory::~FlingingRendererClientFactory() = default;
 

content/renderer/media/android/flinging_renderer_client_factory.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>
 
+#include "base/memory/raw_ptr.h"
 #include "base/task/sequenced_task_runner.h"
 #include "content/common/content_export.h"
 #include "media/base/media_status.h"
@@ -28,8 +29,7 @@ class CONTENT_EXPORT FlingingRendererClientFactory
  public:
   FlingingRendererClientFactory(
       std::unique_ptr<media::MojoRendererFactory> mojo_renderer_factory,
-      std::unique_ptr<media::RemotePlaybackClientWrapper>
-          remote_playback_client);
+      media::RemotePlaybackClientWrapper* remote_playback_client);
 
   FlingingRendererClientFactory(const FlingingRendererClientFactory&) = delete;
   FlingingRendererClientFactory& operator=(
@@ -59,7 +59,7 @@ class CONTENT_EXPORT FlingingRendererClientFactory
   std::string GetActivePresentationId();
 
   std::unique_ptr<media::MojoRendererFactory> mojo_flinging_factory_;
-  std::unique_ptr<media::RemotePlaybackClientWrapper> remote_playback_client_;
+  raw_ptr<media::RemotePlaybackClientWrapper> remote_playback_client_;
 
   media::RemotePlayStateChangeCB remote_play_state_change_cb_;
 };

content/renderer/media/media_factory.cc

@@ -56,7 +56,6 @@
 #include "third_party/blink/public/common/thread_safe_browser_interface_broker_proxy.h"
 #include "third_party/blink/public/platform/browser_interface_broker_proxy.h"
 #include "third_party/blink/public/platform/media/key_system_config_selector.h"
-#include "third_party/blink/public/platform/media/remote_playback_client_wrapper_impl.h"
 #include "third_party/blink/public/platform/media/video_frame_compositor.h"
 #include "third_party/blink/public/platform/media/web_encrypted_media_client_impl.h"
 #include "third_party/blink/public/platform/media/web_media_player_builder.h"
@@ -435,8 +434,7 @@ std::unique_ptr<blink::WebMediaPlayer> MediaFactory::CreateMediaPlayer(
   auto factory_selector = CreateRendererFactorySelector(
       player_id, media_log.get(), url,
       render_frame_->GetRenderFrameMediaPlaybackOptions(),
-      decoder_factory_.get(),
-      std::make_unique<blink::RemotePlaybackClientWrapperImpl>(client),
+      decoder_factory_.get(), client->RemotePlaybackClientWrapper(),
       &media_observer, client->GetElementId());
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
@@ -534,7 +532,7 @@ MediaFactory::CreateRendererFactorySelector(
     blink::WebURL url,
     const RenderFrameMediaPlaybackOptions& renderer_media_playback_options,
     media::DecoderFactory* decoder_factory,
-    std::unique_ptr<media::RemotePlaybackClientWrapper> client_wrapper,
+    media::RemotePlaybackClientWrapper* client_wrapper,
     base::WeakPtr<media::MediaObserver>* out_media_observer,
     int element_id) {
   using media::RendererType;

content/renderer/media/media_factory.h

@@ -133,7 +133,7 @@ class MediaFactory {
       blink::WebURL url,
       const RenderFrameMediaPlaybackOptions& renderer_media_playback_options,
       media::DecoderFactory* decoder_factory,
-      std::unique_ptr<media::RemotePlaybackClientWrapper> client_wrapper,
+      media::RemotePlaybackClientWrapper* client_wrapper,
       base::WeakPtr<media::MediaObserver>* out_media_observer,
       int element_id);
 

content/renderer/render_frame_impl.cc

@@ -204,7 +204,6 @@
 #include "third_party/blink/public/web/blink.h"
 #include "third_party/blink/public/web/modules/media/audio/audio_device_factory.h"
 #include "third_party/blink/public/web/modules/media/audio/audio_output_ipc_factory.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/public/web/modules/mediastream/web_media_stream_device_observer.h"
 #include "third_party/blink/public/web/web_autofill_client.h"
 #include "third_party/blink/public/web/web_console_message.h"
@@ -6496,19 +6495,6 @@ void RenderFrameImpl::BindMhtmlFileWriter(
       std::move(receiver), GetTaskRunner(blink::TaskType::kInternalDefault));
 }
 
-// TODO(crbug.com/40550966): Move this method to Blink, and eliminate
-// the plumbing logic through blink::WebLocalFrameClient.
-void RenderFrameImpl::CheckIfAudioSinkExistsAndIsAuthorized(
-    const blink::WebString& sink_id,
-    blink::WebSetSinkIdCompleteCallback completion_callback) {
-  std::move(
-      blink::ConvertToOutputDeviceStatusCB(std::move(completion_callback)))
-      .Run(blink::AudioDeviceFactory::GetInstance()
-               ->GetOutputDeviceInfo(GetWebFrame()->GetLocalFrameToken(),
-                                     sink_id.Utf8())
-               .device_status());
-}
-
 scoped_refptr<network::SharedURLLoaderFactory>
 RenderFrameImpl::GetURLLoaderFactory() {
   if (!RenderThreadImpl::current()) {

content/renderer/render_frame_impl.h

@@ -667,9 +667,6 @@ class CONTENT_EXPORT RenderFrameImpl
       std::vector<ui::AXEvent> events,
       ui::AXLocationAndScrollUpdates location_and_scroll_updates,
       bool had_load_complete_messages) override;
-  void CheckIfAudioSinkExistsAndIsAuthorized(
-      const blink::WebString& sink_id,
-      blink::WebSetSinkIdCompleteCallback callback) override;
   scoped_refptr<network::SharedURLLoaderFactory> GetURLLoaderFactory() override;
   blink::URLLoaderThrottleProvider* GetURLLoaderThrottleProvider() override;
   scoped_refptr<blink::WebBackgroundResourceFetchAssets>

content/web_test/renderer/web_frame_test_proxy.cc

@@ -731,19 +731,17 @@ void WebFrameTestProxy::HandleWebAccessibilityEventForTest(
                                      event.event_intents);
 }
 
-void WebFrameTestProxy::CheckIfAudioSinkExistsAndIsAuthorized(
-    const blink::WebString& sink_id,
-    blink::WebSetSinkIdCompleteCallback completion_callback) {
+std::optional<media::OutputDeviceStatus>
+WebFrameTestProxy::CheckIfAudioSinkExistsAndIsAuthorized(
+    const blink::WebString& sink_id) {
   std::string device_id = sink_id.Utf8();
-  if (device_id == "valid" || device_id.empty())
-    std::move(completion_callback).Run(/*error =*/std::nullopt);
-  else if (device_id == "unauthorized")
-    std::move(completion_callback)
-        .Run(blink::WebSetSinkIdError::kNotAuthorized);
-  else
-    std::move(completion_callback).Run(blink::WebSetSinkIdError::kNotFound);
-
-  // Intentionally does not call RenderFrameImpl.
+  if (device_id == "valid" || device_id.empty()) {
+    return media::OutputDeviceStatus::OUTPUT_DEVICE_STATUS_OK;
+  } else if (device_id == "unauthorized") {
+    return media::OutputDeviceStatus::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED;
+  } else {
+    return media::OutputDeviceStatus::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
+  }
 }
 
 void WebFrameTestProxy::DidClearWindowObject() {

content/web_test/renderer/web_frame_test_proxy.h

@@ -82,9 +82,9 @@ class WebFrameTestProxy : public RenderFrameImpl,
   void FinalizeRequest(blink::WebURLRequest& request) override;
   void BeginNavigation(std::unique_ptr<blink::WebNavigationInfo> info) override;
   void PostAccessibilityEvent(const ui::AXEvent& event) override;
-  void CheckIfAudioSinkExistsAndIsAuthorized(
-      const blink::WebString& sink_id,
-      blink::WebSetSinkIdCompleteCallback completion_callback) override;
+  std::optional<media::OutputDeviceStatus>
+  CheckIfAudioSinkExistsAndIsAuthorized(
+      const blink::WebString& sink_id) override;
   void DidClearWindowObject() override;
   void DidCommitNavigation(
       blink::WebHistoryCommitType commit_type,

third_party/blink/public/BUILD.gn

@@ -144,7 +144,6 @@ source_set("blink_headers") {
     "platform/modules/mediastream/web_media_stream_track.h",
     "platform/modules/mediastream/web_platform_media_stream_source.h",
     "platform/modules/remoteplayback/remote_playback_source.h",
-    "platform/modules/remoteplayback/web_remote_playback_client.h",
     "platform/modules/service_worker/web_service_worker_error.h",
     "platform/modules/service_worker/web_service_worker_fetch_context.h",
     "platform/modules/service_worker/web_service_worker_network_provider.h",
@@ -272,7 +271,6 @@ source_set("blink_headers") {
     "web/modules/media/audio/audio_device_factory.h",
     "web/modules/media/audio/audio_input_ipc_factory.h",
     "web/modules/media/audio/audio_output_ipc_factory.h",
-    "web/modules/media/web_media_player_util.h",
     "web/modules/mediastream/encoded_video_frame.h",
     "web/modules/mediastream/media_stream_video_sink.h",
     "web/modules/mediastream/media_stream_video_source.h",

third_party/blink/public/platform/media/BUILD.gn

@@ -10,7 +10,6 @@
 source_set("media") {
   sources = [
     "key_system_config_selector.h",
-    "remote_playback_client_wrapper_impl.h",
     "video_frame_compositor.h",
     "web_encrypted_media_client_impl.h",
     "web_media_player_builder.h",

third_party/blink/public/platform/media/remote_playback_client_wrapper_impl.h

@@ -1,34 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_WRAPPER_IMPL_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_WRAPPER_IMPL_H_
-
-#include <string>
-
-#include "base/memory/raw_ptr.h"
-#include "media/renderers/remote_playback_client_wrapper.h"
-#include "third_party/blink/public/platform/web_common.h"
-
-namespace blink {
-class WebMediaPlayerClient;
-class WebRemotePlaybackClient;
-
-// Wraps a WebRemotePlaybackClient to expose only the methods used by the
-// FlingingRendererClientFactory. This avoids dependencies on the blink layer.
-class BLINK_PLATFORM_EXPORT RemotePlaybackClientWrapperImpl
-    : public media::RemotePlaybackClientWrapper {
- public:
-  explicit RemotePlaybackClientWrapperImpl(WebMediaPlayerClient* client);
-  ~RemotePlaybackClientWrapperImpl() override;
-
-  std::string GetActivePresentationId() override;
-
- private:
-  raw_ptr<WebRemotePlaybackClient> remote_playback_client_;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_WRAPPER_IMPL_H_

third_party/blink/public/platform/web_media_player_client.h

@@ -31,199 +31,31 @@
 #ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_MEDIA_PLAYER_CLIENT_H_
 #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_MEDIA_PLAYER_CLIENT_H_
 
-#include <memory>
-
-#include "base/time/time.h"
-#include "third_party/blink/public/common/media/display_type.h"
 #include "third_party/blink/public/platform/web_common.h"
-#include "third_party/blink/public/platform/web_media_player.h"
-#include "ui/gfx/color_space.h"
-
-namespace cc {
-class Layer;
-}
 
 namespace media {
-enum class MediaContentType;
-enum class VideoCodec;
-enum class AudioCodec;
-class MediaTrack;
+class RemotePlaybackClientWrapper;
 }  // namespace media
 
 namespace blink {
 
-class WebMediaSource;
-class WebRemotePlaybackClient;
-
 class BLINK_PLATFORM_EXPORT WebMediaPlayerClient {
  public:
-  enum VideoTrackKind {
-    kVideoTrackKindNone,
-    kVideoTrackKindAlternative,
-    kVideoTrackKindCaptions,
-    kVideoTrackKindMain,
-    kVideoTrackKindSign,
-    kVideoTrackKindSubtitles,
-    kVideoTrackKindCommentary
-  };
-
-  enum AudioTrackKind {
-    kAudioTrackKindNone,
-    kAudioTrackKindAlternative,
-    kAudioTrackKindDescriptions,
-    kAudioTrackKindMain,
-    kAudioTrackKindMainDescriptions,
-    kAudioTrackKindTranslation,
-    kAudioTrackKindCommentary
-  };
-
-  // Reason for a PausePlayback call, for better diagnostic messages.
-  enum class PauseReason {
-    kUnknown,
-    kPageHidden,
-    kSuspendedPlayerIdleTimeout,
-    kRemotePlayStateChange,
-    kFrameHidden,
-  };
-
-  static const int kMediaRemotingStopNoText = -1;
-
-  virtual void NetworkStateChanged() = 0;
-  virtual void ReadyStateChanged() = 0;
-  virtual void TimeChanged() = 0;
-  virtual void Repaint() = 0;
-  virtual void DurationChanged() = 0;
-  virtual void SizeChanged() = 0;
-  virtual void SetCcLayer(cc::Layer*) = 0;
-
-  virtual void AddMediaTrack(const media::MediaTrack&) = 0;
-  virtual void RemoveMediaTrack(const media::MediaTrack&) = 0;
-
-  virtual void MediaSourceOpened(std::unique_ptr<WebMediaSource>) = 0;
-  virtual void RemotePlaybackCompatibilityChanged(const WebURL&,
-                                                  bool is_compatible) = 0;
-
-  // Returns whether the media element has always been muted. This is used to
-  // avoid take audio focus for elements that the user is not aware is playing.
-  virtual bool WasAlwaysMuted() = 0;
-
-  // Returns if there's a selected video track.
-  virtual bool HasSelectedVideoTrack() = 0;
-
-  // Returns the selected video track id (or an empty id if there's none).
-  virtual WebMediaPlayer::TrackId GetSelectedVideoTrackId() = 0;
-
-  // Informs that media starts being rendered and played back remotely.
-  // |remote_device_friendly_name| will be shown in the remoting UI to indicate
-  // which device the content is rendered on. An empty name indicates an unknown
-  // remote device. A default message will be shown in this case.
-  virtual void MediaRemotingStarted(
-      const WebString& remote_device_friendly_name) = 0;
-
-  // Informs that media stops being rendered remotely. |error_code| corresponds
-  // to a localized string that explains the reason as user-readable text.
-  // |error_code| should be IDS_FOO or kMediaRemotingStopNoText.
-  virtual void MediaRemotingStopped(int error_code) = 0;
-
-  // Returns whether the media element has native controls. It does not mean
-  // that the controls are currently visible.
-  virtual bool HasNativeControls() = 0;
-
-  // Returns true iff the client represents an HTML <audio> element.
-  virtual bool IsAudioElement() = 0;
-
-  // Returns the current display type of the media element.
-  virtual DisplayType GetDisplayType() const = 0;
-
   // Returns the remote playback client associated with the media element, if
   // any.
-  virtual WebRemotePlaybackClient* RemotePlaybackClient() { return nullptr; }
-
-  // Returns the color space to render media into if.
-  // Rendering media into this color space may avoid some conversions.
-  virtual gfx::ColorSpace TargetColorSpace() { return gfx::ColorSpace(); }
-
-  // Returns whether the media element was initiated via autoplay.
-  // In this context, autoplay means that it was initiated before any user
-  // activation was received on the page and before a user initiated same-domain
-  // navigation. In other words, with the unified autoplay policy applied, it
-  // should only return `true` when MEI allowed autoplay.
-  virtual bool WasAutoplayInitiated() { return false; }
-
-  // Returns true if playback would start if the ready state was at least
-  // WebMediaPlayer::kReadyStateHaveFutureData.
-  virtual bool CouldPlayIfEnoughData() const = 0;
-
-  // Returns whether the playback is in auto-pip mode which does not have th
-  // behavior as regular Picture-in-Picture.
-  virtual bool IsInAutoPIP() const = 0;
-
-  // Requests the player to resume playback.
-  virtual void ResumePlayback() = 0;
-
-  // Request the player to pause playback.
-  virtual void PausePlayback(PauseReason) = 0;
-
-  // Notify the client that the media player started playing content.
-  virtual void DidPlayerStartPlaying() = 0;
-
-  // Notify the client that the media player stopped playing content, indicating
-  // in |stream_ended| if playback has reached the end of the stream.
-  virtual void DidPlayerPaused(bool stream_ended) = 0;
-
-  // Notify the client that the muted status of the media player has changed.
-  virtual void DidPlayerMutedStatusChange(bool muted) = 0;
-
-  // Notify the client that the media metadata of the media player has changed.
-  virtual void DidMediaMetadataChange(
-      bool has_audio,
-      bool has_video,
-      media::AudioCodec audio_codec,
-      media::VideoCodec video_codec,
-      media::MediaContentType media_content_type,
-      bool is_encrypted_media) = 0;
-
-  // Notify the client that the playback position has changed.
-  virtual void DidPlayerMediaPositionStateChange(double playback_rate,
-                                                 base::TimeDelta duration,
-                                                 base::TimeDelta position,
-                                                 bool end_of_media) = 0;
-
-  // Notify the client that the audio sink cannot be changed.
-  virtual void DidDisableAudioOutputSinkChanges() = 0;
-
-  // Notify the client that the playback starts/stops to use AudioService.
-  virtual void DidUseAudioServiceChange(bool uses_audio_service) = 0;
-
-  // Notify the client that the size of the media player has changed.
-  // TODO(crbug.com/1039252): Remove by merging this method into SizeChanged().
-  virtual void DidPlayerSizeChange(const gfx::Size& size) = 0;
-
-  virtual void OnFirstFrame(base::TimeTicks first_frame,
-                            size_t bytes_to_first_frame) = 0;
-
-  // Notify the client that one of the state used by Picture-in-Picture has
-  // changed. The client will then have to poll the states from the associated
-  // WebMediaPlayer.
-  // The states are:
-  //  - Delegate ID;
-  //  - Surface ID;
-  //  - Natural Size.
-  virtual void OnPictureInPictureStateChange() = 0;
-
-  // Called when a video frame has been presented to the compositor, after a
-  // request was initiated via WebMediaPlayer::RequestVideoFrameCallback().
-  // See https://wicg.github.io/video-rvfc/.
-  virtual void OnRequestVideoFrameCallback() {}
-
-  // Notify the client that the RemotePlayback has been disabled/enabled.
-  virtual void OnRemotePlaybackDisabled(bool disabled) = 0;
+  virtual media::RemotePlaybackClientWrapper* RemotePlaybackClientWrapper() {
+    return nullptr;
+  }
 
   // Returns the DOMNodeId of the DOM element hosting this media player.
   virtual int GetElementId() = 0;
 
  protected:
   ~WebMediaPlayerClient() = default;
+
+ private:
+  friend class MediaPlayerClient;
+  WebMediaPlayerClient() = default;
 };
 
 }  // namespace blink

third_party/blink/public/web/modules/media/web_media_player_util.h

@@ -1,49 +0,0 @@
-// Copyright 2013 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIA_WEB_MEDIA_PLAYER_UTIL_H_
-#define THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIA_WEB_MEDIA_PLAYER_UTIL_H_
-
-#include "base/time/time.h"
-#include "media/base/audio_renderer_sink.h"
-#include "media/base/eme_constants.h"
-#include "media/base/pipeline_status.h"
-#include "media/base/ranges.h"
-#include "media/mojo/mojom/media_metrics_provider.mojom-shared.h"
-#include "third_party/blink/public/platform/web_common.h"
-#include "third_party/blink/public/platform/web_encrypted_media_types.h"
-#include "third_party/blink/public/platform/web_media_player.h"
-#include "third_party/blink/public/platform/web_security_origin.h"
-#include "third_party/blink/public/platform/web_set_sink_id_callbacks.h"
-#include "third_party/blink/public/platform/web_time_range.h"
-
-namespace media {
-class MediaLog;
-}  // namespace media
-
-namespace blink {
-
-// Translates a |url| into the appropriate URL scheme.
-BLINK_MODULES_EXPORT media::mojom::MediaURLScheme GetMediaURLScheme(
-    const WebURL& url);
-
-BLINK_MODULES_EXPORT WebTimeRanges
-ConvertToWebTimeRanges(const media::Ranges<base::TimeDelta>& ranges);
-
-BLINK_MODULES_EXPORT WebMediaPlayer::NetworkState PipelineErrorToNetworkState(
-    media::PipelineStatus error);
-
-// Report various metrics to UMA.
-BLINK_MODULES_EXPORT void ReportMetrics(WebMediaPlayer::LoadType load_type,
-                                        const WebURL& url,
-                                        media::MediaLog* media_log);
-
-// Wraps a WebSetSinkIdCompleteCallback into a
-// media::OutputDeviceStatusCB and binds it to the current thread
-BLINK_MODULES_EXPORT media::OutputDeviceStatusCB ConvertToOutputDeviceStatusCB(
-    WebSetSinkIdCompleteCallback completion_callback);
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIA_WEB_MEDIA_PLAYER_UTIL_H_

third_party/blink/public/web/modules/mediastream/web_media_player_ms.h

@@ -41,6 +41,7 @@ using CreateSurfaceLayerBridgeCB =
         WebSurfaceLayerBridgeObserver*,
         cc::UpdateSubmissionStateCB)>;
 
+class MediaPlayerClient;
 class MediaStreamAudioRenderer;
 class MediaStreamInternalFrameWrapper;
 class MediaStreamRendererFactory;
@@ -49,10 +50,10 @@ template <typename TimerFiredClass>
 class TaskRunnerTimer;
 class TimerBase;
 class WebLocalFrame;
-class WebMediaPlayerClient;
 class WebMediaPlayerMSCompositor;
 class WebString;
 class WebVideoFrameSubmitter;
+class WebMediaPlayerClient;
 
 // WebMediaPlayerMS delegates calls from WebCore::MediaPlayerPrivate to
 // Chrome's media player when "src" is from media stream.
@@ -65,7 +66,7 @@ class WebVideoFrameSubmitter;
 // MediaStreamVideoRenderer
 //   provides video frames for rendering.
 //
-// WebMediaPlayerClient
+// MediaPlayerClient
 //   WebKit client of this media player object.
 class BLINK_MODULES_EXPORT WebMediaPlayerMS
     : public WebMediaStreamObserver,
@@ -238,7 +239,7 @@ class BLINK_MODULES_EXPORT WebMediaPlayerMS
   void SetReadyState(WebMediaPlayer::ReadyState state);
 
   // Getter method to |client_|.
-  WebMediaPlayerClient* get_client() { return client_; }
+  MediaPlayerClient* get_client() { return client_; }
 
   // To be run when tracks are added or removed.
   void Reload();
@@ -275,7 +276,7 @@ class BLINK_MODULES_EXPORT WebMediaPlayerMS
 
   const WebTimeRanges buffered_;
 
-  const raw_ptr<WebMediaPlayerClient> client_;
+  const raw_ptr<MediaPlayerClient> client_;
 
   // WebMediaPlayer notifies the |delegate_| of playback state changes using
   // |delegate_id_|; an id provided after registering with the delegate.  The

third_party/blink/public/web/web_local_frame_client.h

@@ -40,6 +40,7 @@
 #include "base/notreached.h"
 #include "base/unguessable_token.h"
 #include "media/base/audio_processing.h"
+#include "media/base/output_device_info.h"
 #include "media/base/speech_recognition_client.h"
 #include "media/mojo/mojom/audio_processing.mojom-shared.h"
 #include "services/metrics/public/cpp/ukm_source_id.h"
@@ -718,12 +719,12 @@ class BLINK_EXPORT WebLocalFrameClient {
 
   // Audio Output Devices API --------------------------------------------
 
-  // Checks that the given audio sink exists and is authorized. The result is
-  // provided via the callbacks.
-  virtual void CheckIfAudioSinkExistsAndIsAuthorized(
-      const WebString& sink_id,
-      WebSetSinkIdCompleteCallback callback) {
-    std::move(callback).Run(WebSetSinkIdError::kNotSupported);
+  // Checks that the given audio sink exists and is authorized. This is mainly
+  // used as a testing hook, if std::nullopt is returned it will fall back
+  // checking that a sink exists.
+  virtual std::optional<media::OutputDeviceStatus>
+  CheckIfAudioSinkExistsAndIsAuthorized(const WebString& sink_id) {
+    return std::nullopt;
   }
 
   // Visibility ----------------------------------------------------------

third_party/blink/renderer/core/core_initializer.h

@@ -60,6 +60,7 @@ class LocalFrame;
 class MediaControls;
 class Page;
 class PictureInPictureController;
+class RemotePlaybackClient;
 class ServiceWorkerGlobalScope;
 class Settings;
 class ShadowRoot;
@@ -67,7 +68,6 @@ class WebLocalFrameClient;
 class WebMediaPlayer;
 class WebMediaPlayerClient;
 class WebMediaPlayerSource;
-class WebRemotePlaybackClient;
 
 class CORE_EXPORT CoreInitializer {
   USING_FAST_MALLOC(CoreInitializer);
@@ -121,7 +121,7 @@ class CORE_EXPORT CoreInitializer {
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) const = 0;
 
-  virtual WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
+  virtual RemotePlaybackClient* CreateRemotePlaybackClient(
       HTMLMediaElement&) const = 0;
 
   virtual void ProvideModulesToPage(Page&,

third_party/blink/renderer/core/exported/web_media_player_impl_unittest.cc

@@ -61,7 +61,6 @@
 #include "third_party/blink/public/platform/media/web_media_player_delegate.h"
 #include "third_party/blink/public/platform/web_fullscreen_video_status.h"
 #include "third_party/blink/public/platform/web_media_player.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_encrypted_media_client.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
 #include "third_party/blink/public/platform/web_security_origin.h"
@@ -74,6 +73,7 @@
 #include "third_party/blink/public/web/web_widget.h"
 #include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
 #include "third_party/blink/renderer/platform/media/buffered_data_source_host_impl.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/media/power_status_helper.h"
 #include "third_party/blink/renderer/platform/media/resource_multi_buffer_data_provider.h"
 #include "third_party/blink/renderer/platform/media/testing/mock_resource_fetch_context.h"
@@ -151,7 +151,7 @@ class MockMediaObserver : public media::MediaObserver {
   base::WeakPtrFactory<MediaObserver> weak_ptr_factory_{this};
 };
 
-class MockWebMediaPlayerClient : public WebMediaPlayerClient {
+class MockWebMediaPlayerClient : public MediaPlayerClient {
  public:
   MockWebMediaPlayerClient() = default;
 
@@ -168,7 +168,7 @@ class MockWebMediaPlayerClient : public WebMediaPlayerClient {
   MOCK_METHOD1(AddMediaTrack, void(const media::MediaTrack& track));
   MOCK_METHOD1(RemoveMediaTrack, void(const media::MediaTrack&));
   MOCK_METHOD1(MediaSourceOpened, void(std::unique_ptr<WebMediaSource>));
-  MOCK_METHOD2(RemotePlaybackCompatibilityChanged, void(const WebURL&, bool));
+  MOCK_METHOD2(RemotePlaybackCompatibilityChanged, void(const KURL&, bool));
   MOCK_METHOD0(WasAlwaysMuted, bool());
   MOCK_METHOD0(HasSelectedVideoTrack, bool());
   MOCK_METHOD0(GetSelectedVideoTrackId, WebMediaPlayer::TrackId());
@@ -182,7 +182,7 @@ class MockWebMediaPlayerClient : public WebMediaPlayerClient {
   MOCK_METHOD0(OnPictureInPictureStateChange, void());
   MOCK_CONST_METHOD0(CouldPlayIfEnoughData, bool());
   MOCK_METHOD0(ResumePlayback, void());
-  MOCK_METHOD1(PausePlayback, void(WebMediaPlayerClient::PauseReason));
+  MOCK_METHOD1(PausePlayback, void(MediaPlayerClient::PauseReason));
   MOCK_METHOD0(DidPlayerStartPlaying, void());
   MOCK_METHOD1(DidPlayerPaused, void(bool));
   MOCK_METHOD1(DidPlayerMutedStatusChange, void(bool));
@@ -2384,10 +2384,9 @@ TEST_F(WebMediaPlayerImplTest, BackgroundIdlePauseTimerDependsOnAudio) {
   ScheduleIdlePauseTimer();
   EXPECT_TRUE(IsIdlePauseTimerRunning());
 
-  EXPECT_CALL(
-      client_,
-      PausePlayback(
-          WebMediaPlayerClient::PauseReason::kSuspendedPlayerIdleTimeout));
+  EXPECT_CALL(client_,
+              PausePlayback(
+                  MediaPlayerClient::PauseReason::kSuspendedPlayerIdleTimeout));
   FireIdlePauseTimer();
   base::RunLoop().RunUntilIdle();
 }

third_party/blink/renderer/core/frame/local_frame_client.h

@@ -99,6 +99,7 @@ class KURL;
 class LocalDOMWindow;
 class LocalFrame;
 class RemoteFrame;
+class RemotePlaybackClient;
 class ResourceError;
 class ResourceRequest;
 class ResourceResponse;
@@ -110,7 +111,6 @@ class WebMediaPlayer;
 class WebMediaPlayerClient;
 class WebMediaPlayerSource;
 class WebPluginContainerImpl;
-class WebRemotePlaybackClient;
 class WebServiceWorkerProvider;
 class WebSpellCheckPanelHostClient;
 class WebTextCheckClient;
@@ -287,7 +287,7 @@ class CORE_EXPORT LocalFrameClient : public FrameClient {
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) = 0;
-  virtual WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
+  virtual RemotePlaybackClient* CreateRemotePlaybackClient(
       HTMLMediaElement&) = 0;
 
   virtual void DidCommitDocumentReplacementNavigation(DocumentLoader*) = 0;

third_party/blink/renderer/core/frame/local_frame_client_impl.cc

@@ -994,9 +994,9 @@ std::unique_ptr<WebMediaPlayer> LocalFrameClientImpl::CreateWebMediaPlayer(
       web_frame->Client(), html_media_element, source, client);
 }
 
-WebRemotePlaybackClient* LocalFrameClientImpl::CreateWebRemotePlaybackClient(
+RemotePlaybackClient* LocalFrameClientImpl::CreateRemotePlaybackClient(
     HTMLMediaElement& html_media_element) {
-  return CoreInitializer::GetInstance().CreateWebRemotePlaybackClient(
+  return CoreInitializer::GetInstance().CreateRemotePlaybackClient(
       html_media_element);
 }
 

third_party/blink/renderer/core/frame/local_frame_client_impl.h

@@ -200,8 +200,7 @@ class CORE_EXPORT LocalFrameClientImpl final : public LocalFrameClient {
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override;
-  WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
-      HTMLMediaElement&) override;
+  RemotePlaybackClient* CreateRemotePlaybackClient(HTMLMediaElement&) override;
   void DidChangeScrollOffset() override;
   void NotifyCurrentHistoryItemChanged() override;
   void DidUpdateCurrentHistoryItem() override;

third_party/blink/renderer/core/html/media/DEPS

@@ -4,6 +4,7 @@ include_rules = [
     "+media/base/media_switches.h",
     "+media/base/video_frame.h",
     "+media/base/media_track.h",
+    "+media/renderers/remote_playback_client_wrapper.h",
     "+media/mojo/mojom/media_player.mojom-blink.h",
     "+services/media_session/public/mojom/media_session.mojom-blink.h",
 ]

third_party/blink/renderer/core/html/media/html_media_element.cc

@@ -49,7 +49,6 @@
 #include "third_party/blink/public/common/privacy_budget/identifiable_surface.h"
 #include "third_party/blink/public/mojom/frame/user_activation_notification_type.mojom-shared.h"
 #include "third_party/blink/public/platform/modules/mediastream/web_media_stream.h"
-#include "third_party/blink/public/platform/modules/remoteplayback/web_remote_playback_client.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/public/platform/web_media_player.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
@@ -109,6 +108,7 @@
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
 #include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
+#include "third_party/blink/renderer/platform/media/remote_playback_client.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_descriptor.h"
 #include "third_party/blink/renderer/platform/network/mime/content_type.h"
 #include "third_party/blink/renderer/platform/network/mime/mime_type_from_url.h"
@@ -442,7 +442,6 @@ HTMLMediaElement::HTMLMediaElement(const QualifiedName& tag_name,
       audio_source_node_(nullptr),
       speech_synthesis_(nullptr),
       autoplay_policy_(MakeGarbageCollected<AutoplayPolicy>(this)),
-      remote_playback_client_(nullptr),
       media_controls_(nullptr),
       controls_list_(MakeGarbageCollected<HTMLMediaElementControlsList>(this)),
       lazy_load_intersection_observer_(nullptr) {
@@ -453,7 +452,7 @@ HTMLMediaElement::HTMLMediaElement(const QualifiedName& tag_name,
   LocalFrame* frame = document.GetFrame();
   if (frame) {
     remote_playback_client_ =
-        frame->Client()->CreateWebRemotePlaybackClient(*this);
+        frame->Client()->CreateRemotePlaybackClient(*this);
   }
 
   SetHasCustomStyleCallbacks();
@@ -3746,10 +3745,11 @@ void HTMLMediaElement::DurationChanged(double duration, bool request_seek) {
     Seek(duration);
 }
 
-void HTMLMediaElement::RemotePlaybackCompatibilityChanged(const WebURL& url,
+void HTMLMediaElement::RemotePlaybackCompatibilityChanged(const KURL& url,
                                                           bool is_compatible) {
-  if (RemotePlaybackClient())
-    RemotePlaybackClient()->SourceChanged(url, is_compatible);
+  if (remote_playback_client_) {
+    remote_playback_client_->SourceChanged(url, is_compatible);
+  }
 }
 
 bool HTMLMediaElement::HasSelectedVideoTrack() {
@@ -4958,6 +4958,18 @@ void HTMLMediaElement::OnRemotePlaybackMetadataChange() {
   }
 }
 
+std::string HTMLMediaElement::GetActivePresentationId() {
+  if (!remote_playback_client_) {
+    return std::string();
+  }
+
+  // The presentation ID is essentially a GUID preceded by the "mr_" prefix,
+  // which makes it ASCII compatible.
+  // If MediaRouterBase::CreatePresentationId() were changed, this line might
+  // need to be updated.
+  return remote_playback_client_->GetPresentationId().Ascii();
+}
+
 HTMLMediaElement::OpenerContextObserver::OpenerContextObserver(
     HTMLMediaElement* element)
     : element_(element) {}

third_party/blink/renderer/core/html/media/html_media_element.h

@@ -35,10 +35,10 @@
 #include "base/time/time.h"
 #include "base/timer/elapsed_timer.h"
 #include "media/mojo/mojom/media_player.mojom-blink.h"
+#include "media/renderers/remote_playback_client_wrapper.h"
 #include "third_party/abseil-cpp/absl/types/variant.h"
 #include "third_party/blink/public/common/media/display_type.h"
 #include "third_party/blink/public/platform/web_audio_source_provider_impl.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/core/core_export.h"
@@ -52,6 +52,7 @@
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/heap/disallow_new_wrapper.h"
 #include "third_party/blink/renderer/platform/heap/prefinalizer.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/media/web_audio_source_provider_client.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_receiver_set.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_remote.h"
@@ -91,6 +92,7 @@ class MediaSourceAttachment;
 class MediaSourceHandle;
 class MediaSourceTracer;
 class MediaStreamDescriptor;
+class RemotePlaybackClient;
 class ScriptPromiseResolverBase;
 class ScriptState;
 class TextTrack;
@@ -101,7 +103,6 @@ class VideoTrack;
 class VideoTrackList;
 class V8CanPlayTypeResult;
 class V8TextTrackKind;
-class WebRemotePlaybackClient;
 
 class CORE_EXPORT HTMLMediaElement
     : public HTMLElement,
@@ -109,7 +110,8 @@ class CORE_EXPORT HTMLMediaElement
       public ActiveScriptWrappable<HTMLMediaElement>,
       public ExecutionContextLifecycleStateObserver,
       public media::mojom::blink::MediaPlayer,
-      private WebMediaPlayerClient {
+      public media::RemotePlaybackClientWrapper,
+      private MediaPlayerClient {
   DEFINE_WRAPPERTYPEINFO();
   USING_PRE_FINALIZER(HTMLMediaElement, Dispose);
 
@@ -373,10 +375,6 @@ class CORE_EXPORT HTMLMediaElement
 
   void VideoWillBeDrawnToCanvas() const;
 
-  const WebRemotePlaybackClient* RemotePlaybackClient() const {
-    return remote_playback_client_;
-  }
-
   const AutoplayPolicy& GetAutoplayPolicy() const { return *autoplay_policy_; }
 
   WebMediaPlayer::LoadType GetLoadType() const;
@@ -419,6 +417,9 @@ class CORE_EXPORT HTMLMediaElement
   bool HandleCommandInternal(HTMLElement& invoker,
                              CommandEventType command) override;
 
+  // media::RemotePlaybackClientWrapper overrides:
+  std::string GetActivePresentationId() override;
+
  protected:
   // Assert the correct order of the children in shadow dom when DCHECK is on.
   static void AssertShadowRootChildren(ShadowRoot&);
@@ -552,7 +553,7 @@ class CORE_EXPORT HTMLMediaElement
   void RemoveMediaTrack(const media::MediaTrack&) final;
 
   void MediaSourceOpened(std::unique_ptr<WebMediaSource>) final;
-  void RemotePlaybackCompatibilityChanged(const WebURL&,
+  void RemotePlaybackCompatibilityChanged(const KURL&,
                                           bool is_compatible) final;
   bool HasSelectedVideoTrack() final;
   WebMediaPlayer::TrackId GetSelectedVideoTrackId() final;
@@ -560,8 +561,8 @@ class CORE_EXPORT HTMLMediaElement
   bool HasNativeControls() final;
   bool IsAudioElement() final;
   DisplayType GetDisplayType() const override;
-  WebRemotePlaybackClient* RemotePlaybackClient() final {
-    return remote_playback_client_;
+  media::RemotePlaybackClientWrapper* RemotePlaybackClientWrapper() final {
+    return this;
   }
   gfx::ColorSpace TargetColorSpace() override;
   bool WasAutoplayInitiated() override;
@@ -982,7 +983,7 @@ class CORE_EXPORT HTMLMediaElement
 
   Member<AutoplayPolicy> autoplay_policy_;
 
-  WebRemotePlaybackClient* remote_playback_client_;
+  RemotePlaybackClient* remote_playback_client_ = nullptr;
 
   Member<MediaControls> media_controls_;
   Member<HTMLMediaElementControlsList> controls_list_;

third_party/blink/renderer/core/html/media/html_media_element_event_listeners_test.cc

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/blink/renderer/core/html/media/html_media_element.h"
-
 #include <algorithm>
 #include <memory>
 
@@ -18,6 +16,7 @@
 #include "third_party/blink/renderer/core/execution_context/agent.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/fullscreen/fullscreen.h"
+#include "third_party/blink/renderer/core/html/media/html_media_element.h"
 #include "third_party/blink/renderer/core/html/media/html_video_element.h"
 #include "third_party/blink/renderer/core/html/media/media_controls.h"
 #include "third_party/blink/renderer/core/html/media/media_custom_controls_fullscreen_detector.h"
@@ -27,6 +26,7 @@
 #include "third_party/blink/renderer/core/loader/empty_clients.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 #include "third_party/blink/renderer/platform/heap/thread_state.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/scheduler/public/event_loop.h"
 #include "third_party/blink/renderer/platform/testing/empty_web_media_player.h"
 #include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
@@ -45,7 +45,9 @@ class FakeWebMediaPlayer final : public EmptyWebMediaPlayer {
   FakeWebMediaPlayer(WebMediaPlayerClient* client,
                      ExecutionContext* context,
                      double duration)
-      : client_(client), context_(context), duration_(duration) {}
+      : client_(static_cast<MediaPlayerClient*>(client)),
+        context_(context),
+        duration_(duration) {}
 
   MOCK_METHOD1(SetIsEffectivelyFullscreen,
                void(blink::WebFullscreenVideoStatus));
@@ -127,7 +129,7 @@ class FakeWebMediaPlayer final : public EmptyWebMediaPlayer {
     context_->GetAgent()->event_loop()->PerformMicrotaskCheckpoint();
   }
 
-  WebMediaPlayerClient* client_;
+  MediaPlayerClient* client_;
   WeakPersistent<ExecutionContext> context_;
   mutable double current_time_ = 0;
   bool playing_ = false;

third_party/blink/renderer/core/html/media/media_remoting_interstitial.cc

@@ -84,7 +84,7 @@ void MediaRemotingInterstitial::Hide(int error_code) {
     return;
   if (toggle_interstitial_timer_.IsActive())
     toggle_interstitial_timer_.Stop();
-  if (error_code == WebMediaPlayerClient::kMediaRemotingStopNoText) {
+  if (error_code == MediaPlayerClient::kMediaRemotingStopNoText) {
     state_ = kHidden;
   } else {
     String stop_text =

third_party/blink/renderer/core/html/media/video_wake_lock_test.cc

@@ -27,6 +27,7 @@
 #include "third_party/blink/renderer/core/html/media/html_video_element.h"
 #include "third_party/blink/renderer/core/testing/wait_for_event.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_descriptor.h"
 #include "third_party/blink/renderer/platform/testing/empty_web_media_player.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
@@ -148,12 +149,12 @@ class VideoWakeLockTestWebFrameClient
       const WebString& sink_id,
       const cc::LayerTreeSettings* settings,
       scoped_refptr<base::TaskRunner> compositor_worker_task_runner) override {
-    web_media_player_client_ = client;
+    media_player_client_ = static_cast<MediaPlayerClient*>(client);
     return std::move(web_media_player_);
   }
 
-  WebMediaPlayerClient* web_media_player_client() const {
-    return web_media_player_client_;
+  MediaPlayerClient* media_player_client() const {
+    return media_player_client_;
   }
 
   void SetWebMediaPlayer(std::unique_ptr<WebMediaPlayer> web_media_player) {
@@ -161,7 +162,7 @@ class VideoWakeLockTestWebFrameClient
   }
 
  private:
-  WebMediaPlayerClient* web_media_player_client_ = nullptr;
+  MediaPlayerClient* media_player_client_ = nullptr;
   std::unique_ptr<WebMediaPlayer> web_media_player_;
 };
 
@@ -206,8 +207,8 @@ class VideoWakeLockTest : public testing::Test {
   HTMLVideoElement* Video() const { return video_.Get(); }
   VideoWakeLock* GetVideoWakeLock() const { return video_wake_lock_.Get(); }
   VideoWakeLockMediaPlayer* GetMediaPlayer() const { return media_player_; }
-  WebMediaPlayerClient* GetMediaPlayerClient() const {
-    return client_->web_media_player_client();
+  MediaPlayerClient* GetMediaPlayerClient() const {
+    return client_->media_player_client();
   }
 
   LocalFrame& GetFrame() const { return *helper_.LocalMainFrame()->GetFrame(); }

third_party/blink/renderer/core/loader/empty_clients.cc

@@ -162,7 +162,7 @@ std::unique_ptr<WebMediaPlayer> EmptyLocalFrameClient::CreateWebMediaPlayer(
   return nullptr;
 }
 
-WebRemotePlaybackClient* EmptyLocalFrameClient::CreateWebRemotePlaybackClient(
+RemotePlaybackClient* EmptyLocalFrameClient::CreateRemotePlaybackClient(
     HTMLMediaElement&) {
   return nullptr;
 }

third_party/blink/renderer/core/loader/empty_clients.h

@@ -402,8 +402,7 @@ class CORE_EXPORT EmptyLocalFrameClient : public LocalFrameClient {
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override;
-  WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
-      HTMLMediaElement&) override;
+  RemotePlaybackClient* CreateRemotePlaybackClient(HTMLMediaElement&) override;
 
   void DidCommitDocumentReplacementNavigation(DocumentLoader*) override {}
   void DispatchDidClearWindowObjectInMainWorld(

third_party/blink/renderer/core/paint/video_painter_test.cc

@@ -16,6 +16,7 @@
 #include "third_party/blink/renderer/core/html/media/html_media_element.h"
 #include "third_party/blink/renderer/core/paint/paint_controller_paint_test.h"
 #include "third_party/blink/renderer/platform/heap/thread_state.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/testing/empty_web_media_player.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
@@ -65,7 +66,8 @@ size_t CountImagesOfType(const PaintRecord& record, cc::ImageType image_type) {
 
 class StubWebMediaPlayer : public EmptyWebMediaPlayer {
  public:
-  StubWebMediaPlayer(WebMediaPlayerClient* client) : client_(client) {}
+  explicit StubWebMediaPlayer(WebMediaPlayerClient* client)
+      : client_(static_cast<MediaPlayerClient*>(client)) {}
 
   const cc::Layer* GetCcLayer() { return layer_.get(); }
 
@@ -88,7 +90,7 @@ class StubWebMediaPlayer : public EmptyWebMediaPlayer {
   ReadyState GetReadyState() const override { return ready_state_; }
 
  private:
-  WebMediaPlayerClient* client_;
+  MediaPlayerClient* client_;
   scoped_refptr<cc::Layer> layer_;
   NetworkState network_state_ = kNetworkStateEmpty;
   ReadyState ready_state_ = kReadyStateHaveNothing;

third_party/blink/renderer/modules/audio_output_devices/html_media_element_audio_output_device.cc

@@ -10,6 +10,7 @@
 #include "base/functional/callback_helpers.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/public/platform/web_set_sink_id_callbacks.h"
+#include "third_party/blink/public/web/modules/media/audio/audio_device_factory.h"
 #include "third_party/blink/public/web/web_local_frame_client.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
@@ -19,6 +20,7 @@
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
 #include "third_party/blink/renderer/platform/heap/persistent.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
 
 namespace blink {
@@ -129,8 +131,18 @@ void SetSinkIdResolver::DoSetSinkId() {
   // This is associated with an HTML element, so the context must be a window.
   if (WebLocalFrameImpl* web_frame = WebLocalFrameImpl::FromFrame(
           To<LocalDOMWindow>(context)->GetFrame())) {
-    web_frame->Client()->CheckIfAudioSinkExistsAndIsAuthorized(
-        sink_id_, std::move(set_sink_id_completion_callback));
+    std::optional<media::OutputDeviceStatus> status =
+        web_frame->Client()->CheckIfAudioSinkExistsAndIsAuthorized(sink_id_);
+
+    if (!status.has_value()) {
+      status = AudioDeviceFactory::GetInstance()
+                   ->GetOutputDeviceInfo(web_frame->GetLocalFrameToken(),
+                                         sink_id_.Utf8())
+                   .device_status();
+    }
+    std::move(ConvertToOutputDeviceStatusCB(
+                  std::move(set_sink_id_completion_callback)))
+        .Run(status.value());
   } else {
     resolver_->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kSecurityError,

third_party/blink/renderer/modules/media/BUILD.gn

@@ -22,7 +22,6 @@ blink_modules_sources("media") {
     "audio/mojo_audio_input_ipc.h",
     "audio/mojo_audio_output_ipc.cc",
     "audio/mojo_audio_output_ipc.h",
-    "web_media_player_util.cc",
   ]
 
   deps = [

third_party/blink/renderer/modules/media/web_media_player_util.cc

@@ -1,148 +0,0 @@
-// Copyright 2013 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
-
-#include <math.h>
-#include <stddef.h>
-#include <string>
-#include <utility>
-
-#include "base/metrics/histogram_macros.h"
-#include "base/task/bind_post_task.h"
-#include "media/base/media_log.h"
-#include "third_party/blink/public/common/scheme_registry.h"
-#include "third_party/blink/public/platform/url_conversion.h"
-#include "third_party/blink/public/platform/web_media_player_encrypted_media_client.h"
-#include "third_party/blink/public/web/web_local_frame.h"
-#include "third_party/blink/renderer/platform/weborigin/kurl.h"
-#include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"
-#include "third_party/blink/renderer/platform/wtf/functional.h"
-
-namespace {
-
-void RunSetSinkIdCallback(blink::WebSetSinkIdCompleteCallback callback,
-                          media::OutputDeviceStatus result) {
-  switch (result) {
-    case media::OUTPUT_DEVICE_STATUS_OK:
-      std::move(callback).Run(/*error =*/std::nullopt);
-      break;
-    case media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND:
-      std::move(callback).Run(blink::WebSetSinkIdError::kNotFound);
-      break;
-    case media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED:
-      std::move(callback).Run(blink::WebSetSinkIdError::kNotAuthorized);
-      break;
-    case media::OUTPUT_DEVICE_STATUS_ERROR_TIMED_OUT:
-    case media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL:
-      std::move(callback).Run(blink::WebSetSinkIdError::kAborted);
-      break;
-  }
-}
-
-}  // namespace
-
-namespace blink {
-
-media::mojom::MediaURLScheme GetMediaURLScheme(const WebURL& url) {
-  if (!url.GetParsed().scheme.is_valid())
-    return media::mojom::MediaURLScheme::kMissing;
-  if (url.ProtocolIs(url::kHttpScheme))
-    return media::mojom::MediaURLScheme::kHttp;
-  if (url.ProtocolIs(url::kHttpsScheme))
-    return media::mojom::MediaURLScheme::kHttps;
-  if (url.ProtocolIs(url::kFtpScheme))
-    return media::mojom::MediaURLScheme::kFtp;
-  if (url.ProtocolIs(url::kJavaScriptScheme))
-    return media::mojom::MediaURLScheme::kJavascript;
-  if (url.ProtocolIs(url::kFileScheme))
-    return media::mojom::MediaURLScheme::kFile;
-  if (url.ProtocolIs(url::kBlobScheme))
-    return media::mojom::MediaURLScheme::kBlob;
-  if (url.ProtocolIs(url::kDataScheme))
-    return media::mojom::MediaURLScheme::kData;
-  if (url.ProtocolIs(url::kFileSystemScheme))
-    return media::mojom::MediaURLScheme::kFileSystem;
-  if (url.ProtocolIs(url::kContentScheme))
-    return media::mojom::MediaURLScheme::kContent;
-  if (url.ProtocolIs(url::kContentIDScheme))
-    return media::mojom::MediaURLScheme::kContentId;
-
-  // Some internals pages and extension pages play media.
-  KURL kurl(url);
-  if (SchemeRegistry::IsWebUIScheme(kurl.Protocol()))
-    return media::mojom::MediaURLScheme::kChrome;
-  if (CommonSchemeRegistry::IsExtensionScheme(kurl.Protocol().Ascii()))
-    return media::mojom::MediaURLScheme::kChromeExtension;
-
-  return media::mojom::MediaURLScheme::kUnknown;
-}
-
-WebTimeRanges ConvertToWebTimeRanges(
-    const media::Ranges<base::TimeDelta>& ranges) {
-  WebTimeRanges result(ranges.size());
-  for (size_t i = 0; i < ranges.size(); ++i) {
-    result[i].start = ranges.start(i).InSecondsF();
-    result[i].end = ranges.end(i).InSecondsF();
-  }
-  return result;
-}
-
-WebMediaPlayer::NetworkState PipelineErrorToNetworkState(
-    media::PipelineStatus error) {
-  switch (error.code()) {
-    case media::PIPELINE_ERROR_NETWORK:
-    case media::PIPELINE_ERROR_READ:
-    case media::CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR:
-      return WebMediaPlayer::kNetworkStateNetworkError;
-
-    case media::PIPELINE_ERROR_INITIALIZATION_FAILED:
-    case media::PIPELINE_ERROR_COULD_NOT_RENDER:
-    case media::PIPELINE_ERROR_EXTERNAL_RENDERER_FAILED:
-    case media::DEMUXER_ERROR_COULD_NOT_OPEN:
-    case media::DEMUXER_ERROR_COULD_NOT_PARSE:
-    case media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS:
-    case media::DEMUXER_ERROR_DETECTED_HLS:
-    case media::DECODER_ERROR_NOT_SUPPORTED:
-      return WebMediaPlayer::kNetworkStateFormatError;
-
-    case media::PIPELINE_ERROR_DECODE:
-    case media::PIPELINE_ERROR_ABORT:
-    case media::PIPELINE_ERROR_INVALID_STATE:
-    case media::PIPELINE_ERROR_HARDWARE_CONTEXT_RESET:
-    case media::PIPELINE_ERROR_DISCONNECTED:
-    case media::CHUNK_DEMUXER_ERROR_APPEND_FAILED:
-    case media::CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR:
-    case media::AUDIO_RENDERER_ERROR:
-      return WebMediaPlayer::kNetworkStateDecodeError;
-
-    case media::PIPELINE_OK:
-      NOTREACHED_IN_MIGRATION() << "Unexpected status! " << error;
-  }
-  return WebMediaPlayer::kNetworkStateFormatError;
-}
-
-void ReportMetrics(WebMediaPlayer::LoadType load_type,
-                   const WebURL& url,
-                   media::MediaLog* media_log) {
-  DCHECK(media_log);
-
-  // Report URL scheme, such as http, https, file, blob etc. Only do this for
-  // URL based loads, otherwise it's not very useful.
-  if (load_type == WebMediaPlayer::kLoadTypeURL) {
-    UMA_HISTOGRAM_ENUMERATION("Media.URLScheme2", GetMediaURLScheme(url));
-  }
-
-  // Report load type, such as URL, MediaSource or MediaStream.
-  UMA_HISTOGRAM_ENUMERATION("Media.LoadType", load_type,
-                            WebMediaPlayer::kLoadTypeMax + 1);
-}
-
-media::OutputDeviceStatusCB ConvertToOutputDeviceStatusCB(
-    WebSetSinkIdCompleteCallback callback) {
-  return base::BindPostTaskToCurrentDefault(
-      WTF::BindOnce(RunSetSinkIdCallback, std::move(callback)));
-}
-
-}  // namespace blink

third_party/blink/renderer/modules/media/web_media_player_util_unittest.cc

@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
-
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/scheme_registry.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
 #include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"

third_party/blink/renderer/modules/media_controls/media_controls_impl_test.cc

@@ -12,7 +12,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/input/web_mouse_event.h"
 #include "third_party/blink/public/mojom/input/focus_type.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/remoteplayback/web_remote_playback_client.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_gc_controller.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_pointer_event_init.h"
 #include "third_party/blink/renderer/core/css/css_property_value_set.h"
@@ -52,6 +51,7 @@
 #include "third_party/blink/renderer/modules/remoteplayback/remote_playback.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
 #include "third_party/blink/renderer/platform/heap/thread_state.h"
+#include "third_party/blink/renderer/platform/media/remote_playback_client.h"
 #include "third_party/blink/renderer/platform/testing/empty_web_media_player.h"
 #include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
@@ -103,7 +103,7 @@ class StubLocalFrameClientForImpl : public EmptyLocalFrameClient {
     return std::make_unique<MockWebMediaPlayerForImpl>();
   }
 
-  WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
+  RemotePlaybackClient* CreateRemotePlaybackClient(
       HTMLMediaElement& element) override {
     return &RemotePlayback::From(element);
   }

third_party/blink/renderer/modules/mediastream/web_media_player_ms.cc

@@ -37,10 +37,8 @@
 #include "third_party/blink/public/platform/modules/webrtc/webrtc_logging.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/url_conversion.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
 #include "third_party/blink/public/platform/web_surface_layer_bridge.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream_audio_renderer.h"
@@ -48,6 +46,8 @@
 #include "third_party/blink/renderer/modules/mediastream/media_stream_renderer_factory.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream_video_renderer.h"
 #include "third_party/blink/renderer/modules/mediastream/web_media_player_ms_compositor.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_audio_track.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_descriptor.h"
@@ -360,7 +360,7 @@ WebMediaPlayerMS::WebMediaPlayerMS(
       network_state_(WebMediaPlayer::kNetworkStateEmpty),
       ready_state_(WebMediaPlayer::kReadyStateHaveNothing),
       buffered_(static_cast<size_t>(0)),
-      client_(client),
+      client_(static_cast<MediaPlayerClient*>(client)),
       delegate_(delegate),
       delegate_id_(0),
       paused_(true),
@@ -390,7 +390,7 @@ WebMediaPlayerMS::WebMediaPlayerMS(
   delegate_id_ = delegate_->AddObserver(this);
   SendLogMessage(String::Format(
       "%s({delegate_id=%d}, {is_audio_element=%s}, {sink_id=%s})", __func__,
-      delegate_id_, client->IsAudioElement() ? "true" : "false",
+      delegate_id_, client_->IsAudioElement() ? "true" : "false",
       sink_id.Utf8().c_str()));
 
   // TODO(tmathmeyer) WebMediaPlayerImpl gets the URL from the WebLocalFrame.

third_party/blink/renderer/modules/mediastream/web_media_player_ms_test.cc

@@ -32,12 +32,12 @@
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/public/platform/web_fullscreen_video_status.h"
 #include "third_party/blink/public/platform/web_media_player.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream_audio_renderer.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream_renderer_factory.h"
 #include "third_party/blink/renderer/modules/mediastream/web_media_player_ms_compositor.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_copier_base.h"
@@ -525,7 +525,7 @@ class WebMediaPlayerMSTest
           testing::tuple<bool /* enable_surface_layer_for_video */,
                          bool /* opaque_frame */,
                          bool /* odd_size_frame */>>,
-      public WebMediaPlayerClient,
+      public MediaPlayerClient,
       public cc::VideoFrameProvider::Client {
  public:
   WebMediaPlayerMSTest()
@@ -566,7 +566,7 @@ class WebMediaPlayerMSTest
   void AddMediaTrack(const media::MediaTrack& track) override {}
 
   void MediaSourceOpened(std::unique_ptr<WebMediaSource>) override {}
-  void RemotePlaybackCompatibilityChanged(const WebURL& url,
+  void RemotePlaybackCompatibilityChanged(const KURL& url,
                                           bool is_compatible) override {}
   bool WasAlwaysMuted() override { return false; }
   bool HasSelectedVideoTrack() override { return false; }

third_party/blink/renderer/modules/modules_initializer.cc

@@ -363,7 +363,7 @@ std::unique_ptr<WebMediaPlayer> ModulesInitializer::CreateWebMediaPlayer(
       base::ThreadPool::CreateTaskRunner(base::TaskTraits{}));
 }
 
-WebRemotePlaybackClient* ModulesInitializer::CreateWebRemotePlaybackClient(
+RemotePlaybackClient* ModulesInitializer::CreateRemotePlaybackClient(
     HTMLMediaElement& html_media_element) const {
   return &RemotePlayback::From(html_media_element);
 }

third_party/blink/renderer/modules/modules_initializer.h

@@ -36,7 +36,7 @@ class MODULES_EXPORT ModulesInitializer : public CoreInitializer {
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) const override;
-  WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
+  RemotePlaybackClient* CreateRemotePlaybackClient(
       HTMLMediaElement&) const override;
 
   void ProvideModulesToPage(Page&,

third_party/blink/renderer/modules/remoteplayback/remote_playback.cc

@@ -62,7 +62,7 @@ void RunRemotePlaybackTask(
   std::move(task).Run();
 }
 
-KURL GetAvailabilityUrl(const WebURL& source,
+KURL GetAvailabilityUrl(const KURL& source,
                         bool is_source_supported,
                         std::optional<media::VideoCodec> video_codec,
                         std::optional<media::AudioCodec> audio_codec) {
@@ -409,7 +409,7 @@ void RemotePlayback::StateChanged(
     if (auto* video_element =
             DynamicTo<HTMLVideoElement>(media_element_.Get())) {
       video_element->MediaRemotingStopped(
-          WebMediaPlayerClient::kMediaRemotingStopNoText);
+          MediaPlayerClient::kMediaRemotingStopNoText);
     }
     CleanupConnections();
     presentation_id_ = "";
@@ -439,7 +439,7 @@ void RemotePlayback::PromptCancelled() {
   prompt_promise_resolver_ = nullptr;
 }
 
-void RemotePlayback::SourceChanged(const WebURL& source,
+void RemotePlayback::SourceChanged(const KURL& source,
                                    bool is_source_supported) {
   source_ = source;
   is_source_supported_ = is_source_supported;
@@ -489,7 +489,7 @@ void RemotePlayback::UpdateAvailabilityUrlsAndStartListening() {
   MaybeStartListeningForAvailability();
 }
 
-WebString RemotePlayback::GetPresentationId() {
+String RemotePlayback::GetPresentationId() {
   return presentation_id_;
 }
 

third_party/blink/renderer/modules/remoteplayback/remote_playback.h

@@ -6,7 +6,6 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_REMOTEPLAYBACK_REMOTE_PLAYBACK_H_
 
 #include "third_party/blink/public/mojom/presentation/presentation.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/remoteplayback/web_remote_playback_client.h"
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
@@ -20,6 +19,7 @@
 #include "third_party/blink/renderer/platform/heap/collection_support/heap_hash_map.h"
 #include "third_party/blink/renderer/platform/heap/collection_support/heap_hash_set.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
+#include "third_party/blink/renderer/platform/media/remote_playback_client.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_receiver.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_remote.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_wrapper_mode.h"
@@ -50,7 +50,7 @@ class MODULES_EXPORT RemotePlayback final
     : public EventTarget,
       public ExecutionContextLifecycleObserver,
       public ActiveScriptWrappable<RemotePlayback>,
-      public WebRemotePlaybackClient,
+      public RemotePlaybackClient,
       public PresentationAvailabilityObserver,
       public mojom::blink::PresentationConnection,
       public RemotePlaybackController {
@@ -126,10 +126,10 @@ class MODULES_EXPORT RemotePlayback final
   void DidChangeState(mojom::blink::PresentationConnectionState) override;
   void DidClose(mojom::blink::PresentationConnectionCloseReason) override;
 
-  // WebRemotePlaybackClient implementation.
+  // RemotePlaybackClient implementation.
   bool RemotePlaybackAvailable() const override;
-  void SourceChanged(const WebURL&, bool is_source_supported) override;
-  WebString GetPresentationId() override;
+  void SourceChanged(const KURL&, bool is_source_supported) override;
+  WTF::String GetPresentationId() override;
   void MediaMetadataChanged(
       std::optional<media::VideoCodec> video_codec,
       std::optional<media::AudioCodec> audio_codec) override;
@@ -191,7 +191,7 @@ class MODULES_EXPORT RemotePlayback final
 
   String presentation_id_;
   KURL presentation_url_;
-  WebURL source_;
+  KURL source_;
   bool is_source_supported_ = false;
   std::optional<media::VideoCodec> video_codec_ = std::nullopt;
   std::optional<media::AudioCodec> audio_codec_ = std::nullopt;

third_party/blink/renderer/platform/BUILD.gn

@@ -1251,6 +1251,10 @@ component("platform") {
     "language_detection/detect.h",
     "link_hash.cc",
     "link_hash.h",
+    "media/media_player_client.h",
+    "media/media_player_util.cc",
+    "media/media_player_util.h",
+    "media/remote_playback_client.h",
     "media/web_audio_source_provider_client.h",
     "media/web_audio_source_provider_impl.cc",
     "media_capabilities/web_audio_configuration.h",

third_party/blink/renderer/platform/media/BUILD.gn

@@ -35,7 +35,6 @@ component("media") {
     "new_session_cdm_result_promise.h",
     "power_status_helper.cc",
     "power_status_helper.h",
-    "remote_playback_client_wrapper_impl.cc",
     "resource_fetch_context.h",
     "resource_multi_buffer_data_provider.cc",
     "resource_multi_buffer_data_provider.h",
@@ -58,8 +57,10 @@ component("media") {
     "web_source_buffer_impl.h",
   ]
 
-  configs +=
-      [ "//third_party/blink/renderer/platform:blink_platform_implementation" ]
+  configs += [
+    "//third_party/blink/renderer/platform:blink_platform_implementation",
+    "//third_party/blink/renderer:inside_blink",
+  ]
   public_deps = [
     "//base",
     "//media",
@@ -125,6 +126,7 @@ source_set("unit_tests") {
   # TODO(https://crbug.com/1198341): enable this config once the code is ported
   # to Blink code conventions.
   #configs += [ "//third_party/blink/renderer/platform:blink_platform_config" ]
+  configs += [ "//third_party/blink/renderer:inside_blink" ]
   sources = [
     "cache_util_unittest.cc",
     "interval_map_unittest.cc",
@@ -174,9 +176,11 @@ source_set("test_support") {
   testonly = true
   configs += [
     "//third_party/blink/renderer:non_test_config",
+
     # TODO(https://crbug.com/1198341): enable this config once the code is
     # ported to Blink code conventions.
     #"//third_party/blink/renderer/platform:blink_platform_config",
+    "//third_party/blink/renderer:inside_blink",
   ]
   sources = [
     "testing/mock_resource_fetch_context.cc",

third_party/blink/renderer/platform/media/DEPS

@@ -35,6 +35,7 @@ include_rules = [
   "+third_party/blink/renderer/platform/bindings/v8_external_memory_accounter.h",
   "+third_party/blink/renderer/platform/allow_discouraged_type.h",
   "+third_party/blink/renderer/platform/platform_export.h",
+  "+third_party/blink/renderer/platform/weborigin",
   "+third_party/blink/renderer/platform/wtf",
 ]
 

third_party/blink/renderer/platform/media/key_system_config_selector.cc

@@ -29,8 +29,8 @@
 #include "third_party/blink/public/platform/web_media_key_system_configuration.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_vector.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/public/web/web_local_frame.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 
 namespace blink {
 namespace {

third_party/blink/renderer/platform/media/media_player_client.h

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_CLIENT_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_CLIENT_H_
+
+#include <memory>
+
+#include "base/time/time.h"
+#include "third_party/blink/public/common/media/display_type.h"
+#include "third_party/blink/public/platform/web_common.h"
+#include "third_party/blink/public/platform/web_media_player.h"
+#include "third_party/blink/public/platform/web_media_player_client.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+#include "ui/gfx/color_space.h"
+
+namespace cc {
+class Layer;
+}
+
+namespace media {
+enum class MediaContentType;
+enum class VideoCodec;
+enum class AudioCodec;
+class MediaTrack;
+}  // namespace media
+
+namespace blink {
+
+class WebMediaSource;
+
+class PLATFORM_EXPORT MediaPlayerClient : public WebMediaPlayerClient {
+ public:
+  enum VideoTrackKind {
+    kVideoTrackKindNone,
+    kVideoTrackKindAlternative,
+    kVideoTrackKindCaptions,
+    kVideoTrackKindMain,
+    kVideoTrackKindSign,
+    kVideoTrackKindSubtitles,
+    kVideoTrackKindCommentary
+  };
+
+  enum AudioTrackKind {
+    kAudioTrackKindNone,
+    kAudioTrackKindAlternative,
+    kAudioTrackKindDescriptions,
+    kAudioTrackKindMain,
+    kAudioTrackKindMainDescriptions,
+    kAudioTrackKindTranslation,
+    kAudioTrackKindCommentary
+  };
+
+  // Reason for a PausePlayback call, for better diagnostic messages.
+  enum class PauseReason {
+    kUnknown,
+    kPageHidden,
+    kSuspendedPlayerIdleTimeout,
+    kRemotePlayStateChange,
+    kFrameHidden,
+  };
+
+  static const int kMediaRemotingStopNoText = -1;
+
+  virtual void NetworkStateChanged() = 0;
+  virtual void ReadyStateChanged() = 0;
+  virtual void TimeChanged() = 0;
+  virtual void Repaint() = 0;
+  virtual void DurationChanged() = 0;
+  virtual void SizeChanged() = 0;
+  virtual void SetCcLayer(cc::Layer*) = 0;
+
+  virtual void AddMediaTrack(const media::MediaTrack&) = 0;
+  virtual void RemoveMediaTrack(const media::MediaTrack&) = 0;
+
+  virtual void MediaSourceOpened(std::unique_ptr<WebMediaSource>) = 0;
+  virtual void RemotePlaybackCompatibilityChanged(const KURL&,
+                                                  bool is_compatible) = 0;
+
+  // Returns whether the media element has always been muted. This is used to
+  // avoid take audio focus for elements that the user is not aware is playing.
+  virtual bool WasAlwaysMuted() = 0;
+
+  // Returns if there's a selected video track.
+  virtual bool HasSelectedVideoTrack() = 0;
+
+  // Returns the selected video track id (or an empty id if there's none).
+  virtual WebMediaPlayer::TrackId GetSelectedVideoTrackId() = 0;
+
+  // Informs that media starts being rendered and played back remotely.
+  // |remote_device_friendly_name| will be shown in the remoting UI to indicate
+  // which device the content is rendered on. An empty name indicates an unknown
+  // remote device. A default message will be shown in this case.
+  virtual void MediaRemotingStarted(
+      const WebString& remote_device_friendly_name) = 0;
+
+  // Informs that media stops being rendered remotely. |error_code| corresponds
+  // to a localized string that explains the reason as user-readable text.
+  // |error_code| should be IDS_FOO or kMediaRemotingStopNoText.
+  virtual void MediaRemotingStopped(int error_code) = 0;
+
+  // Returns whether the media element has native controls. It does not mean
+  // that the controls are currently visible.
+  virtual bool HasNativeControls() = 0;
+
+  // Returns true iff the client represents an HTML <audio> element.
+  virtual bool IsAudioElement() = 0;
+
+  // Returns the current display type of the media element.
+  virtual DisplayType GetDisplayType() const = 0;
+
+  // Returns the color space to render media into if.
+  // Rendering media into this color space may avoid some conversions.
+  virtual gfx::ColorSpace TargetColorSpace() { return gfx::ColorSpace(); }
+
+  // Returns whether the media element was initiated via autoplay.
+  // In this context, autoplay means that it was initiated before any user
+  // activation was received on the page and before a user initiated same-domain
+  // navigation. In other words, with the unified autoplay policy applied, it
+  // should only return `true` when MEI allowed autoplay.
+  virtual bool WasAutoplayInitiated() { return false; }
+
+  // Returns true if playback would start if the ready state was at least
+  // WebMediaPlayer::kReadyStateHaveFutureData.
+  virtual bool CouldPlayIfEnoughData() const = 0;
+
+  // Returns whether the playback is in auto-pip mode which does not have th
+  // behavior as regular Picture-in-Picture.
+  virtual bool IsInAutoPIP() const = 0;
+
+  // Requests the player to resume playback.
+  virtual void ResumePlayback() = 0;
+
+  // Request the player to pause playback.
+  virtual void PausePlayback(PauseReason) = 0;
+
+  // Notify the client that the media player started playing content.
+  virtual void DidPlayerStartPlaying() = 0;
+
+  // Notify the client that the media player stopped playing content, indicating
+  // in |stream_ended| if playback has reached the end of the stream.
+  virtual void DidPlayerPaused(bool stream_ended) = 0;
+
+  // Notify the client that the muted status of the media player has changed.
+  virtual void DidPlayerMutedStatusChange(bool muted) = 0;
+
+  // Notify the client that the media metadata of the media player has changed.
+  virtual void DidMediaMetadataChange(
+      bool has_audio,
+      bool has_video,
+      media::AudioCodec audio_codec,
+      media::VideoCodec video_codec,
+      media::MediaContentType media_content_type,
+      bool is_encrypted_media) = 0;
+
+  // Notify the client that the playback position has changed.
+  virtual void DidPlayerMediaPositionStateChange(double playback_rate,
+                                                 base::TimeDelta duration,
+                                                 base::TimeDelta position,
+                                                 bool end_of_media) = 0;
+
+  // Notify the client that the audio sink cannot be changed.
+  virtual void DidDisableAudioOutputSinkChanges() = 0;
+
+  // Notify the client that the playback starts/stops to use AudioService.
+  virtual void DidUseAudioServiceChange(bool uses_audio_service) = 0;
+
+  // Notify the client that the size of the media player has changed.
+  // TODO(crbug.com/1039252): Remove by merging this method into SizeChanged().
+  virtual void DidPlayerSizeChange(const gfx::Size& size) = 0;
+
+  virtual void OnFirstFrame(base::TimeTicks first_frame,
+                            size_t bytes_to_first_frame) = 0;
+
+  // Notify the client that one of the state used by Picture-in-Picture has
+  // changed. The client will then have to poll the states from the associated
+  // WebMediaPlayer.
+  // The states are:
+  //  - Delegate ID;
+  //  - Surface ID;
+  //  - Natural Size.
+  virtual void OnPictureInPictureStateChange() = 0;
+
+  // Called when a video frame has been presented to the compositor, after a
+  // request was initiated via WebMediaPlayer::RequestVideoFrameCallback().
+  // See https://wicg.github.io/video-rvfc/.
+  virtual void OnRequestVideoFrameCallback() {}
+
+  // Notify the client that the RemotePlayback has been disabled/enabled.
+  virtual void OnRemotePlaybackDisabled(bool disabled) = 0;
+
+ protected:
+  ~MediaPlayerClient() = default;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_CLIENT_H_

third_party/blink/renderer/platform/media/media_player_util.cc

@@ -0,0 +1,116 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
+
+#include <math.h>
+#include <stddef.h>
+
+#include <string>
+#include <utility>
+
+#include "base/metrics/histogram_macros.h"
+#include "base/task/bind_post_task.h"
+#include "media/base/media_log.h"
+#include "third_party/blink/public/common/scheme_registry.h"
+#include "third_party/blink/public/platform/url_conversion.h"
+#include "third_party/blink/public/platform/web_media_player_encrypted_media_client.h"
+#include "third_party/blink/renderer/platform/weborigin/kurl.h"
+#include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"
+#include "third_party/blink/renderer/platform/wtf/functional.h"
+
+namespace {
+
+void RunSetSinkIdCallback(blink::WebSetSinkIdCompleteCallback callback,
+                          media::OutputDeviceStatus result) {
+  switch (result) {
+    case media::OUTPUT_DEVICE_STATUS_OK:
+      std::move(callback).Run(/*error =*/std::nullopt);
+      break;
+    case media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND:
+      std::move(callback).Run(blink::WebSetSinkIdError::kNotFound);
+      break;
+    case media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED:
+      std::move(callback).Run(blink::WebSetSinkIdError::kNotAuthorized);
+      break;
+    case media::OUTPUT_DEVICE_STATUS_ERROR_TIMED_OUT:
+    case media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL:
+      std::move(callback).Run(blink::WebSetSinkIdError::kAborted);
+      break;
+  }
+}
+
+}  // namespace
+
+namespace blink {
+
+media::mojom::blink::MediaURLScheme GetMediaURLScheme(const KURL& url) {
+  if (!url.GetParsed().scheme.is_valid()) {
+    return media::mojom::blink::MediaURLScheme::kMissing;
+  }
+  if (url.ProtocolIs(url::kHttpScheme)) {
+    return media::mojom::blink::MediaURLScheme::kHttp;
+  }
+  if (url.ProtocolIs(url::kHttpsScheme)) {
+    return media::mojom::blink::MediaURLScheme::kHttps;
+  }
+  if (url.ProtocolIs(url::kFtpScheme)) {
+    return media::mojom::blink::MediaURLScheme::kFtp;
+  }
+  if (url.ProtocolIs(url::kJavaScriptScheme)) {
+    return media::mojom::blink::MediaURLScheme::kJavascript;
+  }
+  if (url.ProtocolIs(url::kFileScheme)) {
+    return media::mojom::blink::MediaURLScheme::kFile;
+  }
+  if (url.ProtocolIs(url::kBlobScheme)) {
+    return media::mojom::blink::MediaURLScheme::kBlob;
+  }
+  if (url.ProtocolIs(url::kDataScheme)) {
+    return media::mojom::blink::MediaURLScheme::kData;
+  }
+  if (url.ProtocolIs(url::kFileSystemScheme)) {
+    return media::mojom::blink::MediaURLScheme::kFileSystem;
+  }
+  if (url.ProtocolIs(url::kContentScheme)) {
+    return media::mojom::blink::MediaURLScheme::kContent;
+  }
+  if (url.ProtocolIs(url::kContentIDScheme)) {
+    return media::mojom::blink::MediaURLScheme::kContentId;
+  }
+
+  // Some internals pages and extension pages play media.
+  if (SchemeRegistry::IsWebUIScheme(url.Protocol())) {
+    return media::mojom::blink::MediaURLScheme::kChrome;
+  }
+  if (CommonSchemeRegistry::IsExtensionScheme(url.Protocol().Ascii())) {
+    return media::mojom::blink::MediaURLScheme::kChromeExtension;
+  }
+
+  return media::mojom::blink::MediaURLScheme::kUnknown;
+}
+
+void ReportMetrics(WebMediaPlayer::LoadType load_type,
+                   const KURL& url,
+                   media::MediaLog* media_log) {
+  DCHECK(media_log);
+
+  // Report URL scheme, such as http, https, file, blob etc. Only do this for
+  // URL based loads, otherwise it's not very useful.
+  if (load_type == WebMediaPlayer::kLoadTypeURL) {
+    UMA_HISTOGRAM_ENUMERATION("Media.URLScheme2", GetMediaURLScheme(url));
+  }
+
+  // Report load type, such as URL, MediaSource or MediaStream.
+  UMA_HISTOGRAM_ENUMERATION("Media.LoadType", load_type,
+                            WebMediaPlayer::kLoadTypeMax + 1);
+}
+
+media::OutputDeviceStatusCB ConvertToOutputDeviceStatusCB(
+    WebSetSinkIdCompleteCallback callback) {
+  return base::BindPostTaskToCurrentDefault(
+      WTF::BindOnce(RunSetSinkIdCallback, std::move(callback)));
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/media/media_player_util.h

@@ -0,0 +1,36 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_UTIL_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_UTIL_H_
+
+#include "media/base/output_device_info.h"
+#include "media/mojo/mojom/media_metrics_provider.mojom-blink.h"
+#include "third_party/blink/public/platform/web_media_player.h"
+#include "third_party/blink/public/platform/web_set_sink_id_callbacks.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+
+namespace media {
+class MediaLog;
+}  // namespace media
+
+namespace blink {
+
+// Translates a |url| into the appropriate URL scheme.
+PLATFORM_EXPORT media::mojom::blink::MediaURLScheme GetMediaURLScheme(
+    const KURL& url);
+
+// Report various metrics to UMA.
+PLATFORM_EXPORT void ReportMetrics(WebMediaPlayer::LoadType load_type,
+                                   const KURL& url,
+                                   media::MediaLog* media_log);
+
+// Wraps a WebSetSinkIdCompleteCallback into a
+// media::OutputDeviceStatusCB and binds it to the current thread
+PLATFORM_EXPORT media::OutputDeviceStatusCB ConvertToOutputDeviceStatusCB(
+    WebSetSinkIdCompleteCallback completion_callback);
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_MEDIA_PLAYER_UTIL_H_

third_party/blink/renderer/platform/media/multi_buffer_data_source.cc

@@ -19,7 +19,7 @@
 #include "net/base/net_errors.h"
 #include "third_party/blink/renderer/platform/media/buffered_data_source_host_impl.h"
 #include "third_party/blink/renderer/platform/media/multi_buffer_reader.h"
-#include "url/gurl.h"
+#include "third_party/blink/renderer/platform/weborigin/security_origin.h"
 
 namespace blink {
 namespace {
@@ -156,7 +156,7 @@ bool MultiBufferDataSource::media_has_played() const {
 
 bool MultiBufferDataSource::AssumeFullyBuffered() const {
   DCHECK(url_data_);
-  return !url_data_->url().SchemeIsHTTPOrHTTPS();
+  return !url_data_->url().ProtocolIsInHTTPFamily();
 }
 
 void MultiBufferDataSource::SetReader(
@@ -236,8 +236,8 @@ void MultiBufferDataSource::OnRedirected(
     StopLoader();
     return;
   }
-  if (url_data_->url().DeprecatedGetOriginAsURL() !=
-      new_destination->url().DeprecatedGetOriginAsURL()) {
+  if (!SecurityOrigin::AreSameOrigin(url_data_->url(),
+                                     new_destination->url())) {
     single_origin_ = false;
   }
   SetReader(nullptr);
@@ -410,7 +410,7 @@ int64_t MultiBufferDataSource::GetMemoryUsage() {
 }
 
 GURL MultiBufferDataSource::GetUrlAfterRedirects() const {
-  return url_data_->url();
+  return GURL(url_data_->url());
 }
 
 void MultiBufferDataSource::Read(int64_t position,

third_party/blink/renderer/platform/media/multi_buffer_data_source_unittest.cc

@@ -127,7 +127,7 @@ class TestResourceMultiBuffer : public ResourceMultiBuffer {
 
 class TestUrlData : public UrlData {
  public:
-  TestUrlData(const GURL& url,
+  TestUrlData(const KURL& url,
               CorsMode cors_mode,
               UrlIndex* url_index,
               UrlData::CacheMode cache_mode,
@@ -167,7 +167,7 @@ class TestUrlIndex : public UrlIndex {
       : UrlIndex(fetch_context, task_runner),
         task_runner_(std::move(task_runner)) {}
 
-  scoped_refptr<UrlData> NewUrlData(const GURL& url,
+  scoped_refptr<UrlData> NewUrlData(const KURL& url,
                                     UrlData::CorsMode cors_mode,
                                     UrlData::CacheMode cache_mode) override {
     NotifyNewUrlData(url, cors_mode, cache_mode);
@@ -182,7 +182,7 @@ class TestUrlIndex : public UrlIndex {
   }
 
   MOCK_METHOD3(NotifyNewUrlData,
-               void(GURL, UrlData::CorsMode, UrlData::CacheMode));
+               void(KURL, UrlData::CorsMode, UrlData::CacheMode));
 
  private:
   scoped_refptr<TestUrlData> last_url_data_;
@@ -255,19 +255,19 @@ class MultiBufferDataSourceTest : public testing::Test {
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
-  void InitializeWithCors(const char* url,
+  void InitializeWithCors(const char* url_string,
                           bool expected,
                           UrlData::CorsMode cors_mode,
                           size_t file_size = kFileSize) {
-    GURL gurl(url);
+    KURL url(url_string);
     media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
     data_source_ = std::make_unique<MockMultiBufferDataSource>(
-        task_runner_, url_index_.GetByUrl(gurl, cors_mode, UrlData::kNormal),
+        task_runner_, url_index_.GetByUrl(url, cors_mode, UrlData::kNormal),
         media_log_.get(), &host_);
     data_source_->SetPreload(preload_);
 
     response_generator_ =
-        std::make_unique<TestResponseGenerator>(gurl, file_size);
+        std::make_unique<TestResponseGenerator>(url, file_size);
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->SetIsClientAudioElement(is_client_audio_element_);
     data_source_->Initialize(base::BindOnce(
@@ -747,7 +747,7 @@ TEST_F(MultiBufferDataSourceTest,
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
-  response2.SetCurrentRequestUrl(GURL(kHttpDifferentPathUrl));
+  response2.SetCurrentRequestUrl(KURL(kHttpDifferentPathUrl));
   // The origin URL of response1 and response2 are same. So no error should
   // occur.
   ExecuteMixedResponseSuccessTest(response1, response2);
@@ -760,7 +760,7 @@ TEST_F(MultiBufferDataSourceTest,
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
-  response2.SetCurrentRequestUrl(GURL(kHttpDifferentOriginUrl));
+  response2.SetCurrentRequestUrl(KURL(kHttpDifferentOriginUrl));
   // The origin URL of response1 and response2 are different. So an error should
   // occur.
   ExecuteMixedResponseFailureTest(response1, response2);
@@ -785,7 +785,7 @@ TEST_F(MultiBufferDataSourceTest,
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.SetWasFetchedViaServiceWorker(true);
-  std::vector<WebURL> url_list = {GURL(kHttpUrl)};
+  std::vector<WebURL> url_list = {KURL(kHttpUrl)};
   response1.SetUrlListViaServiceWorker(url_list);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
@@ -800,7 +800,7 @@ TEST_F(MultiBufferDataSourceTest,
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.SetWasFetchedViaServiceWorker(true);
-  std::vector<WebURL> url_list = {GURL(kHttpDifferentPathUrl)};
+  std::vector<WebURL> url_list = {KURL(kHttpDifferentPathUrl)};
   response1.SetUrlListViaServiceWorker(url_list);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
@@ -815,7 +815,7 @@ TEST_F(MultiBufferDataSourceTest,
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.SetWasFetchedViaServiceWorker(true);
-  std::vector<WebURL> url_list = {GURL(kHttpDifferentOriginUrl)};
+  std::vector<WebURL> url_list = {KURL(kHttpDifferentOriginUrl)};
   response1.SetUrlListViaServiceWorker(url_list);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
@@ -830,7 +830,7 @@ TEST_F(MultiBufferDataSourceTest,
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.SetWasFetchedViaServiceWorker(true);
-  std::vector<WebURL> url_list = {GURL(kHttpDifferentOriginUrl)};
+  std::vector<WebURL> url_list = {KURL(kHttpDifferentOriginUrl)};
   response1.SetUrlListViaServiceWorker(url_list);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
@@ -1036,7 +1036,7 @@ TEST_F(MultiBufferDataSourceTest, Http_ShareData) {
   media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
   MockMultiBufferDataSource source2(
       task_runner_,
-      url_index_.GetByUrl(GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
+      url_index_.GetByUrl(KURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
                           UrlData::kNormal),
       media_log_.get(), &host2);
   source2.SetPreload(preload_);
@@ -1067,7 +1067,7 @@ TEST_F(MultiBufferDataSourceTest, Http_ShareData_AtLeastOneProgress) {
   media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
   MockMultiBufferDataSource source2(
       task_runner_,
-      url_index_.GetByUrl(GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
+      url_index_.GetByUrl(KURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
                           UrlData::kNormal),
       media_log_.get(), &host2);
   source2.SetPreload(preload_);
@@ -1502,16 +1502,16 @@ TEST_F(MultiBufferDataSourceTest,
 }
 
 TEST_F(MultiBufferDataSourceTest, SeekPastEOF) {
-  GURL gurl(kHttpUrl);
+  KURL url(kHttpUrl);
   media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
   data_source_ = std::make_unique<MockMultiBufferDataSource>(
       task_runner_,
-      url_index_.GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlData::kNormal),
+      url_index_.GetByUrl(url, UrlData::CORS_UNSPECIFIED, UrlData::kNormal),
       media_log_.get(), &host_);
   data_source_->SetPreload(preload_);
 
   response_generator_ =
-      std::make_unique<TestResponseGenerator>(gurl, kDataSize + 1);
+      std::make_unique<TestResponseGenerator>(url, kDataSize + 1);
   EXPECT_CALL(*this, OnInitialize(true));
   data_source_->Initialize(base::BindOnce(
       &MultiBufferDataSourceTest::OnInitialize, base::Unretained(this)));
@@ -1555,8 +1555,8 @@ TEST_F(MultiBufferDataSourceTest, Http_RetryThenRedirect) {
   run_loop.Run();
 
   // Server responds with a redirect.
-  WebURL url{GURL(kHttpDifferentPathUrl)};
-  WebURLResponse response((GURL(kHttpUrl)));
+  WebURL url{KURL(kHttpDifferentPathUrl)};
+  WebURLResponse response((KURL(kHttpUrl)));
   response.SetHttpStatusCode(307);
   data_provider()->WillFollowRedirect(url, response);
 
@@ -1573,8 +1573,8 @@ TEST_F(MultiBufferDataSourceTest, Http_NotStreamingAfterRedirect) {
   Initialize(kHttpUrl, true);
 
   // Server responds with a redirect.
-  WebURL url{GURL(kHttpDifferentPathUrl)};
-  WebURLResponse response((GURL(kHttpUrl)));
+  WebURL url{KURL(kHttpDifferentPathUrl)};
+  WebURLResponse response((KURL(kHttpUrl)));
   response.SetHttpStatusCode(307);
   data_provider()->WillFollowRedirect(url, response);
 
@@ -1595,8 +1595,8 @@ TEST_F(MultiBufferDataSourceTest, Http_RangeNotSatisfiableAfterRedirect) {
   Initialize(kHttpUrl, true);
 
   // Server responds with a redirect.
-  WebURL url{GURL(kHttpDifferentPathUrl)};
-  WebURLResponse response((GURL(kHttpUrl)));
+  WebURL url{KURL(kHttpDifferentPathUrl)};
+  WebURLResponse response((KURL(kHttpUrl)));
   response.SetHttpStatusCode(307);
   data_provider()->WillFollowRedirect(url, response);
 
@@ -1609,8 +1609,8 @@ TEST_F(MultiBufferDataSourceTest, Http_404AfterRedirect) {
   Initialize(kHttpUrl, false);
 
   // Server responds with a redirect.
-  WebURL url{GURL(kHttpDifferentPathUrl)};
-  WebURLResponse response((GURL(kHttpUrl)));
+  WebURL url{KURL(kHttpDifferentPathUrl)};
+  WebURLResponse response((KURL(kHttpUrl)));
   response.SetHttpStatusCode(307);
   data_provider()->WillFollowRedirect(url, response);
 
@@ -1619,8 +1619,8 @@ TEST_F(MultiBufferDataSourceTest, Http_404AfterRedirect) {
 }
 
 TEST_F(MultiBufferDataSourceTest, PreserveCachingModeAfterRedirect) {
-  GURL start = GURL("https://start.com");
-  GURL redir = GURL("https://redir.com");
+  KURL start("https://start.com");
+  KURL redir("https://redir.com");
   media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
   WebURL url{redir};
   WebURLResponse redirect_response(start);
@@ -1753,8 +1753,8 @@ TEST_F(MultiBufferDataSourceTest, LengthKnownAtEOF) {
 
 TEST_F(MultiBufferDataSourceTest, FileSizeLessThanBlockSize) {
   Initialize(kHttpUrl, true);
-  GURL gurl(kHttpUrl);
-  WebURLResponse response(gurl);
+  KURL url(kHttpUrl);
+  WebURLResponse response(url);
   response.SetHttpStatusCode(200);
   response.SetHttpHeaderField(
       WebString::FromUTF8("Content-Length"),
@@ -1988,16 +1988,16 @@ TEST_F(MultiBufferDataSourceTest, CheckBufferSizeAfterReadingALot) {
 // Provoke an edge case where the loading state may not end up transitioning
 // back to "idle" when we're done loading.
 TEST_F(MultiBufferDataSourceTest, Http_CheckLoadingTransition) {
-  GURL gurl(kHttpUrl);
+  KURL url(kHttpUrl);
   media_log_ = std::make_unique<NiceMock<media::MockMediaLog>>();
   data_source_ = std::make_unique<MockMultiBufferDataSource>(
       task_runner_,
-      url_index_.GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlData::kNormal),
+      url_index_.GetByUrl(url, UrlData::CORS_UNSPECIFIED, UrlData::kNormal),
       media_log_.get(), &host_);
   data_source_->SetPreload(preload_);
 
   response_generator_ =
-      std::make_unique<TestResponseGenerator>(gurl, kDataSize * 1);
+      std::make_unique<TestResponseGenerator>(url, kDataSize * 1);
   EXPECT_CALL(*this, OnInitialize(true));
   data_source_->Initialize(base::BindOnce(
       &MultiBufferDataSourceTest::OnInitialize, base::Unretained(this)));

third_party/blink/renderer/platform/media/remote_playback_client.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_REMOTEPLAYBACK_WEB_REMOTE_PLAYBACK_CLIENT_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_REMOTEPLAYBACK_WEB_REMOTE_PLAYBACK_CLIENT_H_
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_H_
 
 #include <optional>
 
@@ -12,23 +12,26 @@ enum class VideoCodec;
 enum class AudioCodec;
 }  // namespace media
 
+namespace WTF {
+class String;
+}  // namespace WTF
+
 namespace blink {
 
-class WebURL;
-class WebString;
+class KURL;
 
 // The interface between the HTMLMediaElement and its
 // HTMLMediaElementRemotePlayback supplement.
-class WebRemotePlaybackClient {
+class RemotePlaybackClient {
  public:
-  virtual ~WebRemotePlaybackClient() = default;
+  virtual ~RemotePlaybackClient() = default;
 
   // Returns if the remote playback available for this media element.
   virtual bool RemotePlaybackAvailable() const = 0;
 
   // Notifies the client that the source of the HTMLMediaElement has changed as
   // well as if the new source is supported for remote playback.
-  virtual void SourceChanged(const WebURL&, bool is_source_supported) = 0;
+  virtual void SourceChanged(const KURL&, bool is_source_supported) = 0;
 
   virtual void MediaMetadataChanged(
       std::optional<media::VideoCodec> video_codec,
@@ -36,9 +39,9 @@ class WebRemotePlaybackClient {
 
   // Gets the presentation ID associated with the client. The presentation ID
   // may be null, empty or stale.
-  virtual WebString GetPresentationId() = 0;
+  virtual WTF::String GetPresentationId() = 0;
 };
 
 }  // namespace blink
 
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_REMOTEPLAYBACK_WEB_REMOTE_PLAYBACK_CLIENT_H_
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIA_REMOTE_PLAYBACK_CLIENT_H_

third_party/blink/renderer/platform/media/remote_playback_client_wrapper_impl.cc

@@ -1,30 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/public/platform/media/remote_playback_client_wrapper_impl.h"
-
-#include "third_party/blink/public/platform/modules/remoteplayback/web_remote_playback_client.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
-#include "third_party/blink/public/platform/web_string.h"
-
-namespace blink {
-
-RemotePlaybackClientWrapperImpl::RemotePlaybackClientWrapperImpl(
-    WebMediaPlayerClient* client)
-    : remote_playback_client_(client->RemotePlaybackClient()) {}
-
-RemotePlaybackClientWrapperImpl::~RemotePlaybackClientWrapperImpl() = default;
-
-std::string RemotePlaybackClientWrapperImpl::GetActivePresentationId() {
-  if (!remote_playback_client_)
-    return std::string();
-
-  // The presentation ID is essentially a GUID preceeded by the "mr_" prefix,
-  // which makes it ASCII compatible.
-  // If MediaRouterBase::CreatePresentationId() were changed, this line might
-  // need to be updated.
-  return remote_playback_client_->GetPresentationId().Ascii();
-}
-
-}  // namespace blink

third_party/blink/renderer/platform/media/resource_multi_buffer_data_provider.cc

@@ -34,6 +34,7 @@
 #include "third_party/blink/renderer/platform/media/cache_util.h"
 #include "third_party/blink/renderer/platform/media/resource_fetch_context.h"
 #include "third_party/blink/renderer/platform/media/url_index.h"
+#include "third_party/blink/renderer/platform/weborigin/security_origin.h"
 
 namespace blink {
 
@@ -63,7 +64,7 @@ ResourceMultiBufferDataProvider::ResourceMultiBufferDataProvider(
       url_data_(url_data),
       retries_(0),
       cors_mode_(url_data->cors_mode()),
-      origin_(url_data->url().DeprecatedGetOriginAsURL()),
+      original_url_(url_data->url()),
       is_client_audio_element_(is_client_audio_element),
       task_runner_(std::move(task_runner)) {
   DCHECK(url_data_) << " pos = " << pos;
@@ -177,7 +178,7 @@ bool ResourceMultiBufferDataProvider::WillFollowRedirect(
   // This test is vital for security!
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED) {
     // We allow the redirect if the origin is the same.
-    if (origin_ != redirects_to_.DeprecatedGetOriginAsURL()) {
+    if (!SecurityOrigin::AreSameOrigin(original_url_, redirects_to_)) {
       // We also allow the redirect if we don't have any data in the
       // cache, as that means that no dangerous data mixing can occur.
       if (url_data_->multibuffer()->map().empty() && fifo_.empty())
@@ -225,10 +226,10 @@ void ResourceMultiBufferDataProvider::DidReceiveResponse(
 
   scoped_refptr<UrlData> destination_url_data(url_data_.get());
 
-  if (!redirects_to_.is_empty()) {
+  if (!redirects_to_.IsEmpty()) {
     destination_url_data = url_data_->url_index()->GetByUrl(
         redirects_to_, cors_mode_, url_data_->cache_lookup_mode());
-    redirects_to_ = GURL();
+    redirects_to_ = KURL();
   }
 
   base::Time last_modified;
@@ -260,7 +261,7 @@ void ResourceMultiBufferDataProvider::DidReceiveResponse(
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
-  if (destination_url_data->url().SchemeIsHTTPOrHTTPS()) {
+  if (destination_url_data->url().ProtocolIsInHTTPFamily()) {
     bool partial_response = (response.HttpStatusCode() == kHttpPartialContent);
     bool ok_response = (response.HttpStatusCode() == kHttpOK);
 
@@ -360,14 +361,14 @@ void ResourceMultiBufferDataProvider::DidReceiveResponse(
   // ResponseUrl(), but ResourceMultiBufferDataProvider disallows mixing
   // constructed responses (new Response()) and native server responses, even if
   // they have the same response URL.
-  GURL response_url;
+  KURL response_url;
   if (!response.WasFetchedViaServiceWorker() ||
       response.HasUrlListViaServiceWorker()) {
     response_url = response.ResponseUrl();
   }
 
   // This test is vital for security!
-  if (!url_data_->ValidateDataOrigin(response_url.DeprecatedGetOriginAsURL())) {
+  if (!url_data_->ValidateDataOrigin(response_url)) {
     active_loader_.reset();
     url_data_->Fail();
     return;  // "this" may be deleted now.

third_party/blink/renderer/platform/media/resource_multi_buffer_data_provider.h

@@ -21,7 +21,7 @@
 #include "third_party/blink/renderer/platform/media/multi_buffer.h"
 #include "third_party/blink/renderer/platform/media/url_index.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
-#include "url/gurl.h"
+#include "third_party/blink/renderer/platform/weborigin/kurl.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -111,14 +111,14 @@ class PLATFORM_EXPORT ResourceMultiBufferDataProvider
 
   // The origin for the initial request.
   // const to make it obvious that redirects cannot change it.
-  const GURL origin_ ALLOW_DISCOURAGED_TYPE("Avoids conversion in media code");
+  const KURL original_url_;
 
   // Keeps track of an active WebAssociatedURLLoader.
   // Only valid while loading resource.
   std::unique_ptr<WebAssociatedURLLoader> active_loader_;
 
   // When we encounter a redirect, this is the source of the redirect.
-  GURL redirects_to_ ALLOW_DISCOURAGED_TYPE("Avoids conversion in media code");
+  KURL redirects_to_;
 
   // If the server tries to gives us more bytes than we want, this how
   // many bytes we need to discard before we get to the right place.

third_party/blink/renderer/platform/media/resource_multi_buffer_data_provider_unittest.cc

@@ -85,9 +85,9 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
       const ResourceMultiBufferDataProviderTest&) = delete;
 
   void Initialize(const char* url, int first_position) {
-    gurl_ = GURL(url);
+    url_ = KURL(url);
     url_data_ =
-        url_index_.GetByUrl(gurl_, UrlData::CORS_UNSPECIFIED, UrlData::kNormal);
+        url_index_.GetByUrl(url_, UrlData::CORS_UNSPECIFIED, UrlData::kNormal);
     url_data_->set_etag(kEtag);
     DCHECK(url_data_);
     url_data_->OnRedirect(
@@ -106,7 +106,7 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
   void Start() { loader_->Start(); }
 
   void FullResponse(int64_t instance_size, bool ok = true) {
-    WebURLResponse response(gurl_);
+    WebURLResponse response(url_);
     response.SetHttpHeaderField(
         WebString::FromUTF8("Content-Length"),
         WebString::FromUTF8(base::StringPrintf("%" PRId64, instance_size)));
@@ -132,7 +132,7 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
                        int64_t instance_size,
                        bool chunked,
                        bool accept_ranges) {
-    WebURLResponse response(gurl_);
+    WebURLResponse response(url_);
     response.SetHttpHeaderField(
         WebString::FromUTF8("Content-Range"),
         WebString::FromUTF8(
@@ -166,8 +166,8 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
   }
 
   void Redirect(const char* url) {
-    WebURL new_url{GURL(url)};
-    WebURLResponse redirect_response(gurl_);
+    WebURL new_url{KURL(url)};
+    WebURLResponse redirect_response(url_);
 
     EXPECT_CALL(*this, RedirectCallback(_))
         .WillOnce(
@@ -216,7 +216,7 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
   }
 
   base::test::SingleThreadTaskEnvironment task_environment_;
-  GURL gurl_;
+  KURL url_;
   int32_t first_position_;
 
   NiceMock<MockResourceFetchContext> fetch_context_;
@@ -243,7 +243,7 @@ TEST_F(ResourceMultiBufferDataProviderTest, BadHttpResponse) {
 
   EXPECT_CALL(*this, RedirectCallback(scoped_refptr<UrlData>(nullptr)));
 
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpStatusCode(404);
   response.SetHttpStatusText("Not Found\n");
   loader_->DidReceiveResponse(response);
@@ -301,7 +301,7 @@ TEST_F(ResourceMultiBufferDataProviderTest, InvalidPartialResponse) {
 
   EXPECT_CALL(*this, RedirectCallback(scoped_refptr<UrlData>(nullptr)));
 
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpHeaderField(
       WebString::FromUTF8("Content-Range"),
       WebString::FromUTF8(base::StringPrintf("bytes "

third_party/blink/renderer/platform/media/testing/test_response_generator.cc

@@ -12,16 +12,16 @@
 
 namespace blink {
 
-TestResponseGenerator::TestResponseGenerator(const GURL& gurl,
+TestResponseGenerator::TestResponseGenerator(const KURL& url,
                                              int64_t content_length)
-    : gurl_(gurl), content_length_(content_length) {}
+    : url_(url), content_length_(content_length) {}
 
 WebURLError TestResponseGenerator::GenerateError() {
   return WebURLError(net::ERR_ABORTED, WebURL());
 }
 
 WebURLResponse TestResponseGenerator::Generate200() {
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpStatusCode(200);
 
   response.SetHttpHeaderField(
@@ -52,7 +52,7 @@ WebURLResponse TestResponseGenerator::GeneratePartial206(
     Flags flags) {
   int64_t range_content_length = content_length_ - first_byte_offset;
 
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpStatusCode(206);
 
   if ((flags & kNoAcceptRanges) == 0) {
@@ -82,7 +82,7 @@ WebURLResponse TestResponseGenerator::GeneratePartial206(
 }
 
 WebURLResponse TestResponseGenerator::GenerateResponse(int code) {
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpStatusCode(code);
   return response;
 }
@@ -93,7 +93,7 @@ WebURLResponse TestResponseGenerator::Generate404() {
 
 WebURLResponse TestResponseGenerator::GenerateFileResponse(
     int64_t first_byte_offset) {
-  WebURLResponse response(gurl_);
+  WebURLResponse response(url_);
   response.SetHttpStatusCode(0);
 
   if (first_byte_offset >= 0) {

third_party/blink/renderer/platform/media/testing/test_response_generator.h

@@ -7,9 +7,9 @@
 
 #include <stdint.h>
 
+#include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/public/platform/web_url_error.h"
 #include "third_party/blink/public/platform/web_url_response.h"
-#include "url/gurl.h"
 
 namespace blink {
 
@@ -26,7 +26,7 @@ class TestResponseGenerator {
 
   // Build an HTTP response generator for the given URL. |content_length| is
   // used to generate Content-Length and Content-Range headers.
-  TestResponseGenerator(const GURL& gurl, int64_t content_length);
+  TestResponseGenerator(const KURL& url, int64_t content_length);
   TestResponseGenerator(const TestResponseGenerator&) = delete;
   TestResponseGenerator& operator=(const TestResponseGenerator&) = delete;
 
@@ -73,7 +73,7 @@ class TestResponseGenerator {
   int64_t content_length() { return content_length_; }
 
  private:
-  GURL gurl_;
+  WebURL url_;
   int64_t content_length_;
 };
 

third_party/blink/renderer/platform/media/url_index.cc

@@ -15,6 +15,7 @@
 #include "base/time/time.h"
 #include "media/base/media_switches.h"
 #include "third_party/blink/renderer/platform/media/resource_multi_buffer_data_provider.h"
+#include "third_party/blink/renderer/platform/weborigin/security_origin.h"
 
 namespace blink {
 
@@ -49,7 +50,7 @@ void ResourceMultiBuffer::OnEmpty() {
 }
 
 UrlData::UrlData(base::PassKey<UrlIndex>,
-                 const GURL& url,
+                 const KURL& url,
                  CorsMode cors_mode,
                  UrlIndex* url_index,
                  CacheMode cache_lookup_mode,
@@ -60,7 +61,7 @@ UrlData::UrlData(base::PassKey<UrlIndex>,
               cache_lookup_mode,
               std::move(task_runner)) {}
 
-UrlData::UrlData(const GURL& url,
+UrlData::UrlData(const KURL& url,
                  CorsMode cors_mode,
                  UrlIndex* url_index,
                  CacheMode cache_lookup_mode,
@@ -78,7 +79,7 @@ UrlData::UrlData(const GURL& url,
 
 UrlData::~UrlData() = default;
 
-std::pair<GURL, UrlData::CorsMode> UrlData::key() const {
+std::pair<KURL, UrlData::CorsMode> UrlData::key() const {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   return std::make_pair(url(), cors_mode());
 }
@@ -174,14 +175,14 @@ void UrlData::Use() {
   last_used_ = base::Time::Now();
 }
 
-bool UrlData::ValidateDataOrigin(const GURL& origin) {
+bool UrlData::ValidateDataOrigin(const KURL& origin) {
   if (!have_data_origin_) {
     data_origin_ = origin;
     have_data_origin_ = true;
     return true;
   }
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED) {
-    return data_origin_ == origin;
+    return SecurityOrigin::SecurityOrigin::AreSameOrigin(data_origin_, origin);
   }
   // The actual cors checks is done in the net layer.
   return true;
@@ -258,7 +259,7 @@ UrlIndex::~UrlIndex() {
 #if DCHECK_IS_ON()
   // Verify that only |this| holds reference to UrlData instances.
   auto dcheck_has_one_ref = [](const UrlDataMap::value_type& entry) {
-    DCHECK(entry.second->HasOneRef());
+    DCHECK(entry.value->HasOneRef());
   };
   base::ranges::for_each(indexed_data_, dcheck_has_one_ref);
 #endif
@@ -268,25 +269,26 @@ void UrlIndex::RemoveUrlData(const scoped_refptr<UrlData>& url_data) {
   DCHECK(url_data->multibuffer()->map().empty());
 
   auto i = indexed_data_.find(url_data->key());
-  if (i != indexed_data_.end() && i->second == url_data)
+  if (i != indexed_data_.end() && i->value == url_data) {
     indexed_data_.erase(i);
+  }
 }
 
-scoped_refptr<UrlData> UrlIndex::GetByUrl(const GURL& gurl,
+scoped_refptr<UrlData> UrlIndex::GetByUrl(const KURL& url,
                                           UrlData::CorsMode cors_mode,
                                           UrlData::CacheMode cache_mode) {
   if (cache_mode == UrlData::kNormal) {
-    auto i = indexed_data_.find(std::make_pair(gurl, cors_mode));
-    if (i != indexed_data_.end() && i->second->Valid()) {
-      return i->second;
+    auto i = indexed_data_.find(std::make_pair(url, cors_mode));
+    if (i != indexed_data_.end() && i->value->Valid()) {
+      return i->value;
     }
   }
 
-  return NewUrlData(gurl, cors_mode, cache_mode);
+  return NewUrlData(url, cors_mode, cache_mode);
 }
 
 scoped_refptr<UrlData> UrlIndex::NewUrlData(
-    const GURL& url,
+    const KURL& url,
     UrlData::CorsMode cors_mode,
     UrlData::CacheMode cache_lookup_mode) {
   return base::MakeRefCounted<UrlData>(base::PassKey<UrlIndex>(), url,
@@ -333,7 +335,7 @@ scoped_refptr<UrlData> UrlIndex::TryInsert(
   if (iter == indexed_data_.end()) {
     // If valid and not already indexed, index it.
     if (url_data->Valid()) {
-      indexed_data_.insert(iter, std::make_pair(url_data->key(), url_data));
+      indexed_data_.insert(url_data->key(), url_data);
     }
     return url_data;
   }
@@ -342,14 +344,15 @@ scoped_refptr<UrlData> UrlIndex::TryInsert(
 
   // If the indexed instance is the same as |url_data|,
   // nothing needs to be done.
-  if (iter->second == url_data)
+  if (iter->value == url_data) {
     return url_data;
+  }
 
   // The indexed instance is different.
   // Check if it should be replaced with |url_data|.
-  if (IsNewDataForSameResource(url_data, iter->second)) {
+  if (IsNewDataForSameResource(url_data, iter->value)) {
     if (url_data->Valid()) {
-      iter->second = url_data;
+      iter->value = url_data;
     }
     return url_data;
   }
@@ -360,14 +363,14 @@ scoped_refptr<UrlData> UrlIndex::TryInsert(
   }
 
   if (url_data->Valid()) {
-    if ((!iter->second->Valid() ||
-         url_data->CachedSize() > iter->second->CachedSize())) {
-      iter->second = url_data;
+    if ((!iter->value->Valid() ||
+         url_data->CachedSize() > iter->value->CachedSize())) {
+      iter->value = url_data;
     } else {
-      iter->second->MergeFrom(url_data);
+      iter->value->MergeFrom(url_data);
     }
   }
-  return iter->second;
+  return iter->value;
 }
 
 }  // namespace blink

third_party/blink/renderer/platform/media/url_index.h

@@ -23,8 +23,9 @@
 #include "third_party/blink/renderer/platform/allow_discouraged_type.h"
 #include "third_party/blink/renderer/platform/media/multi_buffer.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
+#include "third_party/blink/renderer/platform/weborigin/kurl.h"
+#include "third_party/blink/renderer/platform/weborigin/kurl_hash.h"
 #include "third_party/blink/renderer/platform/wtf/ref_counted.h"
-#include "url/gurl.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -71,10 +72,10 @@ class PLATFORM_EXPORT UrlData : public RefCounted<UrlData> {
   // Keep in sync with WebMediaPlayer::CorsMode.
   enum CorsMode { CORS_UNSPECIFIED, CORS_ANONYMOUS, CORS_USE_CREDENTIALS };
   enum CacheMode { kNormal, kCacheDisabled };
-  using KeyType = std::pair<GURL, CorsMode>;
+  using KeyType = std::pair<KURL, CorsMode>;
 
   UrlData(base::PassKey<UrlIndex>,
-          const GURL& url,
+          const KURL& url,
           CorsMode cors_mode,
           UrlIndex* url_index,
           CacheMode cache_lookup_mode,
@@ -83,7 +84,7 @@ class PLATFORM_EXPORT UrlData : public RefCounted<UrlData> {
   UrlData& operator=(const UrlData&) = delete;
 
   // Accessors
-  const GURL& url() const { return url_; }
+  const KURL& url() const { return url_; }
 
   // Cross-origin access mode
   CorsMode cors_mode() const { return cors_mode_; }
@@ -145,7 +146,7 @@ class PLATFORM_EXPORT UrlData : public RefCounted<UrlData> {
   // If the multibuffer is empty, the data origin is set from
   // |origin| and returns true. If not, it compares |origin|
   // to the previous origin and returns whether they match or not.
-  bool ValidateDataOrigin(const GURL& origin);
+  bool ValidateDataOrigin(const KURL& origin);
 
   // Setters.
   void set_length(int64_t length);
@@ -186,7 +187,7 @@ class PLATFORM_EXPORT UrlData : public RefCounted<UrlData> {
   int64_t BytesReadFromCache() const { return bytes_read_from_cache_; }
 
  protected:
-  UrlData(const GURL& url,
+  UrlData(const KURL& url,
           CorsMode cors_mode,
           UrlIndex* url_index,
           CacheMode cache_lookup_mode,
@@ -203,11 +204,11 @@ class PLATFORM_EXPORT UrlData : public RefCounted<UrlData> {
 
   // Url we represent, note that there may be multiple UrlData for
   // the same url.
-  const GURL url_ ALLOW_DISCOURAGED_TYPE("TODO(crbug.com/40760651)");
+  const KURL url_;
 
   // Origin of the data, should only be different from the
   // url_.DeprecatedGetOriginAsURL() when service workers are involved.
-  GURL data_origin_ ALLOW_DISCOURAGED_TYPE("TODO(crbug.com/40760651)");
+  KURL data_origin_;
   bool have_data_origin_;
 
   // Cross-origin access mode.
@@ -284,7 +285,7 @@ class PLATFORM_EXPORT UrlIndex {
   // ranges and it's last modified time.
   // Because the returned UrlData has a raw reference to |this|, it must be
   // released before |this| is destroyed.
-  scoped_refptr<UrlData> GetByUrl(const GURL& gurl,
+  scoped_refptr<UrlData> GetByUrl(const KURL& gurl,
                                   UrlData::CorsMode cors_mode,
                                   UrlData::CacheMode cache_mode);
 
@@ -320,7 +321,7 @@ class PLATFORM_EXPORT UrlIndex {
 
   // Virtual so we can override it in tests.
   virtual scoped_refptr<UrlData> NewUrlData(
-      const GURL& url,
+      const KURL& url,
       UrlData::CorsMode cors_mode,
       UrlData::CacheMode cache_lookup_mode);
 
@@ -328,8 +329,8 @@ class PLATFORM_EXPORT UrlIndex {
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
   raw_ptr<ResourceFetchContext> fetch_context_;
-  using UrlDataMap = std::map<UrlData::KeyType, scoped_refptr<UrlData>>;
-  UrlDataMap indexed_data_ ALLOW_DISCOURAGED_TYPE("TODO(crbug.com/40760651)");
+  using UrlDataMap = HashMap<UrlData::KeyType, scoped_refptr<UrlData>>;
+  UrlDataMap indexed_data_;
   scoped_refptr<MultiBuffer::GlobalLRU> lru_;
 
   // log2 of block size in multibuffer cache. Defaults to kBlockSizeShift.

third_party/blink/renderer/platform/media/url_index_unittest.cc

@@ -23,11 +23,11 @@ class UrlIndexTest : public testing::Test {
  public:
   UrlIndexTest() = default;
 
-  scoped_refptr<UrlData> GetByUrl(const GURL& gurl,
+  scoped_refptr<UrlData> GetByUrl(const KURL& url,
                                   UrlData::CorsMode cors_mode) {
     scoped_refptr<UrlData> ret =
-        url_index_.GetByUrl(gurl, cors_mode, UrlData::kNormal);
-    EXPECT_EQ(ret->url(), gurl);
+        url_index_.GetByUrl(url, cors_mode, UrlData::kNormal);
+    EXPECT_EQ(ret->url(), url);
     EXPECT_EQ(ret->cors_mode(), cors_mode);
     return ret;
   }
@@ -38,8 +38,8 @@ class UrlIndexTest : public testing::Test {
 };
 
 TEST_F(UrlIndexTest, SimpleTest) {
-  GURL url1("http://foo.bar.com");
-  GURL url2("http://foo.bar.com/urgel");
+  KURL url1("http://foo.bar.com");
+  KURL url2("http://foo.bar.com/urgel");
   scoped_refptr<UrlData> a = GetByUrl(url1, UrlData::CORS_UNSPECIFIED);
   // Make sure it's valid, we still shouldn't get the same one.
   a->Use();
@@ -75,7 +75,7 @@ TEST_F(UrlIndexTest, SimpleTest) {
 }
 
 TEST_F(UrlIndexTest, UrlDataTest) {
-  GURL url("http://foo.bar.com");
+  KURL url("http://foo.bar.com");
   scoped_refptr<UrlData> a = GetByUrl(url, UrlData::CORS_UNSPECIFIED);
 
   // Check default values.
@@ -103,7 +103,7 @@ TEST_F(UrlIndexTest, UrlDataTest) {
 }
 
 TEST_F(UrlIndexTest, UseTest) {
-  GURL url("http://foo.bar.com");
+  KURL url("http://foo.bar.com");
   scoped_refptr<UrlData> a = GetByUrl(url, UrlData::CORS_UNSPECIFIED);
   EXPECT_FALSE(a->Valid());
   a->Use();
@@ -112,7 +112,7 @@ TEST_F(UrlIndexTest, UseTest) {
 }
 
 TEST_F(UrlIndexTest, TryInsert) {
-  GURL url("http://foo.bar.com");
+  KURL url("http://foo.bar.com");
   scoped_refptr<UrlData> a = GetByUrl(url, UrlData::CORS_UNSPECIFIED);
   scoped_refptr<UrlData> c = GetByUrl(url, UrlData::CORS_UNSPECIFIED);
   EXPECT_NE(a, c);
@@ -162,7 +162,7 @@ TEST_F(UrlIndexTest, TryInsert) {
 }
 
 TEST_F(UrlIndexTest, GetByUrlCacheDisabled) {
-  GURL url("http://foo.bar.com");
+  KURL url("http://foo.bar.com");
   UrlData::CorsMode cors = UrlData::CORS_UNSPECIFIED;
 
   scoped_refptr<UrlData> url_data =

third_party/blink/renderer/platform/media/web_content_decryption_module_session_impl.cc

@@ -32,10 +32,10 @@
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/public/platform/web_vector.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/renderer/platform/media/cdm_result_promise.h"
 #include "third_party/blink/renderer/platform/media/cdm_result_promise_helper.h"
 #include "third_party/blink/renderer/platform/media/cdm_session_adapter.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 
 namespace blink {
 

third_party/blink/renderer/platform/media/web_media_player_builder.cc

@@ -23,11 +23,11 @@
 #include "third_party/blink/public/platform/media/web_media_player_delegate.h"
 #include "third_party/blink/public/platform/web_content_decryption_module.h"
 #include "third_party/blink/public/platform/web_media_player.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_encrypted_media_client.h"
 #include "third_party/blink/public/web/web_associated_url_loader.h"
 #include "third_party/blink/public/web/web_associated_url_loader_options.h"
 #include "third_party/blink/public/web/web_local_frame.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/media/resource_fetch_context.h"
 #include "third_party/blink/renderer/platform/media/url_index.h"
 #include "third_party/blink/renderer/platform/media/web_media_player_impl.h"
@@ -99,8 +99,9 @@ std::unique_ptr<WebMediaPlayer> WebMediaPlayerBuilder::Build(
   DCHECK_EQ(&static_cast<FrameFetchContext*>(fetch_context_.get())->frame(),
             frame);
   return std::make_unique<WebMediaPlayerImpl>(
-      frame, client, encrypted_client, delegate, std::move(factory_selector),
-      url_index_.get(), std::move(compositor), std::move(media_log), player_id,
+      frame, static_cast<MediaPlayerClient*>(client), encrypted_client,
+      delegate, std::move(factory_selector), url_index_.get(),
+      std::move(compositor), std::move(media_log), player_id,
       std::move(defer_load_cb), std::move(audio_renderer_sink),
       std::move(media_task_runner), std::move(worker_task_runner),
       std::move(compositor_task_runner),

third_party/blink/renderer/platform/media/web_media_player_impl.cc

@@ -62,6 +62,7 @@
 #include "media/learning/common/media_learning_tasks.h"
 #include "media/learning/mojo/public/cpp/mojo_learning_task_controller.h"
 #include "media/media_buildflags.h"
+#include "media/mojo/mojom/media_metrics_provider.mojom-blink.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "net/base/data_url.h"
@@ -75,7 +76,6 @@
 #include "third_party/blink/public/platform/web_content_decryption_module.h"
 #include "third_party/blink/public/platform/web_encrypted_media_types.h"
 #include "third_party/blink/public/platform/web_fullscreen_video_status.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_encrypted_media_client.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
 #include "third_party/blink/public/platform/web_media_source.h"
@@ -85,12 +85,12 @@
 #include "third_party/blink/public/platform/web_surface_layer_bridge.h"
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/public/strings/grit/blink_strings.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/web_frame.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/public/web/web_view.h"
 #include "third_party/blink/renderer/platform/media/buffered_data_source_host_impl.h"
+#include "third_party/blink/renderer/platform/media/media_player_util.h"
 #include "third_party/blink/renderer/platform/media/power_status_helper.h"
 #include "third_party/blink/renderer/platform/media/url_index.h"
 #include "third_party/blink/renderer/platform/media/video_decode_stats_reporter.h"
@@ -194,11 +194,9 @@ int GetSwitchToLocalMessage(
     case media::MediaObserverClient::ReasonToSwitchToLocal::PIPELINE_ERROR:
       return IDS_MEDIA_REMOTING_STOP_BY_ERROR_TEXT;
     case media::MediaObserverClient::ReasonToSwitchToLocal::ROUTE_TERMINATED:
-      return WebMediaPlayerClient::kMediaRemotingStopNoText;
+      return MediaPlayerClient::kMediaRemotingStopNoText;
   }
-  NOTREACHED_IN_MIGRATION();
-  // To suppress compiler warning on Windows.
-  return WebMediaPlayerClient::kMediaRemotingStopNoText;
+  NOTREACHED();
 }
 
 // These values are persisted to UMA. Entries should not be renumbered and
@@ -337,6 +335,50 @@ bool UsesAudioService(media::RendererType renderer_type) {
   return renderer_type != media::RendererType::kMediaFoundation;
 }
 
+WebTimeRanges ConvertToWebTimeRanges(
+    const media::Ranges<base::TimeDelta>& ranges) {
+  WebTimeRanges result(ranges.size());
+  for (size_t i = 0; i < ranges.size(); ++i) {
+    result[i].start = ranges.start(i).InSecondsF();
+    result[i].end = ranges.end(i).InSecondsF();
+  }
+  return result;
+}
+
+WebMediaPlayer::NetworkState PipelineErrorToNetworkState(
+    media::PipelineStatus error) {
+  switch (error.code()) {
+    case media::PIPELINE_ERROR_NETWORK:
+    case media::PIPELINE_ERROR_READ:
+    case media::CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR:
+      return WebMediaPlayer::kNetworkStateNetworkError;
+
+    case media::PIPELINE_ERROR_INITIALIZATION_FAILED:
+    case media::PIPELINE_ERROR_COULD_NOT_RENDER:
+    case media::PIPELINE_ERROR_EXTERNAL_RENDERER_FAILED:
+    case media::DEMUXER_ERROR_COULD_NOT_OPEN:
+    case media::DEMUXER_ERROR_COULD_NOT_PARSE:
+    case media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS:
+    case media::DEMUXER_ERROR_DETECTED_HLS:
+    case media::DECODER_ERROR_NOT_SUPPORTED:
+      return WebMediaPlayer::kNetworkStateFormatError;
+
+    case media::PIPELINE_ERROR_DECODE:
+    case media::PIPELINE_ERROR_ABORT:
+    case media::PIPELINE_ERROR_INVALID_STATE:
+    case media::PIPELINE_ERROR_HARDWARE_CONTEXT_RESET:
+    case media::PIPELINE_ERROR_DISCONNECTED:
+    case media::CHUNK_DEMUXER_ERROR_APPEND_FAILED:
+    case media::CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR:
+    case media::AUDIO_RENDERER_ERROR:
+      return WebMediaPlayer::kNetworkStateDecodeError;
+
+    case media::PIPELINE_OK:
+      NOTREACHED_IN_MIGRATION() << "Unexpected status! " << error;
+  }
+  return WebMediaPlayer::kNetworkStateFormatError;
+}
+
 }  // namespace
 
 STATIC_ASSERT_ENUM(WebMediaPlayer::kCorsModeUnspecified,
@@ -347,7 +389,7 @@ STATIC_ASSERT_ENUM(WebMediaPlayer::kCorsModeUseCredentials,
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebLocalFrame* frame,
-    WebMediaPlayerClient* client,
+    MediaPlayerClient* client,
     WebMediaPlayerEncryptedMediaClient* encrypted_client,
     WebMediaPlayerDelegate* delegate,
     std::unique_ptr<media::RendererFactorySelector> renderer_factory_selector,
@@ -503,7 +545,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
 
   auto on_audio_source_provider_set_client_callback = base::BindOnce(
       [](base::WeakPtr<WebMediaPlayerImpl> self,
-         WebMediaPlayerClient* const client) {
+         MediaPlayerClient* const client) {
         if (!self)
           return;
         client->DidDisableAudioOutputSinkChanges();
@@ -585,7 +627,7 @@ WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   // Destruct compositor resources in the proper order.
   client_->SetCcLayer(nullptr);
 
-  client_->MediaRemotingStopped(WebMediaPlayerClient::kMediaRemotingStopNoText);
+  client_->MediaRemotingStopped(MediaPlayerClient::kMediaRemotingStopNoText);
 
   if (!surface_layer_for_video_enabled_ && video_layer_)
     video_layer_->StopUsingProvider();
@@ -641,8 +683,8 @@ WebMediaPlayer::LoadTiming WebMediaPlayerImpl::Load(
   // Only URL or MSE blob URL is supported.
   DCHECK(source.IsURL());
   WebURL url = source.GetAsURL();
-  DVLOG(1) << __func__ << "(" << load_type << ", " << GURL(url) << ", "
-           << cors_mode << ")";
+  DVLOG(1) << __func__ << "(" << load_type << ", " << url << ", " << cors_mode
+           << ")";
 
   bool is_deferred = false;
 
@@ -822,7 +864,7 @@ void WebMediaPlayerImpl::OnDisplayTypeChanged(DisplayType display_type) {
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
-                                const WebURL& url,
+                                const KURL& url,
                                 CorsMode cors_mode,
                                 bool is_cache_disabled) {
   TRACE_EVENT1("media", "WebMediaPlayerImpl::DoLoad", "id", media_player_id_);
@@ -852,7 +894,7 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
   demuxer_manager_->SetLoadedUrl(GURL(url));
   load_type_ = load_type;
 
-  ReportMetrics(load_type, demuxer_manager_->LoadedUrl(), media_log_.get());
+  ReportMetrics(load_type, url, media_log_.get());
 
   // Set subresource URL for crash reporting; will be truncated to 256 bytes.
   static base::debug::CrashKeyString* subresource_url =
@@ -866,7 +908,7 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
 
   // Do a truncation to kMaxUrlLength+1 at most; we can add ellipsis later.
   media_log_->AddEvent<MediaLogEvent::kLoad>(
-      url.GetString().Substring(0, media::kMaxUrlLength + 1).Utf8());
+      String(url).Substring(0, media::kMaxUrlLength + 1).Utf8());
   load_start_time_ = base::TimeTicks::Now();
 
   // If we're adapting, then restart the smoothness experiment.
@@ -875,10 +917,9 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
 
   media_metrics_provider_->Initialize(
       load_type == kLoadTypeMediaSource,
-      load_type == kLoadTypeURL
-          ? GetMediaURLScheme(demuxer_manager_->LoadedUrl())
-          : media::mojom::MediaURLScheme::kUnknown,
-      media::mojom::MediaStreamType::kNone);
+      load_type == kLoadTypeURL ? GetMediaURLScheme(url)
+                                : media::mojom::blink::MediaURLScheme::kUnknown,
+      media::mojom::blink::MediaStreamType::kNone);
 
   // If a demuxer override was specified or a Media Source pipeline will be
   // used, the pipeline can start immediately.
@@ -1644,7 +1685,7 @@ void WebMediaPlayerImpl::GetUrlData(
     base::OnceCallback<void(scoped_refptr<UrlData>)> cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   auto url_data = url_index_->GetByUrl(
-      gurl, static_cast<UrlData::CorsMode>(cors_mode_),
+      KURL(gurl), static_cast<UrlData::CorsMode>(cors_mode_),
       (is_cache_disabled_ || ignore_cache) ? UrlData::kCacheDisabled
                                            : UrlData::kNormal);
   std::move(cb).Run(std::move(url_data));
@@ -2741,7 +2782,7 @@ void WebMediaPlayerImpl::OnRemotePlayStateChange(
   } else if (state == media::MediaStatus::State::kPaused && !Paused()) {
     DVLOG(1) << __func__ << " requesting PAUSE.";
     client_->PausePlayback(
-        WebMediaPlayerClient::PauseReason::kRemotePlayStateChange);
+        MediaPlayerClient::PauseReason::kRemotePlayStateChange);
   }
 }
 #endif  // BUILDFLAG(IS_ANDROID)
@@ -3465,8 +3506,8 @@ void WebMediaPlayerImpl::ScheduleIdlePauseTimer() {
   background_pause_timer_.Start(
       FROM_HERE, base::Seconds(5),
       base::BindOnce(
-          &WebMediaPlayerClient::PausePlayback, base::Unretained(client_),
-          WebMediaPlayerClient::PauseReason::kSuspendedPlayerIdleTimeout));
+          &MediaPlayerClient::PausePlayback, base::Unretained(client_),
+          MediaPlayerClient::PauseReason::kSuspendedPlayerIdleTimeout));
 }
 
 void WebMediaPlayerImpl::CreateWatchTimeReporter() {
@@ -3557,13 +3598,13 @@ bool WebMediaPlayerImpl::IsFrameHidden() const {
 bool WebMediaPlayerImpl::IsPausedBecausePageHidden() const {
   return visibility_pause_reason_ &&
          visibility_pause_reason_ ==
-             WebMediaPlayerClient::PauseReason::kPageHidden;
+             MediaPlayerClient::PauseReason::kPageHidden;
 }
 
 bool WebMediaPlayerImpl::IsPausedBecauseFrameHidden() const {
   return visibility_pause_reason_ &&
          visibility_pause_reason_ ==
-             WebMediaPlayerClient::PauseReason::kFrameHidden;
+             MediaPlayerClient::PauseReason::kFrameHidden;
 }
 
 bool WebMediaPlayerImpl::IsStreaming() const {
@@ -3578,8 +3619,8 @@ bool WebMediaPlayerImpl::DoesOverlaySupportMetadata() const {
 void WebMediaPlayerImpl::UpdateRemotePlaybackCompatibility(bool is_compatible) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  client_->RemotePlaybackCompatibilityChanged(demuxer_manager_->LoadedUrl(),
-                                              is_compatible);
+  client_->RemotePlaybackCompatibilityChanged(
+      KURL(demuxer_manager_->LoadedUrl()), is_compatible);
 }
 
 void WebMediaPlayerImpl::ForceStaleStateForTesting(ReadyState target_state) {
@@ -3778,9 +3819,9 @@ void WebMediaPlayerImpl::PauseVideoIfNeeded() {
       seeking_ || paused_)
     return;
 
-  auto pause_reason = WebMediaPlayerClient::PauseReason::kPageHidden;
+  auto pause_reason = MediaPlayerClient::PauseReason::kPageHidden;
   if (IsFrameHidden() && should_pause_when_frame_is_hidden_) {
-    pause_reason = WebMediaPlayerClient::PauseReason::kFrameHidden;
+    pause_reason = MediaPlayerClient::PauseReason::kFrameHidden;
   }
 
   // client_->PausePlayback() will get `visibility_pause_reason_` set to

third_party/blink/renderer/platform/media/web_media_player_impl.h

@@ -50,12 +50,11 @@
 #include "third_party/blink/public/platform/web_audio_source_provider.h"
 #include "third_party/blink/public/platform/web_content_decryption_module_result.h"
 #include "third_party/blink/public/platform/web_media_player.h"
-#include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_surface_layer_bridge.h"
-#include "third_party/blink/public/web/modules/media/web_media_player_util.h"
 #include "third_party/blink/renderer/platform/allow_discouraged_type.h"
 #include "third_party/blink/renderer/platform/bindings/v8_external_memory_accounter.h"
 #include "third_party/blink/renderer/platform/media/learning_experiment_helper.h"
+#include "third_party/blink/renderer/platform/media/media_player_client.h"
 #include "third_party/blink/renderer/platform/media/multi_buffer_data_source.h"
 #include "third_party/blink/renderer/platform/media/smoothness_helper.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
@@ -133,7 +132,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
   // |delegate| and |renderer_factory_selector| must not be null.
   WebMediaPlayerImpl(
       WebLocalFrame* frame,
-      WebMediaPlayerClient* client,
+      MediaPlayerClient* client,
       WebMediaPlayerEncryptedMediaClient* encrypted_client,
       WebMediaPlayerDelegate* delegate,
       std::unique_ptr<media::RendererFactorySelector> renderer_factory_selector,
@@ -469,7 +468,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
   // 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 WebURL& url,
+              const KURL& url,
               CorsMode cors_mode,
               bool is_cache_disabled);
 
@@ -811,7 +810,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
   // Set if paused automatically when hidden. Reset if paused for any other
   // reason. If set to PauseReason::kPageHidden, playback should be resumed when
   // the page becomes visible.
-  std::optional<WebMediaPlayerClient::PauseReason> visibility_pause_reason_;
+  std::optional<MediaPlayerClient::PauseReason> visibility_pause_reason_;
 
   // Set when starting, seeking, and resuming (all of which require a Pipeline
   // seek). |seek_time_| is only valid when |seeking_| is true.
@@ -842,7 +841,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
   // Whether the current decoder requires a restart on overlay transitions.
   bool decoder_requires_restart_for_overlay_ = false;
 
-  const raw_ptr<WebMediaPlayerClient> client_;
+  const raw_ptr<MediaPlayerClient> client_;
   const raw_ptr<WebMediaPlayerEncryptedMediaClient> encrypted_client_;
 
   // WebMediaPlayer notifies the |delegate_| of playback state changes using

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -1257,6 +1257,8 @@ _CONFIG = [
     {
         'paths': [
             'third_party/blink/public/platform/web_audio_device.h',
+            'third_party/blink/public/web/web_local_frame_client.h',
+            'third_party/blink/renderer/modules/audio_output_devices/html_media_element_audio_output_device.cc',
         ],
         'allowed': [
             'media::OutputDeviceStatus',
@@ -2299,6 +2301,14 @@ _CONFIG = [
             'gpu::SharedImageInterface',
         ]
     },
+    {
+        'paths': [
+            'third_party/blink/public/platform/web_media_player_client.h',
+        ],
+        'allowed': [
+            'media::.+',
+        ]
+    },
 ]