Remove unused `is_remote` argument from playback start message

This is done in preparation for further work in issue 1091203.  No
functionality is changed as `is_remote` was always false outside of
tests.

Bug: 1091203
Change-Id: Ia32c07c628e2aa92bd6e5ae1676207d3df8050f9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2256203
Commit-Queue: Wojciech Dzierżanowski <wdzierzanowski@opera.com>
Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#783878}

content/browser/media/media_web_contents_observer.cc

@@ -217,14 +217,7 @@ void MediaWebContentsObserver::OnMediaPlaying(
     int delegate_id,
     bool has_video,
     bool has_audio,
-    bool is_remote,
     media::MediaContentType media_content_type) {
-  // TODO(mlamouri): this used to be done to avoid video wake lock. However, it
-  // was doing much more. Removing will be done in a follow-up CL to avoid
-  // regressions to be pinpoint to the wake lock refactor.
-  if (is_remote)
-    return;
-
   const MediaPlayerId id(render_frame_host, delegate_id);
   if (has_audio)
     AddMediaPlayerEntry(id, &active_audio_players_);
@@ -233,7 +226,7 @@ void MediaWebContentsObserver::OnMediaPlaying(
     AddMediaPlayerEntry(id, &active_video_players_);
 
   if (!session_controllers_manager_.RequestPlay(
-          id, has_audio, is_remote, media_content_type, has_video)) {
+          id, has_audio, media_content_type, has_video)) {
     return;
   }
 

content/browser/media/media_web_contents_observer.h

@@ -121,7 +121,6 @@ class CONTENT_EXPORT MediaWebContentsObserver : public WebContentsObserver {
                       int delegate_id,
                       bool has_video,
                       bool has_audio,
-                      bool is_remote,
                       media::MediaContentType media_content_type);
   void OnMediaEffectivelyFullscreenChanged(
       RenderFrameHost* render_frame_host,

content/browser/media/session/media_session_controller.cc

@@ -28,13 +28,11 @@ MediaSessionController::~MediaSessionController() {
 
 bool MediaSessionController::Initialize(
     bool has_audio,
-    bool is_remote,
     media::MediaContentType media_content_type,
     media_session::MediaPosition* position,
     bool is_pip_available,
     bool has_video) {
   // Store these as we will need them later.
-  is_remote_ = is_remote;
   has_audio_ = has_audio;
   has_video_ = has_video;
   media_content_type_ = media_content_type;
@@ -170,9 +168,8 @@ bool MediaSessionController::IsMediaSessionNeeded() const {
   const bool has_audio =
       has_audio_ &&
       !media_web_contents_observer_->web_contents()->IsAudioMuted();
-  return !is_remote_ &&
-         (has_audio || media_web_contents_observer_->web_contents()
-                           ->HasPictureInPictureVideo());
+  return has_audio || media_web_contents_observer_->web_contents()
+                          ->HasPictureInPictureVideo();
 }
 
 void MediaSessionController::AddOrRemovePlayer() {

content/browser/media/session/media_session_controller.h

@@ -34,7 +34,6 @@ class CONTENT_EXPORT MediaSessionController
   // returns false.  May be called more than once; does nothing if none of the
   // input parameters have changed since the last call.
   bool Initialize(bool has_audio,
-                  bool is_remote,
                   media::MediaContentType media_content_type,
                   media_session::MediaPosition* position,
                   bool is_pip_available,
@@ -98,7 +97,6 @@ class CONTENT_EXPORT MediaSessionController
   bool has_session_ = false;
   bool has_audio_ = false;
   bool has_video_ = false;
-  bool is_remote_ = false;
   bool is_picture_in_picture_available_ = false;
   media::MediaContentType media_content_type_ =
       media::MediaContentType::Persistent;

content/browser/media/session/media_session_controller_unittest.cc

@@ -146,30 +146,22 @@ class MediaSessionControllerTest : public RenderViewHostImplTestHarness {
 };
 
 TEST_F(MediaSessionControllerTest, NoAudioNoSession) {
-  ASSERT_TRUE(controller_->Initialize(false, false,
-                                      media::MediaContentType::Persistent,
-                                      nullptr, false, false));
-  EXPECT_FALSE(media_session()->IsActive());
-  EXPECT_FALSE(media_session()->IsControllable());
-}
-
-TEST_F(MediaSessionControllerTest, IsRemoteNoSession) {
   ASSERT_TRUE(controller_->Initialize(
-      true, true, media::MediaContentType::Persistent, nullptr, false, false));
+      false, media::MediaContentType::Persistent, nullptr, false, false));
   EXPECT_FALSE(media_session()->IsActive());
   EXPECT_FALSE(media_session()->IsControllable());
 }
 
 TEST_F(MediaSessionControllerTest, TransientNoControllableSession) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Transient, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Transient,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_FALSE(media_session()->IsControllable());
 }
 
 TEST_F(MediaSessionControllerTest, BasicControls) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_TRUE(media_session()->IsControllable());
 
@@ -199,8 +191,8 @@ TEST_F(MediaSessionControllerTest, BasicControls) {
 }
 
 TEST_F(MediaSessionControllerTest, VolumeMultiplier) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_TRUE(media_session()->IsControllable());
 
@@ -216,8 +208,8 @@ TEST_F(MediaSessionControllerTest, VolumeMultiplier) {
 }
 
 TEST_F(MediaSessionControllerTest, ControllerSidePause) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_TRUE(media_session()->IsControllable());
 
@@ -227,29 +219,28 @@ TEST_F(MediaSessionControllerTest, ControllerSidePause) {
   EXPECT_TRUE(media_session()->IsControllable());
 
   // Verify the next Initialize() call restores the session.
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_TRUE(media_session()->IsControllable());
 }
 
 TEST_F(MediaSessionControllerTest, Reinitialize) {
-  ASSERT_TRUE(controller_->Initialize(false, false,
-                                      media::MediaContentType::Persistent,
-                                      nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(
+      false, media::MediaContentType::Persistent, nullptr, false, false));
   EXPECT_FALSE(media_session()->IsActive());
   EXPECT_FALSE(media_session()->IsControllable());
 
   // Create a transient type session.
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Transient, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Transient,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_FALSE(media_session()->IsControllable());
   const int current_player_id = controller_->get_player_id_for_testing();
 
   // Reinitialize the session as a content type.
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
   EXPECT_TRUE(media_session()->IsControllable());
   // Player id should not change when there's an active session.
@@ -263,13 +254,6 @@ TEST_F(MediaSessionControllerTest, Reinitialize) {
   // Likewise verify the resume behavior.
   Resume();
   EXPECT_TRUE(ReceivedMessagePlay<MediaPlayerDelegateMsg_Play>());
-
-  // Switch to a remote player, which should release the session.
-  ASSERT_TRUE(controller_->Initialize(
-      true, true, media::MediaContentType::Persistent, nullptr, false, false));
-  EXPECT_FALSE(media_session()->IsActive());
-  EXPECT_FALSE(media_session()->IsControllable());
-  EXPECT_EQ(current_player_id, controller_->get_player_id_for_testing());
 }
 
 TEST_F(MediaSessionControllerTest, PositionState) {
@@ -277,7 +261,7 @@ TEST_F(MediaSessionControllerTest, PositionState) {
     media_session::MediaPosition expected_position(1.0, base::TimeDelta(),
                                                    base::TimeDelta());
 
-    ASSERT_TRUE(controller_->Initialize(true, true,
+    ASSERT_TRUE(controller_->Initialize(true,
                                         media::MediaContentType::Persistent,
                                         &expected_position, false, false));
 
@@ -297,8 +281,8 @@ TEST_F(MediaSessionControllerTest, PositionState) {
 }
 
 TEST_F(MediaSessionControllerTest, RemovePlayerIfSessionReset) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_TRUE(media_session()->IsActive());
 
   ResetHasSessionBit();
@@ -309,8 +293,8 @@ TEST_F(MediaSessionControllerTest, RemovePlayerIfSessionReset) {
 }
 
 TEST_F(MediaSessionControllerTest, PictureInPictureAvailability) {
-  ASSERT_TRUE(controller_->Initialize(
-      true, false, media::MediaContentType::Persistent, nullptr, false, false));
+  ASSERT_TRUE(controller_->Initialize(true, media::MediaContentType::Persistent,
+                                      nullptr, false, false));
   EXPECT_FALSE(controller_->IsPictureInPictureAvailable(
       controller_->get_player_id_for_testing()));
 
@@ -323,8 +307,7 @@ TEST_F(MediaSessionControllerTest, AddPlayerWhenUnmuted) {
   contents()->SetAudioMuted(true);
 
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_FALSE(media_session()->IsActive());
 
@@ -335,8 +318,7 @@ TEST_F(MediaSessionControllerTest, AddPlayerWhenUnmuted) {
 
 TEST_F(MediaSessionControllerTest, RemovePlayerWhenMuted) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_TRUE(media_session()->IsActive());
 
@@ -349,8 +331,7 @@ TEST_F(MediaSessionControllerTest, EnterLeavePictureInPictureMuted) {
   contents()->SetAudioMuted(true);
 
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_FALSE(media_session()->IsActive());
 
@@ -367,8 +348,7 @@ TEST_F(MediaSessionControllerTest, EnterLeavePictureInPictureMuted) {
 
 TEST_F(MediaSessionControllerTest, MuteWithPictureInPicture) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   contents()->SetHasPictureInPictureVideo(true);
   controller_->PictureInPictureStateChanged(true);
@@ -383,8 +363,7 @@ TEST_F(MediaSessionControllerTest, LeavePictureInPictureUnmuted) {
   contents()->SetAudioMuted(true);
 
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_FALSE(media_session()->IsActive());
 
@@ -402,14 +381,12 @@ TEST_F(MediaSessionControllerTest, LeavePictureInPictureUnmuted) {
 
 TEST_F(MediaSessionControllerTest, AddPlayerWhenAddingAudio) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ false, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ false, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_FALSE(media_session()->IsActive());
 
   EXPECT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   EXPECT_TRUE(media_session()->IsActive());
 }
@@ -417,8 +394,7 @@ TEST_F(MediaSessionControllerTest, AddPlayerWhenAddingAudio) {
 TEST_F(MediaSessionControllerTest,
        AddPlayerWhenEnteringPictureInPictureWithNoAudio) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ false, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ false, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   ASSERT_FALSE(media_session()->IsActive());
 
@@ -432,8 +408,7 @@ TEST_F(MediaSessionControllerTest,
   contents()->SetHasPictureInPictureVideo(true);
 
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ false, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ false, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   EXPECT_TRUE(media_session()->IsActive());
 
@@ -445,16 +420,14 @@ TEST_F(MediaSessionControllerTest,
 
 TEST_F(MediaSessionControllerTest, HasVideo_True) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ true, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ true, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ true));
   EXPECT_TRUE(controller_->HasVideo(controller_->get_player_id_for_testing()));
 }
 
 TEST_F(MediaSessionControllerTest, HasVideo_False) {
   ASSERT_TRUE(controller_->Initialize(
-      /* has_audio = */ false, /* is_remote = */ false,
-      media::MediaContentType::Persistent, nullptr,
+      /* has_audio = */ false, media::MediaContentType::Persistent, nullptr,
       /* is_pip_available = */ true, /* has_video = */ false));
   EXPECT_FALSE(controller_->HasVideo(controller_->get_player_id_for_testing()));
 }

content/browser/media/session/media_session_controllers_manager.cc

@@ -43,7 +43,6 @@ void MediaSessionControllersManager::RenderFrameDeleted(
 bool MediaSessionControllersManager::RequestPlay(
     const MediaPlayerId& id,
     bool has_audio,
-    bool is_remote,
     media::MediaContentType media_content_type,
     bool has_video) {
   if (!IsMediaSessionEnabled())
@@ -69,8 +68,8 @@ bool MediaSessionControllersManager::RequestPlay(
   // controller. A later playback attempt will create a new controller.
   auto it = controllers_map_.find(id);
   if (it != controllers_map_.end()) {
-    if (it->second->Initialize(has_audio, is_remote, media_content_type,
-                               position, is_pip_available, has_video)) {
+    if (it->second->Initialize(has_audio, media_content_type, position,
+                               is_pip_available, has_video)) {
       return true;
     }
 
@@ -80,8 +79,8 @@ bool MediaSessionControllersManager::RequestPlay(
   std::unique_ptr<MediaSessionController> controller(
       new MediaSessionController(id, media_web_contents_observer_));
 
-  if (!controller->Initialize(has_audio, is_remote, media_content_type,
-                              position, is_pip_available, has_video)) {
+  if (!controller->Initialize(has_audio, media_content_type, position,
+                              is_pip_available, has_video)) {
     return false;
   }
 

content/browser/media/session/media_session_controllers_manager.h

@@ -50,7 +50,6 @@ class CONTENT_EXPORT MediaSessionControllersManager {
   // Returns whether the player was added to the session and can start playing.
   bool RequestPlay(const MediaPlayerId& id,
                    bool has_audio,
-                   bool is_remote,
                    media::MediaContentType media_content_type,
                    bool has_video);
 

content/browser/media/session/media_session_controllers_manager_unittest.cc

@@ -133,15 +133,15 @@ class MediaSessionControllersManagerTest
 TEST_P(MediaSessionControllersManagerTest, RequestPlayAddsSessionsToMap) {
   EXPECT_TRUE(GetControllersMap()->empty());
 
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true,
                                     media::MediaContentType::Transient, false));
   if (!IsMediaSessionEnabled()) {
     EXPECT_TRUE(GetControllersMap()->empty());
   } else {
     EXPECT_EQ(1U, GetControllersMap()->size());
-    EXPECT_TRUE(manager_->RequestPlay(
-        MediaPlayerId(contents()->GetMainFrame(), 2), true, false,
-        media::MediaContentType::Transient, false));
+    EXPECT_TRUE(
+        manager_->RequestPlay(MediaPlayerId(contents()->GetMainFrame(), 2),
+                              true, media::MediaContentType::Transient, false));
     EXPECT_EQ(2U, GetControllersMap()->size());
   }
 }
@@ -153,11 +153,11 @@ TEST_P(MediaSessionControllersManagerTest, RepeatAddsOfInitializablePlayer) {
 
   EXPECT_TRUE(GetControllersMap()->empty());
 
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true,
                                     media::MediaContentType::Transient, false));
   EXPECT_EQ(1U, GetControllersMap()->size());
 
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true,
                                     media::MediaContentType::Transient, false));
   EXPECT_EQ(1U, GetControllersMap()->size());
 }
@@ -175,9 +175,8 @@ TEST_P(MediaSessionControllersManagerTest, RenderFrameDeletedRemovesHost) {
     manager_->RenderFrameDeleted(contents()->GetMainFrame());
     EXPECT_EQ(1U, GetControllersMap()->size());
   } else {
-    EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
-                                      media::MediaContentType::Transient,
-                                      false));
+    EXPECT_TRUE(manager_->RequestPlay(
+        media_player_id_, true, media::MediaContentType::Transient, false));
     EXPECT_EQ(1U, GetControllersMap()->size());
 
     manager_->RenderFrameDeleted(contents()->GetMainFrame());
@@ -221,9 +220,8 @@ TEST_P(MediaSessionControllersManagerTest, OnEndRemovesMediaPlayerId) {
     manager_->OnEnd(media_player_id_);
     EXPECT_EQ(1U, GetControllersMap()->size());
   } else {
-    EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
-                                      media::MediaContentType::Transient,
-                                      false));
+    EXPECT_TRUE(manager_->RequestPlay(
+        media_player_id_, true, media::MediaContentType::Transient, false));
     EXPECT_EQ(1U, GetControllersMap()->size());
 
     manager_->OnEnd(media_player_id_);
@@ -242,9 +240,8 @@ TEST_P(MediaSessionControllersManagerTest, PositionState) {
 
     manager_->OnMediaPositionStateChanged(media_player_id_, expected_position);
 
-    EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
-                                      media::MediaContentType::Transient,
-                                      false));
+    EXPECT_TRUE(manager_->RequestPlay(
+        media_player_id_, true, media::MediaContentType::Transient, false));
     EXPECT_EQ(1U, GetControllersMap()->size());
 
     // The controller should be created with the last received position for
@@ -266,9 +263,8 @@ TEST_P(MediaSessionControllersManagerTest, PositionState) {
     EXPECT_TRUE(GetControllersMap()->empty());
 
     // Recreate the current controller.
-    EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
-                                      media::MediaContentType::Transient,
-                                      false));
+    EXPECT_TRUE(manager_->RequestPlay(
+        media_player_id_, true, media::MediaContentType::Transient, false));
     EXPECT_EQ(1U, GetControllersMap()->size());
 
     // The controller should be created with the last received position for
@@ -293,9 +289,9 @@ TEST_P(MediaSessionControllersManagerTest, MultiplePlayersWithPositionState) {
   manager_->OnMediaPositionStateChanged(media_player_id_, expected_position1);
   manager_->OnMediaPositionStateChanged(media_player_id_2, expected_position2);
 
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true,
                                     media::MediaContentType::Transient, false));
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_2, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_2, true,
                                     media::MediaContentType::Transient, false));
 
   EXPECT_EQ(2U, GetControllersMap()->size());
@@ -319,7 +315,7 @@ TEST_P(MediaSessionControllersManagerTest, PictureInPictureAvailability) {
     return;
 
   manager_->OnPictureInPictureAvailabilityChanged(media_player_id_, true);
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
+  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true,
                                     media::MediaContentType::Transient, false));
   EXPECT_TRUE(IsPictureInPictureAvailable(media_player_id_));
 
@@ -337,12 +333,10 @@ TEST_P(MediaSessionControllersManagerTest,
 
   manager_->OnPictureInPictureAvailabilityChanged(media_player_id_, true);
   manager_->OnPictureInPictureAvailabilityChanged(media_player_id_2, true);
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_, true, false,
-                                    media::MediaContentType::Persistent,
-                                    false));
-  EXPECT_TRUE(manager_->RequestPlay(media_player_id_2, true, false,
-                                    media::MediaContentType::Persistent,
-                                    false));
+  EXPECT_TRUE(manager_->RequestPlay(
+      media_player_id_, true, media::MediaContentType::Persistent, false));
+  EXPECT_TRUE(manager_->RequestPlay(
+      media_player_id_2, true, media::MediaContentType::Persistent, false));
   EXPECT_TRUE(IsPictureInPictureAvailable(media_player_id_));
   EXPECT_TRUE(IsPictureInPictureAvailable(media_player_id_2));
 

content/common/media/media_player_delegate_messages.h

@@ -89,11 +89,10 @@ IPC_MESSAGE_ROUTED2(MediaPlayerDelegateHostMsg_OnMediaPaused,
                     int /* delegate_id, distinguishes instances */,
                     bool /* reached end of stream */)
 
-IPC_MESSAGE_ROUTED5(MediaPlayerDelegateHostMsg_OnMediaPlaying,
+IPC_MESSAGE_ROUTED4(MediaPlayerDelegateHostMsg_OnMediaPlaying,
                     int /* delegate_id, distinguishes instances */,
                     bool /* has_video */,
                     bool /* has_audio */,
-                    bool /* is_remote */,
                     media::MediaContentType /* media_content_type */)
 
 IPC_MESSAGE_ROUTED2(MediaPlayerDelegateHostMsg_OnMutedStatusChanged,

content/renderer/media/renderer_webmediaplayer_delegate.cc

@@ -99,8 +99,7 @@ void RendererWebMediaPlayerDelegate::DidPlay(
   }
 
   Send(new MediaPlayerDelegateHostMsg_OnMediaPlaying(
-      routing_id(), player_id, has_video, has_audio, false,
-      media_content_type));
+      routing_id(), player_id, has_video, has_audio, media_content_type));
 
   ScheduleUpdateTask();
 }

content/renderer/media/renderer_webmediaplayer_delegate_browsertest.cc

@@ -118,7 +118,7 @@ TEST_F(RendererWebMediaPlayerDelegateTest, SendsMessagesCorrectly) {
 
   // Verify the playing message.
   {
-    const bool kHasVideo = true, kHasAudio = false, kIsRemote = false;
+    const bool kHasVideo = true, kHasAudio = false;
     const media::MediaContentType kMediaContentType =
         media::MediaContentType::Transient;
     delegate_manager_->DidPlay(delegate_id, kHasVideo, kHasAudio,
@@ -128,13 +128,12 @@ TEST_F(RendererWebMediaPlayerDelegateTest, SendsMessagesCorrectly) {
         MediaPlayerDelegateHostMsg_OnMediaPlaying::ID);
     ASSERT_TRUE(msg);
 
-    std::tuple<int, bool, bool, bool, media::MediaContentType> result;
+    std::tuple<int, bool, bool, media::MediaContentType> result;
     ASSERT_TRUE(MediaPlayerDelegateHostMsg_OnMediaPlaying::Read(msg, &result));
     EXPECT_EQ(delegate_id, std::get<0>(result));
     EXPECT_EQ(kHasVideo, std::get<1>(result));
     EXPECT_EQ(kHasAudio, std::get<2>(result));
-    EXPECT_EQ(kIsRemote, std::get<3>(result));
-    EXPECT_EQ(kMediaContentType, std::get<4>(result));
+    EXPECT_EQ(kMediaContentType, std::get<3>(result));
   }
 
   // Verify the paused message.