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

Bug: 1007826
Change-Id: I5f12d7453fd7a5f8c3ea7bb756a6f735ec7759aa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2225789
Commit-Queue: Joe Downing <joedow@chromium.org>
Reviewed-by: Joe Downing <joedow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#776105}

remoting/protocol/audio_source.h

@@ -17,7 +17,7 @@ namespace protocol {
 
 class AudioSource {
  public:
-  typedef base::Callback<void(std::unique_ptr<AudioPacket> packet)>
+  typedef base::RepeatingCallback<void(std::unique_ptr<AudioPacket> packet)>
       PacketCapturedCallback;
 
   virtual ~AudioSource() {}

remoting/protocol/authenticator.h

@@ -83,7 +83,7 @@ class Authenticator {
   // Callback used for layered Authenticator implementations, particularly
   // third-party and pairing authenticators. They use this callback to create
   // base SPAKE2 authenticators.
-  typedef base::Callback<std::unique_ptr<Authenticator>(
+  typedef base::RepeatingCallback<std::unique_ptr<Authenticator>(
       const std::string& shared_secret,
       Authenticator::State initial_state)>
       CreateBaseAuthenticatorCallback;

remoting/protocol/channel_authenticator.h

@@ -20,7 +20,7 @@ class P2PStreamSocket;
 // should be used only once for one channel.
 class ChannelAuthenticator {
  public:
-  typedef base::Callback<void(int error, std::unique_ptr<P2PStreamSocket>)>
+  typedef base::OnceCallback<void(int error, std::unique_ptr<P2PStreamSocket>)>
       DoneCallback;
 
   virtual ~ChannelAuthenticator() {}
@@ -29,7 +29,7 @@ class ChannelAuthenticator {
   // authentication is finished. Callback may be invoked before this method
   // returns, and may delete the calling authenticator.
   virtual void SecureAndAuthenticate(std::unique_ptr<P2PStreamSocket> socket,
-                                     const DoneCallback& done_callback) = 0;
+                                     DoneCallback done_callback) = 0;
 };
 
 }  // namespace protocol

remoting/protocol/client_authentication_config.h

@@ -12,18 +12,20 @@
 namespace remoting {
 namespace protocol {
 
-typedef base::Callback<void(const std::string& secret)> SecretFetchedCallback;
-typedef base::Callback<void(
+typedef base::RepeatingCallback<void(const std::string& secret)>
+    SecretFetchedCallback;
+typedef base::RepeatingCallback<void(
     bool pairing_supported,
-    const SecretFetchedCallback& secret_fetched_callback)> FetchSecretCallback;
+    const SecretFetchedCallback& secret_fetched_callback)>
+    FetchSecretCallback;
 
 // Callback passed to |FetchTokenCallback|, and called once the client
 // authentication finishes. |token| is an opaque string that should be sent
 // directly to the host. |shared_secret| should be used by the client to
 // create a V2Authenticator. In case of failure, the callback is called with
 // an empty |token| and |shared_secret|.
-typedef base::Callback<void(const std::string& token,
-                            const std::string& shared_secret)>
+typedef base::RepeatingCallback<void(const std::string& token,
+                                     const std::string& shared_secret)>
     ThirdPartyTokenFetchedCallback;
 
 // Fetches a third party token from |token_url|. |host_public_key| is sent to
@@ -32,7 +34,7 @@ typedef base::Callback<void(const std::string& token,
 // "hostjid:abc@example.com/123 clientjid:def@example.org/456".
 // |token_fetched_callback| is called when the client authentication ends, on
 // the same thread on which FetchThirdPartyTokenCallback was originally called.
-typedef base::Callback<void(
+typedef base::RepeatingCallback<void(
     const std::string& token_url,
     const std::string& scope,
     const ThirdPartyTokenFetchedCallback& token_fetched_callback)>

remoting/protocol/data_channel_manager.h

@@ -20,9 +20,9 @@ class MessagePipe;
 // register a function to handle data from a named data channel.
 class DataChannelManager final {
  public:
-  using CreateHandlerCallback = base::Callback<void(
-      const std::string& name,
-      std::unique_ptr<MessagePipe> pipe)>;
+  using CreateHandlerCallback =
+      base::RepeatingCallback<void(const std::string& name,
+                                   std::unique_ptr<MessagePipe> pipe)>;
 
   DataChannelManager();
   ~DataChannelManager();

remoting/protocol/fake_authenticator.cc

@@ -29,10 +29,10 @@ FakeChannelAuthenticator::~FakeChannelAuthenticator() = default;
 
 void FakeChannelAuthenticator::SecureAndAuthenticate(
     std::unique_ptr<P2PStreamSocket> socket,
-    const DoneCallback& done_callback) {
+    DoneCallback done_callback) {
   socket_ = std::move(socket);
 
-  done_callback_ = done_callback;
+  done_callback_ = std::move(done_callback);
 
   if (async_) {
     if (result_ != net::OK) {

remoting/protocol/fake_authenticator.h

@@ -21,7 +21,7 @@ class FakeChannelAuthenticator : public ChannelAuthenticator {
 
   // ChannelAuthenticator interface.
   void SecureAndAuthenticate(std::unique_ptr<P2PStreamSocket> socket,
-                             const DoneCallback& done_callback) override;
+                             DoneCallback done_callback) override;
 
  private:
   void OnAuthBytesWritten(int result);

remoting/protocol/ice_transport_unittest.cc

@@ -54,7 +54,7 @@ class MockChannelCreatedCallback {
 
 class TestTransportEventHandler : public IceTransport::EventHandler {
  public:
-  typedef base::Callback<void(ErrorCode error)> ErrorCallback;
+  typedef base::RepeatingCallback<void(ErrorCode error)> ErrorCallback;
 
   TestTransportEventHandler() = default;
   ~TestTransportEventHandler() = default;

remoting/protocol/jingle_session.h

@@ -47,7 +47,8 @@ class JingleSession : public Session {
  private:
   friend class JingleSessionManager;
 
-  typedef base::Callback<void(JingleMessageReply::ErrorType)> ReplyCallback;
+  typedef base::RepeatingCallback<void(JingleMessageReply::ErrorType)>
+      ReplyCallback;
 
   explicit JingleSession(JingleSessionManager* session_manager);
 

remoting/protocol/message_reader.h

@@ -36,9 +36,9 @@ class P2PStreamSocket;
 // e.g. when we the sender sends multiple messages in one TCP packet.
 class MessageReader {
  public:
-  typedef base::Callback<void(std::unique_ptr<CompoundBuffer> message)>
+  typedef base::RepeatingCallback<void(std::unique_ptr<CompoundBuffer> message)>
       MessageReceivedCallback;
-  typedef base::Callback<void(int)> ReadFailedCallback;
+  typedef base::RepeatingCallback<void(int)> ReadFailedCallback;
 
   MessageReader();
   virtual ~MessageReader();

remoting/protocol/monitored_video_stub.h

@@ -30,7 +30,7 @@ class MonitoredVideoStub : public VideoStub {
  public:
   // Callback to be called when channel state changes.  The Callback should not
   // destroy the MonitoredVideoStub object.
-  typedef base::Callback<void(bool connected)> ChannelStateCallback;
+  typedef base::RepeatingCallback<void(bool connected)> ChannelStateCallback;
 
   static const int kConnectivityCheckDelaySeconds = 2;
 

remoting/protocol/ssl_hmac_channel_authenticator.cc

@@ -245,10 +245,10 @@ SslHmacChannelAuthenticator::~SslHmacChannelAuthenticator() {
 
 void SslHmacChannelAuthenticator::SecureAndAuthenticate(
     std::unique_ptr<P2PStreamSocket> socket,
-    const DoneCallback& done_callback) {
+    DoneCallback done_callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  done_callback_ = done_callback;
+  done_callback_ = std::move(done_callback);
 
   int result;
   if (is_ssl_server()) {

remoting/protocol/ssl_hmac_channel_authenticator.h

@@ -64,7 +64,7 @@ class SslHmacChannelAuthenticator : public ChannelAuthenticator {
 
   // ChannelAuthenticator interface.
   void SecureAndAuthenticate(std::unique_ptr<P2PStreamSocket> socket,
-                             const DoneCallback& done_callback) override;
+                             DoneCallback done_callback) override;
 
  private:
   class P2PStreamSocketAdapter;

remoting/protocol/stream_message_pipe_adapter.cc

@@ -21,8 +21,8 @@ namespace protocol {
 
 StreamMessagePipeAdapter::StreamMessagePipeAdapter(
     std::unique_ptr<P2PStreamSocket> socket,
-    const ErrorCallback& error_callback)
-    : socket_(std::move(socket)), error_callback_(error_callback) {
+    ErrorCallback error_callback)
+    : socket_(std::move(socket)), error_callback_(std::move(error_callback)) {
   DCHECK(socket_);
   DCHECK(error_callback_);
 }

remoting/protocol/stream_message_pipe_adapter.h

@@ -22,10 +22,10 @@ class StreamChannelFactory;
 // P2PStreamSocket.
 class StreamMessagePipeAdapter : public MessagePipe {
  public:
-  typedef base::Callback<void(int)> ErrorCallback;
+  typedef base::OnceCallback<void(int)> ErrorCallback;
 
   StreamMessagePipeAdapter(std::unique_ptr<P2PStreamSocket> socket,
-                           const ErrorCallback& error_callback);
+                           ErrorCallback error_callback);
   ~StreamMessagePipeAdapter() override;
 
   // MessagePipe interface.
@@ -49,7 +49,7 @@ class StreamMessagePipeAdapter : public MessagePipe {
 
 class StreamMessageChannelFactoryAdapter : public MessageChannelFactory {
  public:
-  typedef base::Callback<void(int)> ErrorCallback;
+  typedef base::RepeatingCallback<void(int)> ErrorCallback;
 
   StreamMessageChannelFactoryAdapter(
       StreamChannelFactory* stream_channel_factory,