Unify SetLocalDescription() and SetRemoteDescription().

Prior to this CL, there was a separate observer class for
SetLocalDescription() and SetRemoteDescription().

In this CL, the WebRtcSetRemoteDescriptionObserver is renamed to
WebRtcSetDescriptionObserver (to reflect it is used both for local and
remote descriptions) and the WebRtcSetDescriptionObserverHandler is
split up in a "Local" and "Remote" handler version.

WebRtcSetDescriptionObserverHandler is updated to use the
TransceiverStateSurfacer. In Plan B this is a refactoring that
shouldn't make any functional changes, but in Unified Plan this setup
will allow the creation of transceivers as well.

The RTCPeerConnectionHandler is updated to wire both local and remote
descriptions to use the same observer.
The WebRtcSetDescriptionObserverImpl takes care of adding and removing
receivers. Prior to this CL this is something we did for remote
descriptions but not local ones. Because SetLocalDescription() does not
change the set of receivers in Plan B, this should not make a
difference. But in Unified Plan, the same codepath needs to run in both
local and remote cases because in Unified Plan both
SetLocalDescription() and SetRemoteDescription() modifies the state of
transcievers. In an upcoming CL the "...ObserverImpl" will not just add
and remove receivers but also take care of updating transceivers if
Unified Plan is used.

This CL also:
- Removes RTCPeerConnectionHandler::SetLocalDescriptionRequest because
  it is not used anymore.
- Removes SessionDescriptionRequestTracker, because it doesn't do much
  and the only remaining use was in CreateSessionDescriptionRequest
  which is updated to do the equivalent of its use of the tracker.

Bug: 777617
Change-Id: I8a5726f25764c1e57ec18e7eb96decf083fc8333
Reviewed-on: https://chromium-review.googlesource.com/1136441Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#575663}

content/renderer/BUILD.gn

@@ -430,8 +430,8 @@ target(link_target_type, "renderer") {
     "media/webrtc/webrtc_media_stream_track_adapter.h",
     "media/webrtc/webrtc_media_stream_track_adapter_map.cc",
     "media/webrtc/webrtc_media_stream_track_adapter_map.h",
-    "media/webrtc/webrtc_set_remote_description_observer.cc",
-    "media/webrtc/webrtc_set_remote_description_observer.h",
+    "media/webrtc/webrtc_set_description_observer.cc",
+    "media/webrtc/webrtc_set_description_observer.h",
     "media/webrtc/webrtc_uma_histograms.cc",
     "media/webrtc/webrtc_uma_histograms.h",
     "media/webrtc/webrtc_util.h",

content/renderer/media/webrtc/rtc_peer_connection_handler.h

@@ -185,8 +185,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
 
   class Observer;
   friend class Observer;
-  class WebRtcSetRemoteDescriptionObserverImpl;
-  friend class WebRtcSetRemoteDescriptionObserverImpl;
+  class WebRtcSetDescriptionObserverImpl;
+  friend class WebRtcSetDescriptionObserverImpl;
   class SetLocalDescriptionRequest;
   friend class SetLocalDescriptionRequest;
 

content/renderer/media/webrtc/transceiver_state_surfacer.cc

@@ -25,7 +25,8 @@ TransceiverStateSurfacer::TransceiverStateSurfacer(
     : main_task_runner_(other.main_task_runner_),
       signaling_task_runner_(other.signaling_task_runner_),
       is_initialized_(other.is_initialized_),
-      states_obtained_(other.states_obtained_) {
+      states_obtained_(other.states_obtained_),
+      transceiver_states_(std::move(other.transceiver_states_)) {
   // Explicitly null |other|'s task runners for use in destructor.
   other.main_task_runner_ = nullptr;
   other.signaling_task_runner_ = nullptr;
@@ -42,6 +43,7 @@ TransceiverStateSurfacer& TransceiverStateSurfacer::operator=(
   main_task_runner_ = other.main_task_runner_;
   signaling_task_runner_ = other.signaling_task_runner_;
   states_obtained_ = other.states_obtained_;
+  transceiver_states_ = std::move(other.transceiver_states_);
   // Explicitly null |other|'s task runners for use in destructor.
   other.main_task_runner_ = nullptr;
   other.signaling_task_runner_ = nullptr;

content/renderer/media/webrtc/webrtc_set_description_observer.cc

+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/renderer/media/webrtc/webrtc_set_description_observer.h"
+
+#include "base/logging.h"
+
+namespace content {
+
+WebRtcSetDescriptionObserver::States::States()
+    : signaling_state(
+          webrtc::PeerConnectionInterface::SignalingState::kClosed) {}
+
+WebRtcSetDescriptionObserver::States::States(States&& other)
+    : signaling_state(other.signaling_state),
+      transceiver_states(std::move(other.transceiver_states)) {}
+
+WebRtcSetDescriptionObserver::States::~States() = default;
+
+WebRtcSetDescriptionObserver::States& WebRtcSetDescriptionObserver::States::
+operator=(States&& other) {
+  signaling_state = other.signaling_state;
+  transceiver_states = std::move(other.transceiver_states);
+  return *this;
+}
+
+WebRtcSetDescriptionObserver::WebRtcSetDescriptionObserver() = default;
+
+WebRtcSetDescriptionObserver::~WebRtcSetDescriptionObserver() = default;
+
+WebRtcSetDescriptionObserverHandlerImpl::
+    WebRtcSetDescriptionObserverHandlerImpl(
+        scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+        scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+        scoped_refptr<webrtc::PeerConnectionInterface> pc,
+        scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+        scoped_refptr<WebRtcSetDescriptionObserver> observer)
+    : main_task_runner_(std::move(main_task_runner)),
+      signaling_task_runner_(std::move(signaling_task_runner)),
+      pc_(std::move(pc)),
+      track_adapter_map_(std::move(track_adapter_map)),
+      observer_(std::move(observer)) {}
+
+WebRtcSetDescriptionObserverHandlerImpl::
+    ~WebRtcSetDescriptionObserverHandlerImpl() = default;
+
+void WebRtcSetDescriptionObserverHandlerImpl::OnSetDescriptionComplete(
+    webrtc::RTCError error) {
+  CHECK(signaling_task_runner_->BelongsToCurrentThread());
+  std::vector<rtc::scoped_refptr<webrtc::RtpTransceiverInterface>>
+      receiver_only_transceivers;
+  for (const auto& receiver : pc_->GetReceivers()) {
+    receiver_only_transceivers.push_back(
+        new SurfaceReceiverStateOnly(receiver));
+  }
+  TransceiverStateSurfacer transceiver_state_surfacer(main_task_runner_,
+                                                      signaling_task_runner_);
+  transceiver_state_surfacer.Initialize(track_adapter_map_,
+                                        std::move(receiver_only_transceivers));
+  main_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&WebRtcSetDescriptionObserverHandlerImpl::
+                                    OnSetDescriptionCompleteOnMainThread,
+                                this, std::move(error), pc_->signaling_state(),
+                                std::move(transceiver_state_surfacer)));
+}
+
+void WebRtcSetDescriptionObserverHandlerImpl::
+    OnSetDescriptionCompleteOnMainThread(
+        webrtc::RTCError error,
+        webrtc::PeerConnectionInterface::SignalingState signaling_state,
+        TransceiverStateSurfacer transceiver_state_surfacer) {
+  CHECK(main_task_runner_->BelongsToCurrentThread());
+  WebRtcSetDescriptionObserver::States states;
+  states.signaling_state = signaling_state;
+  states.transceiver_states = transceiver_state_surfacer.ObtainStates();
+  observer_->OnSetDescriptionComplete(std::move(error), std::move(states));
+}
+
+scoped_refptr<WebRtcSetLocalDescriptionObserverHandler>
+WebRtcSetLocalDescriptionObserverHandler::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+    scoped_refptr<webrtc::PeerConnectionInterface> pc,
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+    scoped_refptr<WebRtcSetDescriptionObserver> observer) {
+  return new rtc::RefCountedObject<WebRtcSetLocalDescriptionObserverHandler>(
+      std::move(main_task_runner), std::move(signaling_task_runner),
+      std::move(pc), std::move(track_adapter_map), std::move(observer));
+}
+
+WebRtcSetLocalDescriptionObserverHandler::
+    WebRtcSetLocalDescriptionObserverHandler(
+        scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+        scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+        scoped_refptr<webrtc::PeerConnectionInterface> pc,
+        scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+        scoped_refptr<WebRtcSetDescriptionObserver> observer)
+    : handler_impl_(new WebRtcSetDescriptionObserverHandlerImpl(
+          std::move(main_task_runner),
+          std::move(signaling_task_runner),
+          std::move(pc),
+          std::move(track_adapter_map),
+          std::move(observer))) {}
+
+WebRtcSetLocalDescriptionObserverHandler::
+    ~WebRtcSetLocalDescriptionObserverHandler() = default;
+
+void WebRtcSetLocalDescriptionObserverHandler::OnSuccess() {
+  handler_impl_->OnSetDescriptionComplete(webrtc::RTCError::OK());
+}
+
+void WebRtcSetLocalDescriptionObserverHandler::OnFailure(
+    webrtc::RTCError error) {
+  handler_impl_->OnSetDescriptionComplete(std::move(error));
+}
+
+scoped_refptr<WebRtcSetRemoteDescriptionObserverHandler>
+WebRtcSetRemoteDescriptionObserverHandler::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+    scoped_refptr<webrtc::PeerConnectionInterface> pc,
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+    scoped_refptr<WebRtcSetDescriptionObserver> observer) {
+  return new rtc::RefCountedObject<WebRtcSetRemoteDescriptionObserverHandler>(
+      std::move(main_task_runner), std::move(signaling_task_runner),
+      std::move(pc), std::move(track_adapter_map), std::move(observer));
+}
+
+WebRtcSetRemoteDescriptionObserverHandler::
+    WebRtcSetRemoteDescriptionObserverHandler(
+        scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+        scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+        scoped_refptr<webrtc::PeerConnectionInterface> pc,
+        scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+        scoped_refptr<WebRtcSetDescriptionObserver> observer)
+    : handler_impl_(new WebRtcSetDescriptionObserverHandlerImpl(
+          std::move(main_task_runner),
+          std::move(signaling_task_runner),
+          std::move(pc),
+          std::move(track_adapter_map),
+          std::move(observer))) {}
+
+WebRtcSetRemoteDescriptionObserverHandler::
+    ~WebRtcSetRemoteDescriptionObserverHandler() = default;
+
+void WebRtcSetRemoteDescriptionObserverHandler::OnSetRemoteDescriptionComplete(
+    webrtc::RTCError error) {
+  handler_impl_->OnSetDescriptionComplete(std::move(error));
+}
+
+}  // namespace content

content/renderer/media/webrtc/webrtc_set_remote_description_observer_unittest.cc → content/renderer/media/webrtc/webrtc_set_description_observer_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/media/webrtc/webrtc_set_remote_description_observer.h"
+#include "content/renderer/media/webrtc/webrtc_set_description_observer.h"
 
 #include <memory>
 #include <utility>
@@ -28,35 +28,40 @@ using ::testing::Return;
 
 namespace content {
 
-class WebRtcSetRemoteDescriptionObserverForTest
-    : public WebRtcSetRemoteDescriptionObserver {
+class WebRtcSetDescriptionObserverForTest
+    : public WebRtcSetDescriptionObserver {
  public:
-  bool called() const { return states_or_error_.has_value(); }
-  bool result() const { return states_or_error_->ok(); }
+  bool called() const { return called_; }
 
-  const WebRtcSetRemoteDescriptionObserver::States& states() const {
-    DCHECK(called() && result());
-    return states_or_error_->value();
+  const WebRtcSetDescriptionObserver::States& states() const {
+    DCHECK(called_);
+    return states_;
   }
   const webrtc::RTCError& error() const {
-    DCHECK(called() && !result());
-    return states_or_error_->error();
+    DCHECK(called_);
+    return error_;
   }
 
-  // WebRtcSetRemoteDescriptionObserver implementation.
-  void OnSetRemoteDescriptionComplete(
-      webrtc::RTCErrorOr<States> states_or_error) override {
-    states_or_error_ = std::move(states_or_error);
+  // WebRtcSetDescriptionObserver implementation.
+  void OnSetDescriptionComplete(
+      webrtc::RTCError error,
+      WebRtcSetDescriptionObserver::States states) override {
+    called_ = true;
+    error_ = std::move(error);
+    states_ = std::move(states);
   }
 
  private:
-  ~WebRtcSetRemoteDescriptionObserverForTest() override {}
+  ~WebRtcSetDescriptionObserverForTest() override {}
 
-  base::Optional<webrtc::RTCErrorOr<WebRtcSetRemoteDescriptionObserver::States>>
-      states_or_error_;
-  WebRtcSetRemoteDescriptionObserver::States states_;
+  bool called_ = false;
+  webrtc::RTCError error_;
+  WebRtcSetDescriptionObserver::States states_;
 };
 
+// TODO(hbos): This only tests WebRtcSetRemoteDescriptionObserverHandler,
+// parameterize the test to make it also test
+// WebRtcSetLocalDescriptionObserverHandler.
 class WebRtcSetRemoteDescriptionObserverHandlerTest : public ::testing::Test {
  public:
   void SetUp() override {
@@ -68,7 +73,7 @@ class WebRtcSetRemoteDescriptionObserverHandlerTest : public ::testing::Test {
     scoped_refptr<WebRtcMediaStreamTrackAdapterMap> map =
         new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
                                              main_thread_);
-    observer_ = new WebRtcSetRemoteDescriptionObserverForTest();
+    observer_ = new WebRtcSetDescriptionObserverForTest();
     observer_handler_ = WebRtcSetRemoteDescriptionObserverHandler::Create(
         main_thread_, dependency_factory_->GetWebRtcSignalingThread(), pc_, map,
         observer_);
@@ -104,7 +109,7 @@ class WebRtcSetRemoteDescriptionObserverHandlerTest : public ::testing::Test {
   scoped_refptr<webrtc::MockPeerConnection> pc_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
-  scoped_refptr<WebRtcSetRemoteDescriptionObserverForTest> observer_;
+  scoped_refptr<WebRtcSetDescriptionObserverForTest> observer_;
   scoped_refptr<WebRtcSetRemoteDescriptionObserverHandler> observer_handler_;
 
   std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>> receivers_;
@@ -122,15 +127,23 @@ TEST_F(WebRtcSetRemoteDescriptionObserverHandlerTest, OnSuccess) {
               {added_stream.get()})));
 
   receivers_.push_back(added_receiver.get());
+  EXPECT_CALL(*pc_, signaling_state())
+      .WillRepeatedly(Return(webrtc::PeerConnectionInterface::kStable));
   EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(receivers_));
 
   InvokeOnSetRemoteDescriptionComplete(webrtc::RTCError::OK());
   EXPECT_TRUE(observer_->called());
-  EXPECT_TRUE(observer_->result());
+  EXPECT_TRUE(observer_->error().ok());
+
+  EXPECT_EQ(webrtc::PeerConnectionInterface::kStable,
+            observer_->states().signaling_state);
 
-  EXPECT_EQ(1u, observer_->states().receiver_states.size());
-  const RtpReceiverState& receiver_state =
-      observer_->states().receiver_states[0];
+  EXPECT_EQ(1u, observer_->states().transceiver_states.size());
+  const RtpTransceiverState& transceiver_state =
+      observer_->states().transceiver_states[0];
+  EXPECT_FALSE(transceiver_state.sender_state());
+  EXPECT_TRUE(transceiver_state.receiver_state());
+  const RtpReceiverState& receiver_state = *transceiver_state.receiver_state();
   EXPECT_EQ(added_receiver, receiver_state.webrtc_receiver());
   EXPECT_EQ(added_track, receiver_state.track_ref()->webrtc_track());
   EXPECT_EQ(1u, receiver_state.stream_ids().size());
@@ -138,11 +151,41 @@ TEST_F(WebRtcSetRemoteDescriptionObserverHandlerTest, OnSuccess) {
 }
 
 TEST_F(WebRtcSetRemoteDescriptionObserverHandlerTest, OnFailure) {
-  webrtc::RTCError error(webrtc::RTCErrorType::INVALID_PARAMETER, "Oh noes!");
-  InvokeOnSetRemoteDescriptionComplete(std::move(error));
+  scoped_refptr<MockWebRtcAudioTrack> added_track =
+      MockWebRtcAudioTrack::Create("added_track");
+  scoped_refptr<webrtc::MediaStreamInterface> added_stream(
+      new rtc::RefCountedObject<MockMediaStream>("added_stream"));
+  scoped_refptr<webrtc::RtpReceiverInterface> added_receiver(
+      new rtc::RefCountedObject<FakeRtpReceiver>(
+          added_track.get(),
+          std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>(
+              {added_stream.get()})));
+
+  receivers_.push_back(added_receiver.get());
+  EXPECT_CALL(*pc_, signaling_state())
+      .WillRepeatedly(Return(webrtc::PeerConnectionInterface::kStable));
+  EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(receivers_));
+
+  InvokeOnSetRemoteDescriptionComplete(
+      webrtc::RTCError(webrtc::RTCErrorType::INVALID_PARAMETER, "Oh noes!"));
   EXPECT_TRUE(observer_->called());
-  EXPECT_FALSE(observer_->result());
+  EXPECT_FALSE(observer_->error().ok());
   EXPECT_EQ(std::string("Oh noes!"), observer_->error().message());
+
+  // Verify states were surfaced even though we got an error.
+  EXPECT_EQ(webrtc::PeerConnectionInterface::kStable,
+            observer_->states().signaling_state);
+
+  EXPECT_EQ(1u, observer_->states().transceiver_states.size());
+  const RtpTransceiverState& transceiver_state =
+      observer_->states().transceiver_states[0];
+  EXPECT_FALSE(transceiver_state.sender_state());
+  EXPECT_TRUE(transceiver_state.receiver_state());
+  const RtpReceiverState& receiver_state = *transceiver_state.receiver_state();
+  EXPECT_EQ(added_receiver, receiver_state.webrtc_receiver());
+  EXPECT_EQ(added_track, receiver_state.track_ref()->webrtc_track());
+  EXPECT_EQ(1u, receiver_state.stream_ids().size());
+  EXPECT_EQ(added_stream->id(), receiver_state.stream_ids()[0]);
 }
 
 }  // namespace content

content/renderer/media/webrtc/webrtc_set_remote_description_observer.cc

-// Copyright (c) 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/renderer/media/webrtc/webrtc_set_remote_description_observer.h"
-
-#include "base/logging.h"
-
-namespace content {
-
-WebRtcSetRemoteDescriptionObserver::States::States()
-    : signaling_state(
-          webrtc::PeerConnectionInterface::SignalingState::kClosed) {}
-
-WebRtcSetRemoteDescriptionObserver::States::States(States&& other)
-    : signaling_state(other.signaling_state),
-      receiver_states(std::move(other.receiver_states)) {}
-
-WebRtcSetRemoteDescriptionObserver::States::~States() {}
-
-WebRtcSetRemoteDescriptionObserver::States&
-WebRtcSetRemoteDescriptionObserver::States::operator=(States&& other) {
-  signaling_state = other.signaling_state;
-  receiver_states = std::move(other.receiver_states);
-  return *this;
-}
-
-WebRtcSetRemoteDescriptionObserver::WebRtcSetRemoteDescriptionObserver() {}
-
-WebRtcSetRemoteDescriptionObserver::~WebRtcSetRemoteDescriptionObserver() {}
-
-scoped_refptr<WebRtcSetRemoteDescriptionObserverHandler>
-WebRtcSetRemoteDescriptionObserverHandler::Create(
-    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
-    scoped_refptr<webrtc::PeerConnectionInterface> pc,
-    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
-    scoped_refptr<WebRtcSetRemoteDescriptionObserver> observer) {
-  return new rtc::RefCountedObject<WebRtcSetRemoteDescriptionObserverHandler>(
-      std::move(main_task_runner), std::move(signaling_task_runner),
-      std::move(pc), std::move(track_adapter_map), std::move(observer));
-}
-
-WebRtcSetRemoteDescriptionObserverHandler::
-    WebRtcSetRemoteDescriptionObserverHandler(
-        scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-        scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
-        scoped_refptr<webrtc::PeerConnectionInterface> pc,
-        scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
-        scoped_refptr<WebRtcSetRemoteDescriptionObserver> observer)
-    : main_task_runner_(std::move(main_task_runner)),
-      signaling_task_runner_(std::move(signaling_task_runner)),
-      pc_(std::move(pc)),
-      track_adapter_map_(std::move(track_adapter_map)),
-      observer_(std::move(observer)) {}
-
-WebRtcSetRemoteDescriptionObserverHandler::
-    ~WebRtcSetRemoteDescriptionObserverHandler() {}
-
-void WebRtcSetRemoteDescriptionObserverHandler::OnSetRemoteDescriptionComplete(
-    webrtc::RTCError error) {
-  CHECK(signaling_task_runner_->BelongsToCurrentThread());
-
-  webrtc::RTCErrorOr<WebRtcSetRemoteDescriptionObserver::States>
-      states_or_error;
-  if (error.ok()) {
-    WebRtcSetRemoteDescriptionObserver::States states;
-    states.signaling_state = pc_->signaling_state();
-    for (const auto& webrtc_receiver : pc_->GetReceivers()) {
-      std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> track_ref =
-          track_adapter_map_->GetOrCreateRemoteTrackAdapter(
-              webrtc_receiver->track().get());
-      std::vector<std::string> stream_ids;
-      for (const auto& stream : webrtc_receiver->streams())
-        stream_ids.push_back(stream->id());
-      states.receiver_states.push_back(RtpReceiverState(
-          main_task_runner_, signaling_task_runner_, webrtc_receiver.get(),
-          std::move(track_ref), std::move(stream_ids)));
-    }
-    states_or_error = std::move(states);
-  } else {
-    states_or_error = std::move(error);
-  }
-  main_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&WebRtcSetRemoteDescriptionObserverHandler::
-                                    OnSetRemoteDescriptionCompleteOnMainThread,
-                                this, std::move(states_or_error)));
-}
-
-void WebRtcSetRemoteDescriptionObserverHandler::
-    OnSetRemoteDescriptionCompleteOnMainThread(
-        webrtc::RTCErrorOr<WebRtcSetRemoteDescriptionObserver::States>
-            states_or_error) {
-  CHECK(main_task_runner_->BelongsToCurrentThread());
-  if (states_or_error.ok()) {
-    for (auto& receiver_state : states_or_error.value().receiver_states)
-      receiver_state.Initialize();
-  }
-  observer_->OnSetRemoteDescriptionComplete(std::move(states_or_error));
-}
-
-}  // namespace content

content/test/BUILD.gn

@@ -1702,7 +1702,7 @@ test("content_unittests") {
     "../renderer/media/webrtc/webrtc_audio_renderer_unittest.cc",
     "../renderer/media/webrtc/webrtc_media_stream_track_adapter_map_unittest.cc",
     "../renderer/media/webrtc/webrtc_media_stream_track_adapter_unittest.cc",
-    "../renderer/media/webrtc/webrtc_set_remote_description_observer_unittest.cc",
+    "../renderer/media/webrtc/webrtc_set_description_observer_unittest.cc",
     "../renderer/media/webrtc/webrtc_uma_histograms_unittest.cc",
     "../renderer/media/webrtc/webrtc_video_capturer_adapter_unittest.cc",
     "../renderer/media/webrtc_local_audio_source_provider_unittest.cc",