Convert Bind to BindOnce or BindRepeating in //remoting/protocol
There's one non-trivial change to MessageReader, where a
RepeatingCallback is converted into a OnceCallback.
Bug: 1007823
Change-Id: I36415fedbd670bc3b9b8c68db8e3bbde4dd73d1a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2271161
Commit-Queue: Evan Stade <[email protected]>
Reviewed-by: Joe Downing <[email protected]>
Cr-Commit-Position: refs/heads/master@{#785429}
diff --git a/remoting/protocol/audio_pump.cc b/remoting/protocol/audio_pump.cc
index 2db03e3..112e128 100644
--- a/remoting/protocol/audio_pump.cc
+++ b/remoting/protocol/audio_pump.cc
@@ -148,7 +148,7 @@
DCHECK(thread_checker_.CalledOnValidThread());
audio_source_->Start(
- base::Bind(&Core::EncodeAudioPacket, base::Unretained(this)));
+ base::BindRepeating(&Core::EncodeAudioPacket, base::Unretained(this)));
}
void AudioPump::Core::Pause(bool pause) {
diff --git a/remoting/protocol/authenticator_test_base.cc b/remoting/protocol/authenticator_test_base.cc
index 6c533094..80846440 100644
--- a/remoting/protocol/authenticator_test_base.cc
+++ b/remoting/protocol/authenticator_test_base.cc
@@ -125,13 +125,13 @@
client_auth_->SecureAndAuthenticate(
std::move(client_fake_socket_),
- base::Bind(&AuthenticatorTestBase::OnClientConnected,
- base::Unretained(this)));
+ base::BindOnce(&AuthenticatorTestBase::OnClientConnected,
+ base::Unretained(this)));
host_auth_->SecureAndAuthenticate(
std::move(host_fake_socket_),
- base::Bind(&AuthenticatorTestBase::OnHostConnected,
- base::Unretained(this)));
+ base::BindOnce(&AuthenticatorTestBase::OnHostConnected,
+ base::Unretained(this)));
// Expect two callbacks to be called - the client callback and the host
// callback.
diff --git a/remoting/protocol/capture_scheduler_unittest.cc b/remoting/protocol/capture_scheduler_unittest.cc
index 32e1a1b5..e41f0de1 100644
--- a/remoting/protocol/capture_scheduler_unittest.cc
+++ b/remoting/protocol/capture_scheduler_unittest.cc
@@ -28,8 +28,8 @@
CaptureSchedulerTest() : capture_called_(false) {}
void InitScheduler() {
- scheduler_.reset(new CaptureScheduler(
- base::Bind(&CaptureSchedulerTest::DoCapture, base::Unretained(this))));
+ scheduler_.reset(new CaptureScheduler(base::BindRepeating(
+ &CaptureSchedulerTest::DoCapture, base::Unretained(this))));
scheduler_->set_minimum_interval(
base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs));
scheduler_->SetTickClockForTest(&tick_clock_);
diff --git a/remoting/protocol/channel_dispatcher_base.cc b/remoting/protocol/channel_dispatcher_base.cc
index fd8f21e8..a6d0909 100644
--- a/remoting/protocol/channel_dispatcher_base.cc
+++ b/remoting/protocol/channel_dispatcher_base.cc
@@ -27,8 +27,9 @@
channel_factory_ = channel_factory;
event_handler_ = event_handler;
- channel_factory_->CreateChannel(channel_name_, base::Bind(
- &ChannelDispatcherBase::OnChannelReady, base::Unretained(this)));
+ channel_factory_->CreateChannel(
+ channel_name_, base::BindOnce(&ChannelDispatcherBase::OnChannelReady,
+ base::Unretained(this)));
}
void ChannelDispatcherBase::Init(std::unique_ptr<MessagePipe> message_pipe,
diff --git a/remoting/protocol/channel_multiplexer.cc b/remoting/protocol/channel_multiplexer.cc
index 88098be..61ffcc91 100644
--- a/remoting/protocol/channel_multiplexer.cc
+++ b/remoting/protocol/channel_multiplexer.cc
@@ -339,8 +339,8 @@
if (pending_channels_.size() == 1U) {
base_channel_factory_->CreateChannel(
base_channel_name_,
- base::Bind(&ChannelMultiplexer::OnBaseChannelReady,
- base::Unretained(this)));
+ base::BindOnce(&ChannelMultiplexer::OnBaseChannelReady,
+ base::Unretained(this)));
}
}
}
@@ -362,13 +362,14 @@
if (base_channel_.get()) {
// Initialize reader and writer.
- reader_.StartReading(base_channel_.get(),
- base::Bind(&ChannelMultiplexer::OnIncomingPacket,
- base::Unretained(this)),
- base::Bind(&ChannelMultiplexer::OnBaseChannelError,
- base::Unretained(this)));
- writer_.Start(base::Bind(&P2PStreamSocket::Write,
- base::Unretained(base_channel_.get())),
+ reader_.StartReading(
+ base_channel_.get(),
+ base::BindRepeating(&ChannelMultiplexer::OnIncomingPacket,
+ base::Unretained(this)),
+ base::BindOnce(&ChannelMultiplexer::OnBaseChannelError,
+ base::Unretained(this)));
+ writer_.Start(base::BindRepeating(&P2PStreamSocket::Write,
+ base::Unretained(base_channel_.get())),
base::BindOnce(&ChannelMultiplexer::OnBaseChannelError,
base::Unretained(this)));
}
diff --git a/remoting/protocol/channel_multiplexer_unittest.cc b/remoting/protocol/channel_multiplexer_unittest.cc
index 22bbfde..7d8ee4b 100644
--- a/remoting/protocol/channel_multiplexer_unittest.cc
+++ b/remoting/protocol/channel_multiplexer_unittest.cc
@@ -91,12 +91,12 @@
std::unique_ptr<P2PStreamSocket>* host_socket,
std::unique_ptr<P2PStreamSocket>* client_socket) {
int counter = 2;
- host_mux_->CreateChannel(name, base::Bind(
- &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this),
- host_socket, &counter));
- client_mux_->CreateChannel(name, base::Bind(
- &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this),
- client_socket, &counter));
+ host_mux_->CreateChannel(
+ name, base::BindOnce(&ChannelMultiplexerTest::OnChannelConnected,
+ base::Unretained(this), host_socket, &counter));
+ client_mux_->CreateChannel(
+ name, base::BindOnce(&ChannelMultiplexerTest::OnChannelConnected,
+ base::Unretained(this), client_socket, &counter));
base::RunLoop().Run();
@@ -323,10 +323,12 @@
MockConnectCallback cb1;
MockConnectCallback cb2;
- host_mux_->CreateChannel(kTestChannelName, base::Bind(
- &MockConnectCallback::OnConnected, base::Unretained(&cb1)));
- host_mux_->CreateChannel(kTestChannelName2, base::Bind(
- &MockConnectCallback::OnConnected, base::Unretained(&cb2)));
+ host_mux_->CreateChannel(kTestChannelName,
+ base::BindOnce(&MockConnectCallback::OnConnected,
+ base::Unretained(&cb1)));
+ host_mux_->CreateChannel(kTestChannelName2,
+ base::BindOnce(&MockConnectCallback::OnConnected,
+ base::Unretained(&cb2)));
EXPECT_CALL(cb1, OnConnectedPtr(nullptr))
.Times(AtMost(1))
diff --git a/remoting/protocol/channel_socket_adapter_unittest.cc b/remoting/protocol/channel_socket_adapter_unittest.cc
index 769cb61..00a3d65 100644
--- a/remoting/protocol/channel_socket_adapter_unittest.cc
+++ b/remoting/protocol/channel_socket_adapter_unittest.cc
@@ -37,10 +37,10 @@
class TransportChannelSocketAdapterTest : public testing::Test {
public:
TransportChannelSocketAdapterTest()
- : callback_(base::Bind(&TransportChannelSocketAdapterTest::Callback,
- base::Unretained(this))),
- callback_result_(0) {
- }
+ : callback_(
+ base::BindRepeating(&TransportChannelSocketAdapterTest::Callback,
+ base::Unretained(this))),
+ callback_result_(0) {}
protected:
void SetUp() override {
diff --git a/remoting/protocol/client_video_dispatcher_unittest.cc b/remoting/protocol/client_video_dispatcher_unittest.cc
index 95ae9a5..349358e 100644
--- a/remoting/protocol/client_video_dispatcher_unittest.cc
+++ b/remoting/protocol/client_video_dispatcher_unittest.cc
@@ -71,22 +71,23 @@
ClientVideoDispatcherTest::ClientVideoDispatcherTest()
: channel_factory_adapter_(
&client_channel_factory_,
- base::Bind(&ClientVideoDispatcherTest::OnChannelError,
- base::Unretained(this))),
+ base::BindRepeating(&ClientVideoDispatcherTest::OnChannelError,
+ base::Unretained(this))),
dispatcher_(this, &client_stub_) {
dispatcher_.Init(&channel_factory_adapter_, this);
base::RunLoop().RunUntilIdle();
DCHECK(initialized_);
host_socket_.PairWith(
client_channel_factory_.GetFakeChannel(kVideoChannelName));
- reader_.StartReading(&host_socket_,
- base::Bind(&ClientVideoDispatcherTest::OnMessageReceived,
- base::Unretained(this)),
- base::Bind(&ClientVideoDispatcherTest::OnReadError,
- base::Unretained(this)));
- writer_.Start(
- base::Bind(&P2PStreamSocket::Write, base::Unretained(&host_socket_)),
- BufferedSocketWriter::WriteFailedCallback());
+ reader_.StartReading(
+ &host_socket_,
+ base::BindRepeating(&ClientVideoDispatcherTest::OnMessageReceived,
+ base::Unretained(this)),
+ base::BindOnce(&ClientVideoDispatcherTest::OnReadError,
+ base::Unretained(this)));
+ writer_.Start(base::BindRepeating(&P2PStreamSocket::Write,
+ base::Unretained(&host_socket_)),
+ BufferedSocketWriter::WriteFailedCallback());
}
void ClientVideoDispatcherTest::ProcessVideoPacket(
diff --git a/remoting/protocol/connection_unittest.cc b/remoting/protocol/connection_unittest.cc
index 6dc2d85..7916df9 100644
--- a/remoting/protocol/connection_unittest.cc
+++ b/remoting/protocol/connection_unittest.cc
@@ -143,8 +143,8 @@
bool Start(const PacketCapturedCallback& callback) override {
callback_ = callback;
timer_.Start(FROM_HERE, kAudioPacketDuration,
- base::Bind(&TestAudioSource::GenerateAudioSamples,
- base::Unretained(this)));
+ base::BindRepeating(&TestAudioSource::GenerateAudioSamples,
+ base::Unretained(this)));
return true;
}
@@ -392,10 +392,12 @@
// VideoStub otherwise.
if (is_using_webrtc()) {
client_video_renderer_.GetFrameConsumer()->set_on_frame_callback(
- base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
+ base::BindRepeating(&base::RunLoop::Quit,
+ base::Unretained(&run_loop)));
} else {
client_video_renderer_.GetVideoStub()->set_on_frame_callback(
- base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
+ base::BindRepeating(&base::RunLoop::Quit,
+ base::Unretained(&run_loop)));
}
run_loop.Run();
@@ -427,7 +429,7 @@
base::RunLoop run_loop;
client_video_renderer_.GetFrameStatsConsumer()->set_on_stats_callback(
- base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
+ base::BindRepeating(&base::RunLoop::Quit, base::Unretained(&run_loop)));
run_loop.Run();
client_video_renderer_.GetFrameStatsConsumer()->set_on_stats_callback({});
diff --git a/remoting/protocol/data_channel_manager_unittest.cc b/remoting/protocol/data_channel_manager_unittest.cc
index 0fc90e4..a83c136 100644
--- a/remoting/protocol/data_channel_manager_unittest.cc
+++ b/remoting/protocol/data_channel_manager_unittest.cc
@@ -101,20 +101,24 @@
void TestDataChannelManagerFullMatch(bool asynchronous) {
base::test::SingleThreadTaskEnvironment task_environment;
DataChannelManager manager;
- manager.RegisterCreateHandlerCallback("FullMatch", base::Bind(
- [](const std::string& expected_data,
- const std::string& name,
- std::unique_ptr<MessagePipe> pipe) -> void {
- new FakeNamedMessagePipeHandler(name, std::move(pipe), expected_data);
- },
- "FullMatchContent"));
- manager.RegisterCreateHandlerCallback("AnotherFullMatch", base::Bind(
- [](const std::string& expected_data,
- const std::string& name,
- std::unique_ptr<MessagePipe> pipe) -> void {
- new FakeNamedMessagePipeHandler(name, std::move(pipe), expected_data);
- },
- "AnotherFullMatchContent"));
+ manager.RegisterCreateHandlerCallback(
+ "FullMatch",
+ base::BindRepeating(
+ [](const std::string& expected_data, const std::string& name,
+ std::unique_ptr<MessagePipe> pipe) -> void {
+ new FakeNamedMessagePipeHandler(name, std::move(pipe),
+ expected_data);
+ },
+ "FullMatchContent"));
+ manager.RegisterCreateHandlerCallback(
+ "AnotherFullMatch",
+ base::BindRepeating(
+ [](const std::string& expected_data, const std::string& name,
+ std::unique_ptr<MessagePipe> pipe) -> void {
+ new FakeNamedMessagePipeHandler(name, std::move(pipe),
+ expected_data);
+ },
+ "AnotherFullMatchContent"));
FakeMessagePipe pipe1(asynchronous);
FakeMessagePipe pipe2(asynchronous);
@@ -193,20 +197,24 @@
void TestDataChannelManagerMultipleRegistrations(bool asynchronous) {
base::test::SingleThreadTaskEnvironment task_environment;
DataChannelManager manager;
- manager.RegisterCreateHandlerCallback("FullMatch", base::Bind(
- [](const std::string& expected_data,
- const std::string& name,
- std::unique_ptr<MessagePipe> pipe) -> void {
- new FakeNamedMessagePipeHandler(name, std::move(pipe), expected_data);
- },
- "FullMatchContent"));
- manager.RegisterCreateHandlerCallback("Prefix-", base::Bind(
- [](const std::string& expected_data,
- const std::string& name,
- std::unique_ptr<MessagePipe> pipe) -> void {
- new FakeNamedMessagePipeHandler(name, std::move(pipe), expected_data);
- },
- "PrefixMatchContent"));
+ manager.RegisterCreateHandlerCallback(
+ "FullMatch",
+ base::BindRepeating(
+ [](const std::string& expected_data, const std::string& name,
+ std::unique_ptr<MessagePipe> pipe) -> void {
+ new FakeNamedMessagePipeHandler(name, std::move(pipe),
+ expected_data);
+ },
+ "FullMatchContent"));
+ manager.RegisterCreateHandlerCallback(
+ "Prefix-",
+ base::BindRepeating(
+ [](const std::string& expected_data, const std::string& name,
+ std::unique_ptr<MessagePipe> pipe) -> void {
+ new FakeNamedMessagePipeHandler(name, std::move(pipe),
+ expected_data);
+ },
+ "PrefixMatchContent"));
FakeMessagePipe pipe1(asynchronous);
FakeMessagePipe pipe2(asynchronous);
diff --git a/remoting/protocol/fake_session.cc b/remoting/protocol/fake_session.cc
index 972f095..4266e15 100644
--- a/remoting/protocol/fake_session.cc
+++ b/remoting/protocol/fake_session.cc
@@ -37,14 +37,15 @@
authenticator_.reset(new FakeAuthenticator(FakeAuthenticator::ACCEPT));
authenticator_->set_auth_key(kTestAuthKey);
transport_->Start(authenticator_.get(),
- base::Bind(&FakeSession::SendTransportInfo,
- weak_factory_.GetWeakPtr()));
+ base::BindRepeating(&FakeSession::SendTransportInfo,
+ weak_factory_.GetWeakPtr()));
// Initialize transport and authenticator on the host.
peer->authenticator_.reset(new FakeAuthenticator(FakeAuthenticator::ACCEPT));
peer->authenticator_->set_auth_key(kTestAuthKey);
- peer->transport_->Start(peer->authenticator_.get(),
- base::Bind(&FakeSession::SendTransportInfo, peer_));
+ peer->transport_->Start(
+ peer->authenticator_.get(),
+ base::BindRepeating(&FakeSession::SendTransportInfo, peer_));
peer->event_handler_->OnSessionStateChange(AUTHENTICATED);
event_handler_->OnSessionStateChange(AUTHENTICATED);
diff --git a/remoting/protocol/ice_connection_to_host.cc b/remoting/protocol/ice_connection_to_host.cc
index 53076f3..b258d46b 100644
--- a/remoting/protocol/ice_connection_to_host.cc
+++ b/remoting/protocol/ice_connection_to_host.cc
@@ -127,8 +127,8 @@
video_renderer_->GetVideoStub(),
base::TimeDelta::FromSeconds(
MonitoredVideoStub::kConnectivityCheckDelaySeconds),
- base::Bind(&IceConnectionToHost::OnVideoChannelStatus,
- base::Unretained(this))));
+ base::BindRepeating(&IceConnectionToHost::OnVideoChannelStatus,
+ base::Unretained(this))));
video_dispatcher_.reset(
new ClientVideoDispatcher(monitored_video_stub_.get(), client_stub_));
video_dispatcher_->Init(transport_->GetChannelFactory(), this);
diff --git a/remoting/protocol/ice_transport.cc b/remoting/protocol/ice_transport.cc
index a4e658c2..282c514 100644
--- a/remoting/protocol/ice_transport.cc
+++ b/remoting/protocol/ice_transport.cc
@@ -46,7 +46,8 @@
pseudotcp_channel_factory_.get(), authenticator));
message_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
secure_channel_factory_.get(),
- base::Bind(&IceTransport::OnChannelError, weak_factory_.GetWeakPtr())));
+ base::BindRepeating(&IceTransport::OnChannelError,
+ weak_factory_.GetWeakPtr())));
}
bool IceTransport::ProcessTransportInfo(jingle_xmpp::XmlElement* transport_info_xml) {
@@ -91,7 +92,8 @@
new ChannelMultiplexer(secure_channel_factory_.get(), kMuxChannelName));
mux_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
channel_multiplexer_.get(),
- base::Bind(&IceTransport::OnChannelError, weak_factory_.GetWeakPtr())));
+ base::BindRepeating(&IceTransport::OnChannelError,
+ weak_factory_.GetWeakPtr())));
}
return mux_channel_factory_.get();
}
diff --git a/remoting/protocol/ice_transport_unittest.cc b/remoting/protocol/ice_transport_unittest.cc
index aeeb6de..8c179e3 100644
--- a/remoting/protocol/ice_transport_unittest.cc
+++ b/remoting/protocol/ice_transport_unittest.cc
@@ -133,20 +133,20 @@
new FakeAuthenticator(FakeAuthenticator::ACCEPT));
}
- host_event_handler_.set_error_callback(base::Bind(
+ host_event_handler_.set_error_callback(base::BindRepeating(
&IceTransportTest::OnTransportError, base::Unretained(this)));
- client_event_handler_.set_error_callback(base::Bind(
+ client_event_handler_.set_error_callback(base::BindRepeating(
&IceTransportTest::OnTransportError, base::Unretained(this)));
// Start both transports.
host_transport_->Start(
host_authenticator_.get(),
- base::Bind(&IceTransportTest::ProcessTransportInfo,
- base::Unretained(this), &client_transport_));
+ base::BindRepeating(&IceTransportTest::ProcessTransportInfo,
+ base::Unretained(this), &client_transport_));
client_transport_->Start(
client_authenticator_.get(),
- base::Bind(&IceTransportTest::ProcessTransportInfo,
- base::Unretained(this), &host_transport_));
+ base::BindRepeating(&IceTransportTest::ProcessTransportInfo,
+ base::Unretained(this), &host_transport_));
}
void WaitUntilConnected() {
@@ -210,11 +210,11 @@
InitializeConnection();
client_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
host_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnHostChannelCreated,
+ base::Unretained(this)));
WaitUntilConnected();
@@ -228,11 +228,11 @@
InitializeConnection();
client_transport_->GetMultiplexedChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
host_transport_->GetMultiplexedChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnHostChannelCreated,
+ base::Unretained(this)));
WaitUntilConnected();
@@ -250,11 +250,11 @@
InitializeConnection();
client_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
host_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnHostChannelCreated,
+ base::Unretained(this)));
run_loop_.reset(new base::RunLoop());
@@ -283,11 +283,11 @@
InitializeConnection();
client_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
host_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnHostChannelCreated,
+ base::Unretained(this)));
// The RunLoop should quit in OnTransportError().
run_loop_.reset(new base::RunLoop());
@@ -308,8 +308,8 @@
InitializeConnection();
client_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
client_transport_->GetChannelFactory()->CancelChannelCreation(
kChannelName);
@@ -324,11 +324,11 @@
InitializeConnection();
client_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnClientChannelCreated,
+ base::Unretained(this)));
host_transport_->GetChannelFactory()->CreateChannel(
- kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
- base::Unretained(this)));
+ kChannelName, base::BindOnce(&IceTransportTest::OnHostChannelCreated,
+ base::Unretained(this)));
WaitUntilConnected();
diff --git a/remoting/protocol/jingle_session.cc b/remoting/protocol/jingle_session.cc
index 370c313..2c770226 100644
--- a/remoting/protocol/jingle_session.cc
+++ b/remoting/protocol/jingle_session.cc
@@ -750,8 +750,8 @@
void JingleSession::OnAuthenticated() {
transport_->Start(authenticator_.get(),
- base::Bind(&JingleSession::SendTransportInfo,
- weak_factory_.GetWeakPtr()));
+ base::BindRepeating(&JingleSession::SendTransportInfo,
+ weak_factory_.GetWeakPtr()));
base::WeakPtr<JingleSession> self = weak_factory_.GetWeakPtr();
std::vector<PendingMessage> messages_to_process;
diff --git a/remoting/protocol/jingle_session_manager.cc b/remoting/protocol/jingle_session_manager.cc
index e6a670ce..a743f87 100644
--- a/remoting/protocol/jingle_session_manager.cc
+++ b/remoting/protocol/jingle_session_manager.cc
@@ -136,8 +136,9 @@
it->second->OnIncomingMessage(
stanza->Attr(jingle_xmpp::QN_ID), std::move(message),
- base::Bind(&JingleSessionManager::SendReply, base::Unretained(this),
- base::Passed(std::move(stanza_copy))));
+ base::BindRepeating(&JingleSessionManager::SendReply,
+ base::Unretained(this),
+ base::Passed(std::move(stanza_copy))));
return true;
}
diff --git a/remoting/protocol/jingle_session_unittest.cc b/remoting/protocol/jingle_session_unittest.cc
index 0bf8217b..8449b823 100644
--- a/remoting/protocol/jingle_session_unittest.cc
+++ b/remoting/protocol/jingle_session_unittest.cc
@@ -198,8 +198,8 @@
host_server_.reset(new JingleSessionManager(host_signal_strategy_.get()));
host_server_->AcceptIncoming(
- base::Bind(&MockSessionManagerListener::OnIncomingSession,
- base::Unretained(&host_server_listener_)));
+ base::BindRepeating(&MockSessionManagerListener::OnIncomingSession,
+ base::Unretained(&host_server_listener_)));
std::unique_ptr<AuthenticatorFactory> factory(
new FakeHostAuthenticatorFactory(messages_till_start, auth_config));
@@ -426,7 +426,7 @@
host_transport_.send_transport_info_callback().Run(CreateTransportInfo("2"));
// Destroy the session as soon as the first message is received.
- client_transport_.set_on_message_callback(base::Bind(
+ client_transport_.set_on_message_callback(base::BindRepeating(
&JingleSessionTest::DeleteClientSession, base::Unretained(this)));
base::RunLoop().RunUntilIdle();
@@ -580,7 +580,7 @@
EXPECT_TRUE(client_transport_.received_messages().empty());
// Destroy the session as soon as the first message is received.
- client_transport_.set_on_message_callback(base::Bind(
+ client_transport_.set_on_message_callback(base::BindRepeating(
&JingleSessionTest::DeleteClientSession, base::Unretained(this)));
// Resume authentication.
diff --git a/remoting/protocol/message_reader.cc b/remoting/protocol/message_reader.cc
index cd08d89..f73a3cc 100644
--- a/remoting/protocol/message_reader.cc
+++ b/remoting/protocol/message_reader.cc
@@ -32,16 +32,16 @@
void MessageReader::StartReading(
P2PStreamSocket* socket,
const MessageReceivedCallback& message_received_callback,
- const ReadFailedCallback& read_failed_callback) {
+ ReadFailedCallback read_failed_callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!socket_);
DCHECK(socket);
- DCHECK(!message_received_callback.is_null());
- DCHECK(!read_failed_callback.is_null());
+ DCHECK(message_received_callback);
+ DCHECK(read_failed_callback);
socket_ = socket;
message_received_callback_ = message_received_callback;
- read_failed_callback_ = read_failed_callback;
+ read_failed_callback_ = std::move(read_failed_callback);
DoRead();
}
@@ -49,14 +49,14 @@
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Don't try to read again if there is another read pending or we
// have messages that we haven't finished processing yet.
- bool read_succeeded = true;
- while (read_succeeded && !closed_ && !read_pending_) {
+ while (!closed_ && !read_pending_) {
read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
int result = socket_->Read(
read_buffer_.get(), kReadBufferSize,
base::BindOnce(&MessageReader::OnRead, weak_factory_.GetWeakPtr()));
- HandleReadResult(result, &read_succeeded);
+ if (!HandleReadResult(result))
+ break;
}
}
@@ -66,33 +66,31 @@
read_pending_ = false;
if (!closed_) {
- bool read_succeeded;
- HandleReadResult(result, &read_succeeded);
- if (read_succeeded)
- DoRead();
+ HandleReadResult(result);
+ DoRead();
}
}
-void MessageReader::HandleReadResult(int result, bool* read_succeeded) {
+bool MessageReader::HandleReadResult(int result) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- if (closed_)
- return;
-
- *read_succeeded = true;
+ DCHECK(!closed_);
if (result > 0) {
OnDataReceived(read_buffer_.get(), result);
- *read_succeeded = true;
- } else if (result == net::ERR_IO_PENDING) {
- read_pending_ = true;
- } else {
- // Stop reading after any error.
- closed_ = true;
- *read_succeeded = false;
-
- LOG(ERROR) << "Read() returned error " << result;
- read_failed_callback_.Run(result);
+ return true;
}
+
+ if (result == net::ERR_IO_PENDING) {
+ read_pending_ = true;
+ return true;
+ }
+
+ // Stop reading after any error.
+ closed_ = true;
+ LOG(ERROR) << "Read() returned error " << result;
+ std::move(read_failed_callback_).Run(result);
+ // |this| may be deleted.
+ return false;
}
void MessageReader::OnDataReceived(net::IOBuffer* data, int data_size) {
@@ -113,7 +111,7 @@
}
void MessageReader::RunCallback(std::unique_ptr<CompoundBuffer> message) {
- if (!message_received_callback_.is_null()) {
+ if (message_received_callback_) {
message_received_callback_.Run(std::move(message));
}
}
diff --git a/remoting/protocol/message_reader.h b/remoting/protocol/message_reader.h
index b20421eb..6a62b99 100644
--- a/remoting/protocol/message_reader.h
+++ b/remoting/protocol/message_reader.h
@@ -38,7 +38,7 @@
public:
typedef base::RepeatingCallback<void(std::unique_ptr<CompoundBuffer> message)>
MessageReceivedCallback;
- typedef base::RepeatingCallback<void(int)> ReadFailedCallback;
+ typedef base::OnceCallback<void(int)> ReadFailedCallback;
MessageReader();
virtual ~MessageReader();
@@ -46,14 +46,17 @@
// Starts reading from |socket|.
void StartReading(P2PStreamSocket* socket,
const MessageReceivedCallback& message_received_callback,
- const ReadFailedCallback& read_failed_callback);
+ ReadFailedCallback read_failed_callback);
private:
void DoRead();
void OnRead(int result);
- void HandleReadResult(int result, bool* read_succeeded);
+ // Returns true on success, or runs |read_failed_callback_| and returns false
+ // on failure. When false is returned, |this| may be deleted.
+ bool HandleReadResult(int result);
void OnDataReceived(net::IOBuffer* data, int data_size);
void RunCallback(std::unique_ptr<CompoundBuffer> message);
+ bool DidReadFail();
ReadFailedCallback read_failed_callback_;
diff --git a/remoting/protocol/message_reader_unittest.cc b/remoting/protocol/message_reader_unittest.cc
index 90fd7559d..9e0b5ea 100644
--- a/remoting/protocol/message_reader_unittest.cc
+++ b/remoting/protocol/message_reader_unittest.cc
@@ -50,10 +50,11 @@
}
void InitReader() {
- reader_->StartReading(
- &socket_,
- base::Bind(&MessageReaderTest::OnMessage, base::Unretained(this)),
- base::Bind(&MessageReaderTest::OnReadError, base::Unretained(this)));
+ reader_->StartReading(&socket_,
+ base::BindRepeating(&MessageReaderTest::OnMessage,
+ base::Unretained(this)),
+ base::BindOnce(&MessageReaderTest::OnReadError,
+ base::Unretained(this)));
}
void AddMessage(const std::string& message) {
diff --git a/remoting/protocol/monitored_video_stub_unittest.cc b/remoting/protocol/monitored_video_stub_unittest.cc
index 14efa87..abb10f9 100644
--- a/remoting/protocol/monitored_video_stub_unittest.cc
+++ b/remoting/protocol/monitored_video_stub_unittest.cc
@@ -35,9 +35,8 @@
monitor_.reset(new MonitoredVideoStub(
&video_stub_,
base::TimeDelta::FromMilliseconds(kTestOverrideDelayMilliseconds),
- base::Bind(
- &MonitoredVideoStubTest::OnVideoChannelStatus,
- base::Unretained(this))));
+ base::BindRepeating(&MonitoredVideoStubTest::OnVideoChannelStatus,
+ base::Unretained(this))));
EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)).Times(AnyNumber());
}
diff --git a/remoting/protocol/negotiating_authenticator_unittest.cc b/remoting/protocol/negotiating_authenticator_unittest.cc
index b33a8dd..223ddba 100644
--- a/remoting/protocol/negotiating_authenticator_unittest.cc
+++ b/remoting/protocol/negotiating_authenticator_unittest.cc
@@ -75,8 +75,8 @@
client_auth_config.pairing_secret = client_paired_secret;
bool pairing_expected = pairing_registry_.get() != nullptr;
client_auth_config.fetch_secret_callback =
- base::Bind(&NegotiatingAuthenticatorTest::FetchSecret,
- client_interactive_pin, pairing_expected);
+ base::BindRepeating(&NegotiatingAuthenticatorTest::FetchSecret,
+ client_interactive_pin, pairing_expected);
client_as_negotiating_authenticator_ = new NegotiatingClientAuthenticator(
kClientJid, kHostJid, client_auth_config);
client_.reset(client_as_negotiating_authenticator_);
diff --git a/remoting/protocol/negotiating_client_authenticator.cc b/remoting/protocol/negotiating_client_authenticator.cc
index 8f413bb7..5a4b2329 100644
--- a/remoting/protocol/negotiating_client_authenticator.cc
+++ b/remoting/protocol/negotiating_client_authenticator.cc
@@ -135,15 +135,15 @@
case Method::THIRD_PARTY_SPAKE2_P224:
current_authenticator_.reset(new ThirdPartyClientAuthenticator(
- base::Bind(&V2Authenticator::CreateForClient),
+ base::BindRepeating(&V2Authenticator::CreateForClient),
config_.fetch_third_party_token_callback));
std::move(resume_callback).Run();
break;
case Method::THIRD_PARTY_SPAKE2_CURVE25519:
current_authenticator_.reset(new ThirdPartyClientAuthenticator(
- base::Bind(&Spake2Authenticator::CreateForClient, local_id_,
- remote_id_),
+ base::BindRepeating(&Spake2Authenticator::CreateForClient, local_id_,
+ remote_id_),
config_.fetch_third_party_token_callback));
std::move(resume_callback).Run();
break;
@@ -151,7 +151,7 @@
case Method::PAIRED_SPAKE2_P224: {
PairingClientAuthenticator* pairing_authenticator =
new PairingClientAuthenticator(
- config_, base::Bind(&V2Authenticator::CreateForClient));
+ config_, base::BindRepeating(&V2Authenticator::CreateForClient));
current_authenticator_ = base::WrapUnique(pairing_authenticator);
pairing_authenticator->Start(preferred_initial_state,
std::move(resume_callback));
@@ -161,7 +161,8 @@
case Method::PAIRED_SPAKE2_CURVE25519: {
PairingClientAuthenticator* pairing_authenticator =
new PairingClientAuthenticator(
- config_, base::Bind(&Spake2Authenticator::CreateForClient,
+ config_,
+ base::BindRepeating(&Spake2Authenticator::CreateForClient,
local_id_, remote_id_));
current_authenticator_ = base::WrapUnique(pairing_authenticator);
pairing_authenticator->Start(preferred_initial_state,
@@ -174,7 +175,7 @@
case Method::SHARED_SECRET_SPAKE2_CURVE25519:
config_.fetch_secret_callback.Run(
false,
- base::Bind(
+ base::BindRepeating(
&NegotiatingClientAuthenticator::CreateSharedSecretAuthenticator,
weak_factory_.GetWeakPtr(), preferred_initial_state,
base::Passed(std::move(resume_callback))));
@@ -188,7 +189,7 @@
methods_.end()) {
PairingClientAuthenticator* pairing_authenticator =
new PairingClientAuthenticator(
- config_, base::Bind(&V2Authenticator::CreateForClient));
+ config_, base::BindRepeating(&V2Authenticator::CreateForClient));
current_authenticator_ = base::WrapUnique(pairing_authenticator);
pairing_authenticator->StartPaired(MESSAGE_READY);
current_method_ = Method::PAIRED_SPAKE2_P224;
diff --git a/remoting/protocol/negotiating_host_authenticator.cc b/remoting/protocol/negotiating_host_authenticator.cc
index 571d7bca..60904674 100644
--- a/remoting/protocol/negotiating_host_authenticator.cc
+++ b/remoting/protocol/negotiating_host_authenticator.cc
@@ -185,8 +185,8 @@
case Method::THIRD_PARTY_SPAKE2_P224:
current_authenticator_.reset(new ThirdPartyHostAuthenticator(
- base::Bind(&V2Authenticator::CreateForHost, local_cert_,
- local_key_pair_),
+ base::BindRepeating(&V2Authenticator::CreateForHost, local_cert_,
+ local_key_pair_),
token_validator_factory_->CreateTokenValidator(local_id_,
remote_id_)));
std::move(resume_callback).Run();
@@ -194,8 +194,8 @@
case Method::THIRD_PARTY_SPAKE2_CURVE25519:
current_authenticator_.reset(new ThirdPartyHostAuthenticator(
- base::Bind(&Spake2Authenticator::CreateForHost, local_id_, remote_id_,
- local_cert_, local_key_pair_),
+ base::BindRepeating(&Spake2Authenticator::CreateForHost, local_id_,
+ remote_id_, local_cert_, local_key_pair_),
token_validator_factory_->CreateTokenValidator(local_id_,
remote_id_)));
std::move(resume_callback).Run();
@@ -204,8 +204,9 @@
case Method::PAIRED_SPAKE2_P224: {
PairingHostAuthenticator* pairing_authenticator =
new PairingHostAuthenticator(
- pairing_registry_, base::Bind(&V2Authenticator::CreateForHost,
- local_cert_, local_key_pair_),
+ pairing_registry_,
+ base::BindRepeating(&V2Authenticator::CreateForHost, local_cert_,
+ local_key_pair_),
shared_secret_hash_);
current_authenticator_.reset(pairing_authenticator);
pairing_authenticator->Initialize(client_id_, preferred_initial_state,
@@ -217,8 +218,9 @@
PairingHostAuthenticator* pairing_authenticator =
new PairingHostAuthenticator(
pairing_registry_,
- base::Bind(&Spake2Authenticator::CreateForHost, local_id_,
- remote_id_, local_cert_, local_key_pair_),
+ base::BindRepeating(&Spake2Authenticator::CreateForHost,
+ local_id_, remote_id_, local_cert_,
+ local_key_pair_),
shared_secret_hash_);
current_authenticator_.reset(pairing_authenticator);
pairing_authenticator->Initialize(client_id_, preferred_initial_state,
diff --git a/remoting/protocol/pairing_client_authenticator.cc b/remoting/protocol/pairing_client_authenticator.cc
index c8c6ffc..bd6874e 100644
--- a/remoting/protocol/pairing_client_authenticator.cc
+++ b/remoting/protocol/pairing_client_authenticator.cc
@@ -58,9 +58,9 @@
DCHECK(!waiting_for_pin_);
waiting_for_pin_ = true;
client_auth_config_.fetch_secret_callback.Run(
- true, base::Bind(&PairingClientAuthenticator::OnPinFetched,
- weak_factory_.GetWeakPtr(), initial_state,
- base::Passed(std::move(resume_callback))));
+ true, base::BindRepeating(&PairingClientAuthenticator::OnPinFetched,
+ weak_factory_.GetWeakPtr(), initial_state,
+ base::Passed(std::move(resume_callback))));
}
void PairingClientAuthenticator::OnPinFetched(State initial_state,
diff --git a/remoting/protocol/performance_tracker.cc b/remoting/protocol/performance_tracker.cc
index 3f69140..927f3d2 100644
--- a/remoting/protocol/performance_tracker.cc
+++ b/remoting/protocol/performance_tracker.cc
@@ -88,9 +88,12 @@
video_decode_ms_(kLatencySampleSize),
video_paint_ms_(kLatencySampleSize),
round_trip_ms_(kLatencySampleSize) {
- uma_custom_counts_updater_ = base::Bind(&UpdateUmaCustomHistogramStub);
- uma_custom_times_updater_ = base::Bind(&UpdateUmaCustomHistogramStub);
- uma_enum_histogram_updater_ = base::Bind(&UpdateUmaEnumHistogramStub);
+ uma_custom_counts_updater_ =
+ base::BindRepeating(&UpdateUmaCustomHistogramStub);
+ uma_custom_times_updater_ =
+ base::BindRepeating(&UpdateUmaCustomHistogramStub);
+ uma_enum_histogram_updater_ =
+ base::BindRepeating(&UpdateUmaEnumHistogramStub);
}
PerformanceTracker::~PerformanceTracker() = default;
@@ -112,8 +115,8 @@
if (!is_paused_ && !upload_uma_stats_timer_.IsRunning()) {
upload_uma_stats_timer_.Start(
FROM_HERE, base::TimeDelta::FromSeconds(kStatsUpdatePeriodSeconds),
- base::Bind(&PerformanceTracker::UploadRateStatsToUma,
- base::Unretained(this)));
+ base::BindRepeating(&PerformanceTracker::UploadRateStatsToUma,
+ base::Unretained(this)));
}
// Record this received packet, even if it is empty.
diff --git a/remoting/protocol/port_allocator.cc b/remoting/protocol/port_allocator.cc
index b6bdfe2..ac87026f 100644
--- a/remoting/protocol/port_allocator.cc
+++ b/remoting/protocol/port_allocator.cc
@@ -75,7 +75,7 @@
PortAllocatorSession::~PortAllocatorSession() = default;
void PortAllocatorSession::GetPortConfigurations() {
- transport_context_->GetIceConfig(base::Bind(
+ transport_context_->GetIceConfig(base::BindOnce(
&PortAllocatorSession::OnIceConfig, weak_factory_.GetWeakPtr()));
}
diff --git a/remoting/protocol/pseudotcp_adapter.cc b/remoting/protocol/pseudotcp_adapter.cc
index bdb467f..0b26d15 100644
--- a/remoting/protocol/pseudotcp_adapter.cc
+++ b/remoting/protocol/pseudotcp_adapter.cc
@@ -347,9 +347,10 @@
// send exactly as many bytes as we requested, or fail.
int result;
if (socket_) {
- result = socket_->Send(
- write_buffer.get(), len,
- base::Bind(&PseudoTcpAdapter::Core::OnWritten, base::Unretained(this)));
+ result =
+ socket_->Send(write_buffer.get(), len,
+ base::BindRepeating(&PseudoTcpAdapter::Core::OnWritten,
+ base::Unretained(this)));
} else {
result = net::ERR_CONNECTION_CLOSED;
}
@@ -371,9 +372,9 @@
int result = 1;
while (socket_ && result > 0) {
- result = socket_->Recv(
- socket_read_buffer_.get(), kReadBufferSize,
- base::Bind(&PseudoTcpAdapter::Core::OnRead, base::Unretained(this)));
+ result = socket_->Recv(socket_read_buffer_.get(), kReadBufferSize,
+ base::BindRepeating(&PseudoTcpAdapter::Core::OnRead,
+ base::Unretained(this)));
if (result != net::ERR_IO_PENDING)
HandleReadResults(result);
}
diff --git a/remoting/protocol/secure_channel_factory.cc b/remoting/protocol/secure_channel_factory.cc
index f52fa3bd..83318588 100644
--- a/remoting/protocol/secure_channel_factory.cc
+++ b/remoting/protocol/secure_channel_factory.cc
@@ -60,9 +60,9 @@
channel_authenticators_[name] = channel_authenticator;
channel_authenticator->SecureAndAuthenticate(
std::move(socket),
- base::Bind(&SecureChannelFactory::OnSecureChannelCreated,
- base::Unretained(this), name,
- base::Passed(std::move(callback))));
+ base::BindOnce(&SecureChannelFactory::OnSecureChannelCreated,
+ base::Unretained(this), name,
+ base::Passed(std::move(callback))));
}
void SecureChannelFactory::OnSecureChannelCreated(
diff --git a/remoting/protocol/ssl_hmac_channel_authenticator_unittest.cc b/remoting/protocol/ssl_hmac_channel_authenticator_unittest.cc
index 4bf7f4e..0833b9f 100644
--- a/remoting/protocol/ssl_hmac_channel_authenticator_unittest.cc
+++ b/remoting/protocol/ssl_hmac_channel_authenticator_unittest.cc
@@ -82,13 +82,14 @@
client_auth_->SecureAndAuthenticate(
std::move(client_fake_socket_),
- base::Bind(&SslHmacChannelAuthenticatorTest::OnClientConnected,
- base::Unretained(this)));
+ base::BindOnce(&SslHmacChannelAuthenticatorTest::OnClientConnected,
+ base::Unretained(this)));
host_auth_->SecureAndAuthenticate(
std::move(host_fake_socket_),
- base::Bind(&SslHmacChannelAuthenticatorTest::OnHostConnected,
- base::Unretained(this), std::string("ref argument value")));
+ base::BindOnce(&SslHmacChannelAuthenticatorTest::OnHostConnected,
+ base::Unretained(this),
+ std::string("ref argument value")));
// Expect two callbacks to be called - the client callback and the host
// callback.
diff --git a/remoting/protocol/stream_message_pipe_adapter.cc b/remoting/protocol/stream_message_pipe_adapter.cc
index 33d7699..a8713de 100644
--- a/remoting/protocol/stream_message_pipe_adapter.cc
+++ b/remoting/protocol/stream_message_pipe_adapter.cc
@@ -34,17 +34,17 @@
event_handler_ = event_handler;
writer_ = std::make_unique<BufferedSocketWriter>();
- writer_->Start(
- base::Bind(&P2PStreamSocket::Write, base::Unretained(socket_.get())),
- base::BindOnce(&StreamMessagePipeAdapter::CloseOnError,
- base::Unretained(this)));
+ writer_->Start(base::BindRepeating(&P2PStreamSocket::Write,
+ base::Unretained(socket_.get())),
+ base::BindOnce(&StreamMessagePipeAdapter::CloseOnError,
+ base::Unretained(this)));
reader_ = std::make_unique<MessageReader>();
reader_->StartReading(socket_.get(),
- base::Bind(&EventHandler::OnMessageReceived,
- base::Unretained(event_handler_)),
- base::Bind(&StreamMessagePipeAdapter::CloseOnError,
- base::Unretained(this)));
+ base::BindRepeating(&EventHandler::OnMessageReceived,
+ base::Unretained(event_handler_)),
+ base::BindOnce(&StreamMessagePipeAdapter::CloseOnError,
+ base::Unretained(this)));
event_handler_->OnMessagePipeOpen();
}
diff --git a/remoting/protocol/third_party_authenticator_unittest.cc b/remoting/protocol/third_party_authenticator_unittest.cc
index c63343d..78bd7c12 100644
--- a/remoting/protocol/third_party_authenticator_unittest.cc
+++ b/remoting/protocol/third_party_authenticator_unittest.cc
@@ -105,12 +105,13 @@
void InitAuthenticators() {
token_validator_ = new FakeTokenValidator();
host_.reset(new ThirdPartyHostAuthenticator(
- base::Bind(&V2Authenticator::CreateForHost, host_cert_, key_pair_),
+ base::BindRepeating(&V2Authenticator::CreateForHost, host_cert_,
+ key_pair_),
base::WrapUnique(token_validator_)));
client_.reset(new ThirdPartyClientAuthenticator(
- base::Bind(&V2Authenticator::CreateForClient),
- base::Bind(&FakeTokenFetcher::FetchThirdPartyToken,
- base::Unretained(&token_fetcher_))));
+ base::BindRepeating(&V2Authenticator::CreateForClient),
+ base::BindRepeating(&FakeTokenFetcher::FetchThirdPartyToken,
+ base::Unretained(&token_fetcher_))));
}
FakeTokenFetcher token_fetcher_;
diff --git a/remoting/protocol/third_party_client_authenticator.cc b/remoting/protocol/third_party_client_authenticator.cc
index 486bfd4..08e242f 100644
--- a/remoting/protocol/third_party_client_authenticator.cc
+++ b/remoting/protocol/third_party_client_authenticator.cc
@@ -46,9 +46,10 @@
fetch_token_callback_.Run(
token_url, token_scope,
- base::Bind(&ThirdPartyClientAuthenticator::OnThirdPartyTokenFetched,
- weak_factory_.GetWeakPtr(),
- base::Passed(std::move(resume_callback))));
+ base::BindRepeating(
+ &ThirdPartyClientAuthenticator::OnThirdPartyTokenFetched,
+ weak_factory_.GetWeakPtr(),
+ base::Passed(std::move(resume_callback))));
}
void ThirdPartyClientAuthenticator::AddTokenElements(
diff --git a/remoting/protocol/video_frame_pump.cc b/remoting/protocol/video_frame_pump.cc
index 226f8f40..d138694 100644
--- a/remoting/protocol/video_frame_pump.cc
+++ b/remoting/protocol/video_frame_pump.cc
@@ -51,10 +51,10 @@
keep_alive_timer_(
FROM_HERE,
base::TimeDelta::FromMilliseconds(kKeepAlivePacketIntervalMs),
- base::Bind(&VideoFramePump::SendKeepAlivePacket,
- base::Unretained(this))),
- capture_scheduler_(base::Bind(&VideoFramePump::CaptureNextFrame,
- base::Unretained(this))) {
+ base::BindRepeating(&VideoFramePump::SendKeepAlivePacket,
+ base::Unretained(this))),
+ capture_scheduler_(base::BindRepeating(&VideoFramePump::CaptureNextFrame,
+ base::Unretained(this))) {
DCHECK(encoder_);
DCHECK(video_stub_);
diff --git a/remoting/protocol/video_frame_pump_unittest.cc b/remoting/protocol/video_frame_pump_unittest.cc
index cb002d3..90ecfde 100644
--- a/remoting/protocol/video_frame_pump_unittest.cc
+++ b/remoting/protocol/video_frame_pump_unittest.cc
@@ -205,7 +205,7 @@
base::RunLoop run_loop;
// Set up the capturer to return null frames.
- capturer->set_frame_generator(base::Bind(&CreateNullFrame));
+ capturer->set_frame_generator(base::BindRepeating(&CreateNullFrame));
// Expect that the VideoEncoder::Encode() method is never called.
EXPECT_CALL(*encoder, EncodePtr(_)).Times(0);
@@ -232,7 +232,7 @@
base::RunLoop run_loop;
// Set up the capturer to return unchanged frames.
- capturer->set_frame_generator(base::Bind(&CreateUnchangedFrame));
+ capturer->set_frame_generator(base::BindRepeating(&CreateUnchangedFrame));
// Expect that the VideoEncoder::Encode() method is called.
EXPECT_CALL(*encoder, EncodePtr(_)).WillRepeatedly(Return(nullptr));
diff --git a/remoting/protocol/webrtc_audio_source_adapter.cc b/remoting/protocol/webrtc_audio_source_adapter.cc
index 72ed24f24..d80c9934 100644
--- a/remoting/protocol/webrtc_audio_source_adapter.cc
+++ b/remoting/protocol/webrtc_audio_source_adapter.cc
@@ -68,7 +68,7 @@
DCHECK(thread_checker_.CalledOnValidThread());
audio_source_ = std::move(audio_source);
audio_source_->Start(
- base::Bind(&Core::OnAudioPacket, base::Unretained(this)));
+ base::BindRepeating(&Core::OnAudioPacket, base::Unretained(this)));
}
void WebrtcAudioSourceAdapter::Core::Pause(bool pause) {
diff --git a/remoting/protocol/webrtc_frame_scheduler_unittest.cc b/remoting/protocol/webrtc_frame_scheduler_unittest.cc
index 3af2de2..482ccd82 100644
--- a/remoting/protocol/webrtc_frame_scheduler_unittest.cc
+++ b/remoting/protocol/webrtc_frame_scheduler_unittest.cc
@@ -33,9 +33,10 @@
video_encoder_factory_.reset(new WebrtcDummyVideoEncoderFactory());
scheduler_.reset(new WebrtcFrameSchedulerSimple(SessionOptions()));
scheduler_->SetTickClockForTest(task_runner_->GetMockTickClock());
- scheduler_->Start(video_encoder_factory_.get(),
- base::Bind(&WebrtcFrameSchedulerTest::CaptureCallback,
- base::Unretained(this)));
+ scheduler_->Start(
+ video_encoder_factory_.get(),
+ base::BindRepeating(&WebrtcFrameSchedulerTest::CaptureCallback,
+ base::Unretained(this)));
}
~WebrtcFrameSchedulerTest() override = default;
diff --git a/remoting/protocol/webrtc_video_stream.cc b/remoting/protocol/webrtc_video_stream.cc
index 5d6c477c..fe03fda 100644
--- a/remoting/protocol/webrtc_video_stream.cc
+++ b/remoting/protocol/webrtc_video_stream.cc
@@ -138,8 +138,8 @@
webrtc_transport_ = webrtc_transport;
webrtc_transport_->video_encoder_factory()->RegisterEncoderSelectedCallback(
- base::Bind(&WebrtcVideoStream::OnEncoderCreated,
- weak_factory_.GetWeakPtr()));
+ base::BindRepeating(&WebrtcVideoStream::OnEncoderCreated,
+ weak_factory_.GetWeakPtr()));
capturer_->Start(this);
@@ -159,9 +159,9 @@
webrtc_transport_->OnVideoTransceiverCreated(transceiver);
scheduler_.reset(new WebrtcFrameSchedulerSimple(session_options_));
- scheduler_->Start(
- webrtc_transport_->video_encoder_factory(),
- base::Bind(&WebrtcVideoStream::CaptureNextFrame, base::Unretained(this)));
+ scheduler_->Start(webrtc_transport_->video_encoder_factory(),
+ base::BindRepeating(&WebrtcVideoStream::CaptureNextFrame,
+ base::Unretained(this)));
video_stats_dispatcher_.Init(webrtc_transport_->CreateOutgoingChannel(
video_stats_dispatcher_.channel_name()),
