Update some callbacks in //remoting/protocol to Once/Repeating

Bug: 1007826
Change-Id: Ibfbad4000f7144629fe01d856e2fcbda26228f26
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2107585
Commit-Queue: Joe Downing <joedow@chromium.org>
Auto-Submit: Evan Stade <estade@chromium.org>
Reviewed-by: Joe Downing <joedow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#774343}

remoting/protocol/session_manager.h

@@ -92,7 +92,7 @@ class SessionManager {
   // the |session| then it must also set configuration for the |session| using
   // Session::set_config(). The callback must take ownership of the |session| if
   // it ACCEPTs it.
-  typedef base::Callback<void(Session* session,
+  typedef base::RepeatingCallback<void(Session* session,
                                        IncomingSessionResponse* response)>
       IncomingSessionCallback;
 

remoting/protocol/webrtc_dummy_video_encoder.cc

@@ -291,7 +291,7 @@ WebrtcDummyVideoEncoderFactory::SendEncodedFrame(
 }
 
 void WebrtcDummyVideoEncoderFactory::RegisterEncoderSelectedCallback(
-    const base::Callback<void(webrtc::VideoCodecType)>& callback) {
+    const base::RepeatingCallback<void(webrtc::VideoCodecType)>& callback) {
   encoder_created_callback_ = callback;
 }
 

remoting/protocol/webrtc_dummy_video_encoder.h

@@ -98,7 +98,7 @@ class WebrtcDummyVideoEncoderFactory : public webrtc::VideoEncoderFactory {
   // Callback will be called once the dummy encoder has been created on
   // |main_task_runner_|.
   void RegisterEncoderSelectedCallback(
-      const base::Callback<void(webrtc::VideoCodecType)>& callback);
+      const base::RepeatingCallback<void(webrtc::VideoCodecType)>& callback);
 
   void SetVideoChannelStateObserver(
       base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer);
@@ -118,7 +118,8 @@ class WebrtcDummyVideoEncoderFactory : public webrtc::VideoEncoderFactory {
   base::Lock lock_;
   base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer_;
   std::vector<WebrtcDummyVideoEncoder*> encoders_;
-  base::Callback<void(webrtc::VideoCodecType)> encoder_created_callback_;
+  base::RepeatingCallback<void(webrtc::VideoCodecType)>
+      encoder_created_callback_;
 };
 
 }  // namespace protocol

remoting/protocol/webrtc_transport.cc

@@ -194,27 +194,28 @@ base::Optional<bool> IsConnectionRelayed(
 class CreateSessionDescriptionObserver
     : public webrtc::CreateSessionDescriptionObserver {
  public:
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       std::unique_ptr<webrtc::SessionDescriptionInterface> description,
       const std::string& error)>
       ResultCallback;
 
   static CreateSessionDescriptionObserver* Create(
-      const ResultCallback& result_callback) {
+      ResultCallback result_callback) {
     return new rtc::RefCountedObject<CreateSessionDescriptionObserver>(
-        result_callback);
+        std::move(result_callback));
   }
+
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
     std::move(result_callback_).Run(base::WrapUnique(desc), std::string());
   }
+
   void OnFailure(webrtc::RTCError error) override {
     std::move(result_callback_).Run(nullptr, error.message());
   }
 
  protected:
-  explicit CreateSessionDescriptionObserver(
-      const ResultCallback& result_callback)
-      : result_callback_(result_callback) {}
+  explicit CreateSessionDescriptionObserver(ResultCallback result_callback)
+      : result_callback_(std::move(result_callback)) {}
   ~CreateSessionDescriptionObserver() override = default;
 
  private:
@@ -228,13 +229,12 @@ class CreateSessionDescriptionObserver
 class SetSessionDescriptionObserver
     : public webrtc::SetSessionDescriptionObserver {
  public:
-  typedef base::Callback<void(bool success, const std::string& error)>
+  typedef base::OnceCallback<void(bool success, const std::string& error)>
       ResultCallback;
 
-  static SetSessionDescriptionObserver* Create(
-      const ResultCallback& result_callback) {
+  static SetSessionDescriptionObserver* Create(ResultCallback result_callback) {
     return new rtc::RefCountedObject<SetSessionDescriptionObserver>(
-        result_callback);
+        std::move(result_callback));
   }
 
   void OnSuccess() override {
@@ -246,8 +246,8 @@ class SetSessionDescriptionObserver
   }
 
  protected:
-  explicit SetSessionDescriptionObserver(const ResultCallback& result_callback)
-      : result_callback_(result_callback) {}
+  explicit SetSessionDescriptionObserver(ResultCallback result_callback)
+      : result_callback_(std::move(result_callback)) {}
   ~SetSessionDescriptionObserver() override = default;
 
  private:
@@ -258,14 +258,13 @@ class SetSessionDescriptionObserver
 
 class RTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
  public:
-  typedef base::RepeatingCallback<void(
+  typedef base::OnceCallback<void(
       const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report)>
       ResultCallback;
 
-  static RTCStatsCollectorCallback* Create(
-      const ResultCallback& result_callback) {
+  static RTCStatsCollectorCallback* Create(ResultCallback result_callback) {
     return new rtc::RefCountedObject<RTCStatsCollectorCallback>(
-        result_callback);
+        std::move(result_callback));
   }
 
   void OnStatsDelivered(
@@ -274,8 +273,8 @@ class RTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
   }
 
  protected:
-  explicit RTCStatsCollectorCallback(const ResultCallback& result_callback)
-      : result_callback_(result_callback) {}
+  explicit RTCStatsCollectorCallback(ResultCallback result_callback)
+      : result_callback_(std::move(result_callback)) {}
   ~RTCStatsCollectorCallback() override = default;
 
  private:
@@ -552,8 +551,8 @@ bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) {
     }
 
     peer_connection()->SetRemoteDescription(
-        SetSessionDescriptionObserver::Create(
-            base::Bind(&WebrtcTransport::OnRemoteDescriptionSet,
+        SetSessionDescriptionObserver::Create(base::BindOnce(
+            &WebrtcTransport::OnRemoteDescriptionSet,
             weak_factory_.GetWeakPtr(),
             type == webrtc::SessionDescriptionInterface::kOffer)),
         session_description.release());
@@ -756,7 +755,7 @@ void WebrtcTransport::OnLocalSessionDescriptionCreated(
   send_transport_info_callback_.Run(std::move(transport_info));
 
   peer_connection()->SetLocalDescription(
-      SetSessionDescriptionObserver::Create(base::Bind(
+      SetSessionDescriptionObserver::Create(base::BindOnce(
           &WebrtcTransport::OnLocalDescriptionSet, weak_factory_.GetWeakPtr())),
       description.release());
 }
@@ -796,7 +795,7 @@ void WebrtcTransport::OnRemoteDescriptionSet(bool send_answer,
     const webrtc::PeerConnectionInterface::RTCOfferAnswerOptions options;
     peer_connection()->CreateAnswer(
         CreateSessionDescriptionObserver::Create(
-            base::Bind(&WebrtcTransport::OnLocalSessionDescriptionCreated,
+            base::BindOnce(&WebrtcTransport::OnLocalSessionDescriptionCreated,
                            weak_factory_.GetWeakPtr())),
         options);
   }
@@ -994,8 +993,7 @@ void WebrtcTransport::RequestRtcStats() {
   if (!connected_)
     return;
 
-  peer_connection()->GetStats(
-      RTCStatsCollectorCallback::Create(base::BindRepeating(
+  peer_connection()->GetStats(RTCStatsCollectorCallback::Create(base::BindOnce(
       &WebrtcTransport::OnStatsDelivered, weak_factory_.GetWeakPtr())));
 }
 
@@ -1021,8 +1019,8 @@ void WebrtcTransport::SendOffer() {
   options.offer_to_receive_audio = false;
   options.ice_restart = want_ice_restart_;
   peer_connection()->CreateOffer(
-      CreateSessionDescriptionObserver::Create(base::BindRepeating(
-          &WebrtcTransport::OnLocalSessionDescriptionCreated,
+      CreateSessionDescriptionObserver::Create(
+          base::BindOnce(&WebrtcTransport::OnLocalSessionDescriptionCreated,
                          weak_factory_.GetWeakPtr())),
       options);
 }

remoting/protocol/webrtc_transport_unittest.cc

@@ -37,8 +37,8 @@ const char kAuthKey[] = "test_auth_key";
 
 class TestTransportEventHandler : public WebrtcTransport::EventHandler {
  public:
-  typedef base::Callback<void(ErrorCode error)> ErrorCallback;
-  typedef base::Callback<void(const std::string& name,
+  typedef base::RepeatingCallback<void(ErrorCode error)> ErrorCallback;
+  typedef base::RepeatingCallback<void(const std::string& name,
                                        std::unique_ptr<MessagePipe> pipe)>
       IncomingChannelCallback;
 
@@ -76,7 +76,7 @@ class TestTransportEventHandler : public WebrtcTransport::EventHandler {
   void OnWebrtcTransportIncomingDataChannel(
       const std::string& name,
       std::unique_ptr<MessagePipe> pipe) override {
-    if (!incoming_channel_callback_.is_null()) {
+    if (incoming_channel_callback_) {
       incoming_channel_callback_.Run(name, std::move(pipe));
     } else {
       FAIL() << "Received unexpected incoming channel.";
@@ -204,30 +204,30 @@ class WebrtcTransportTest : public testing::Test {
     client_event_handler_.set_connected_callback(base::DoNothing());
 
     host_event_handler_.set_error_callback(
-        base::Bind(&WebrtcTransportTest::OnSessionError, base::Unretained(this),
-                   TransportRole::SERVER));
+        base::BindRepeating(&WebrtcTransportTest::OnSessionError,
+                            base::Unretained(this), TransportRole::SERVER));
     client_event_handler_.set_error_callback(
-        base::Bind(&WebrtcTransportTest::OnSessionError, base::Unretained(this),
-                   TransportRole::CLIENT));
+        base::BindRepeating(&WebrtcTransportTest::OnSessionError,
+                            base::Unretained(this), TransportRole::CLIENT));
 
     // Start both transports.
     host_transport_->Start(
         host_authenticator_.get(),
-        base::Bind(&WebrtcTransportTest::ProcessTransportInfo,
+        base::BindRepeating(&WebrtcTransportTest::ProcessTransportInfo,
                             base::Unretained(this), &client_transport_, true));
     client_transport_->Start(
         client_authenticator_.get(),
-        base::Bind(&WebrtcTransportTest::ProcessTransportInfo,
+        base::BindRepeating(&WebrtcTransportTest::ProcessTransportInfo,
                             base::Unretained(this), &host_transport_, false));
   }
 
   void WaitUntilConnected() {
     int counter = 2;
     host_event_handler_.set_connected_callback(
-        base::Bind(&WebrtcTransportTest::QuitRunLoopOnCounter,
+        base::BindRepeating(&WebrtcTransportTest::QuitRunLoopOnCounter,
                             base::Unretained(this), &counter));
     client_event_handler_.set_connected_callback(
-        base::Bind(&WebrtcTransportTest::QuitRunLoopOnCounter,
+        base::BindRepeating(&WebrtcTransportTest::QuitRunLoopOnCounter,
                             base::Unretained(this), &counter));
 
     run_loop_.reset(new base::RunLoop());
@@ -241,14 +241,14 @@ class WebrtcTransportTest : public testing::Test {
   }
 
   void ExpectClientDataStream() {
-    client_event_handler_.set_incoming_channel_callback(base::Bind(
+    client_event_handler_.set_incoming_channel_callback(base::BindRepeating(
         &WebrtcTransportTest::OnIncomingChannel, base::Unretained(this)));
   }
 
   void CreateHostDataStream() {
     host_message_pipe_ = host_transport_->CreateOutgoingChannel(kChannelName);
     host_message_pipe_->Start(&host_message_pipe_event_handler_);
-    host_message_pipe_event_handler_.set_open_callback(base::Bind(
+    host_message_pipe_event_handler_.set_open_callback(base::BindRepeating(
         &WebrtcTransportTest::OnHostChannelConnected, base::Unretained(this)));
   }
 
@@ -339,9 +339,9 @@ TEST_F(WebrtcTransportTest, InvalidAuthKey) {
 }
 
 TEST_F(WebrtcTransportTest, DataStream) {
-  client_event_handler_.set_connecting_callback(base::Bind(
+  client_event_handler_.set_connecting_callback(base::BindRepeating(
       &WebrtcTransportTest::ExpectClientDataStream, base::Unretained(this)));
-  host_event_handler_.set_connecting_callback(base::Bind(
+  host_event_handler_.set_connecting_callback(base::BindRepeating(
       &WebrtcTransportTest::CreateHostDataStream, base::Unretained(this)));
 
   InitializeConnection();
@@ -359,7 +359,7 @@ TEST_F(WebrtcTransportTest, DataStream) {
 
   run_loop_.reset(new base::RunLoop());
   client_message_pipe_event_handler_.set_message_callback(
-      base::Bind(&base::RunLoop::Quit, base::Unretained(run_loop_.get())));
+      run_loop_->QuitClosure());
   run_loop_->Run();
 
   ASSERT_EQ(1U, client_message_pipe_event_handler_.received_messages().size());
@@ -403,7 +403,7 @@ TEST_F(WebrtcTransportTest, TerminateDataChannel) {
 
   // Expect that the channel is closed on the host side once the client closes
   // the channel.
-  host_message_pipe_event_handler_.set_closed_callback(base::Bind(
+  host_message_pipe_event_handler_.set_closed_callback(base::BindRepeating(
       &WebrtcTransportTest::OnHostChannelClosed, base::Unretained(this)));
 
   // Destroy pipe on one side of the of the connection. It should get closed on