Commit 7428644b authored by Jun Cai's avatar Jun Cai Committed by Commit Bot

Convert base::Bind and base::Callback in //remoting/base to Once or Repeating

This CL converts base::Bind and base::Callback in //remoting/base to
Once or Repeating

Bug: 1007820
Change-Id: I92c6f555b8b9464beec2f53af00ee45846a52ccd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2067394Reviewed-by: default avatarJoe Downing <joedow@chromium.org>
Commit-Queue: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#745534}
parent b795f2d9
......@@ -173,10 +173,10 @@ void AutoThread::SetComInitType(ComInitType com_init_type) {
}
#endif
void AutoThread::QuitThread(const base::Closure& quit_when_idle_closure) {
void AutoThread::QuitThread(base::OnceClosure quit_when_idle_closure) {
DCHECK(thread_checker_.CalledOnValidThread());
quit_when_idle_closure.Run();
std::move(quit_when_idle_closure).Run();
was_quit_properly_ = true;
if (joiner_.get()) {
......@@ -206,8 +206,8 @@ void AutoThread::ThreadMain() {
// no more references to it remain.
startup_data_->task_runner = new AutoThreadTaskRunner(
single_thread_task_executor.task_runner(),
base::Bind(&AutoThread::QuitThread, base::Unretained(this),
run_loop.QuitWhenIdleClosure()));
base::BindOnce(&AutoThread::QuitThread, base::Unretained(this),
run_loop.QuitWhenIdleClosure()));
startup_data_->event.Signal();
// startup_data_ can't be touched anymore since the starting thread is now
......
......@@ -82,7 +82,7 @@ class AutoThread : base::PlatformThread::Delegate {
private:
AutoThread(const char* name, AutoThreadTaskRunner* joiner);
void QuitThread(const base::Closure& quit_when_idle_closure);
void QuitThread(base::OnceClosure quit_when_idle_closure);
void JoinAndDeleteThread();
// base::PlatformThread::Delegate methods:
......
......@@ -72,8 +72,8 @@ class AutoThreadTest : public testing::Test {
void SetUp() override {
main_task_runner_ = new AutoThreadTaskRunner(
task_environment_.GetMainThreadTaskRunner(),
base::Bind(&AutoThreadTest::QuitMainMessageLoop,
base::Unretained(this)));
base::BindOnce(&AutoThreadTest::QuitMainMessageLoop,
base::Unretained(this)));
}
void TearDown() override {
......
......@@ -44,10 +44,11 @@ struct BufferedSocketWriter::PendingPacket {
// static
std::unique_ptr<BufferedSocketWriter> BufferedSocketWriter::CreateForSocket(
net::Socket* socket,
const WriteFailedCallback& write_failed_callback) {
WriteFailedCallback write_failed_callback) {
std::unique_ptr<BufferedSocketWriter> result =
std::make_unique<BufferedSocketWriter>();
result->Start(base::Bind(&WriteNetSocket, socket), write_failed_callback);
result->Start(base::BindRepeating(&WriteNetSocket, socket),
std::move(write_failed_callback));
return result;
}
......@@ -57,11 +58,10 @@ BufferedSocketWriter::~BufferedSocketWriter() {
DCHECK(thread_checker_.CalledOnValidThread());
}
void BufferedSocketWriter::Start(
const WriteCallback& write_callback,
const WriteFailedCallback& write_failed_callback) {
void BufferedSocketWriter::Start(const WriteCallback& write_callback,
WriteFailedCallback write_failed_callback) {
write_callback_ = write_callback;
write_failed_callback_ = write_failed_callback;
write_failed_callback_ = std::move(write_failed_callback);
DoWrite();
}
......@@ -92,8 +92,8 @@ void BufferedSocketWriter::DoWrite() {
!queue_.empty()) {
int result = write_callback_.Run(
queue_.front()->data.get(), queue_.front()->data->BytesRemaining(),
base::Bind(&BufferedSocketWriter::OnWritten,
weak_factory_.GetWeakPtr()),
base::BindOnce(&BufferedSocketWriter::OnWritten,
weak_factory_.GetWeakPtr()),
queue_.front()->traffic_annotation);
HandleWriteResult(result);
}
......
......@@ -25,17 +25,17 @@ namespace remoting {
// BufferedSocketWriter implement write data queue for stream sockets.
class BufferedSocketWriter {
public:
typedef base::Callback<int(
typedef base::RepeatingCallback<int(
const scoped_refptr<net::IOBuffer>& buf,
int buf_len,
net::CompletionOnceCallback callback,
const net::NetworkTrafficAnnotationTag& traffic_annotation)>
WriteCallback;
typedef base::Callback<void(int)> WriteFailedCallback;
typedef base::OnceCallback<void(int)> WriteFailedCallback;
static std::unique_ptr<BufferedSocketWriter> CreateForSocket(
net::Socket* socket,
const WriteFailedCallback& write_failed_callback);
WriteFailedCallback write_failed_callback);
BufferedSocketWriter();
virtual ~BufferedSocketWriter();
......@@ -44,7 +44,7 @@ class BufferedSocketWriter {
// socket. |write_failed_callback| is called when write operation fails.
// Writing stops after the first failed write.
void Start(const WriteCallback& write_callback,
const WriteFailedCallback& write_failed_callback);
WriteFailedCallback write_failed_callback);
// Puts a new data chunk in the buffer. If called before Start() then all data
// is buffered until Start().
......
......@@ -117,9 +117,9 @@ class BufferedSocketWriterTest : public testing::Test {
}
void StartWriter() {
writer_->Start(base::Bind(&WriteNetSocket, socket_.get()),
base::Bind(&BufferedSocketWriterTest::OnWriteFailed,
base::Unretained(this)));
writer_->Start(base::BindRepeating(&WriteNetSocket, socket_.get()),
base::BindOnce(&BufferedSocketWriterTest::OnWriteFailed,
base::Unretained(this)));
}
void OnWriteFailed(int error) {
......@@ -140,8 +140,9 @@ class BufferedSocketWriterTest : public testing::Test {
}
void TestWrite() {
writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_, base::Closure(),
writer_->Write(test_buffer_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
base::RunLoop().RunUntilIdle();
VerifyWrittenData();
......@@ -152,7 +153,7 @@ class BufferedSocketWriterTest : public testing::Test {
test_buffer_,
base::BindOnce(base::IgnoreResult(&BufferedSocketWriter::Write),
base::Unretained(writer_.get()), test_buffer_2_,
base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS),
base::OnceClosure(), TRAFFIC_ANNOTATION_FOR_TESTS),
TRAFFIC_ANNOTATION_FOR_TESTS);
base::RunLoop().RunUntilIdle();
VerifyWrittenData();
......@@ -207,13 +208,13 @@ TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
StartWriter();
socket_data_provider_.set_async_write(true);
writer_->Write(test_buffer_,
base::Bind(&BufferedSocketWriterTest::DestroyWriter,
base::Unretained(this)),
base::BindOnce(&BufferedSocketWriterTest::DestroyWriter,
base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_,
base::BindOnce(&BufferedSocketWriterTest::Unexpected,
base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(
test_buffer_2_,
base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
socket_data_provider_.set_async_write(false);
base::RunLoop().RunUntilIdle();
ASSERT_GE(socket_data_provider_.written_data().size(),
......@@ -227,13 +228,14 @@ TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
StartWriter();
socket_data_provider_.set_write_limit(kWriteChunkSize);
writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
socket_data_provider_.set_async_write(true);
socket_data_provider_.set_next_write_error(net::ERR_FAILED);
writer_->Write(
test_buffer_2_,
base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_,
base::BindOnce(&BufferedSocketWriterTest::Unexpected,
base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
socket_data_provider_.set_async_write(false);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(net::ERR_FAILED, write_error_);
......@@ -245,13 +247,14 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
StartWriter();
socket_data_provider_.set_write_limit(kWriteChunkSize);
writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
socket_data_provider_.set_async_write(true);
socket_data_provider_.set_next_write_error(net::ERR_FAILED);
writer_->Write(
test_buffer_2_,
base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_,
base::BindOnce(&BufferedSocketWriterTest::Unexpected,
base::Unretained(this)),
TRAFFIC_ANNOTATION_FOR_TESTS);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(net::ERR_FAILED, write_error_);
EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
......@@ -259,8 +262,10 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
}
TEST_F(BufferedSocketWriterTest, WriteBeforeStart) {
writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
writer_->Write(test_buffer_2_, base::OnceClosure(),
TRAFFIC_ANNOTATION_FOR_TESTS);
StartWriter();
base::RunLoop().RunUntilIdle();
......
......@@ -49,11 +49,11 @@ void ChromiumUrlRequest::SetPostData(const std::string& content_type,
post_data_ = data;
}
void ChromiumUrlRequest::Start(const OnResultCallback& on_result_callback) {
void ChromiumUrlRequest::Start(OnResultCallback on_result_callback) {
DCHECK(!on_result_callback.is_null());
DCHECK(on_result_callback_.is_null());
on_result_callback_ = on_result_callback;
on_result_callback_ = std::move(on_result_callback);
std::string method = resource_request_->method;
......
......@@ -34,7 +34,7 @@ class ChromiumUrlRequest : public UrlRequest {
void AddHeader(const std::string& value) override;
void SetPostData(const std::string& content_type,
const std::string& data) override;
void Start(const OnResultCallback& on_result_callback) override;
void Start(OnResultCallback on_result_callback) override;
private:
void OnURLLoadComplete(std::unique_ptr<std::string> response_body);
......
......@@ -86,8 +86,9 @@ class CompoundBufferTest : public testing::Test {
// Iterate over chunks of data with sizes specified in |sizes| in the
// interval [0..kDataSize]. |function| is called for each chunk.
void IterateOverPieces(const int sizes[],
const base::Callback<void(int, int)>& function) {
void IterateOverPieces(
const int sizes[],
const base::RepeatingCallback<void(int, int)>& function) {
DCHECK_GT(sizes[0], 0);
int pos = 0;
......@@ -183,81 +184,96 @@ class CompoundBufferTest : public testing::Test {
TEST_F(CompoundBufferTest, Append) {
target_.Clear();
IterateOverPieces(kChunkSizes0, base::Bind(
&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(
kChunkSizes0,
base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(
kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
}
TEST_F(CompoundBufferTest, AppendCopyOf) {
target_.Clear();
IterateOverPieces(kChunkSizes0, base::Bind(
&CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
IterateOverPieces(kChunkSizes0,
base::BindRepeating(&CompoundBufferTest::AppendCopyOf,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
IterateOverPieces(kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::AppendCopyOf,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
}
TEST_F(CompoundBufferTest, Prepend) {
target_.Clear();
IterateOverPieces(kChunkSizes0, base::Bind(
&CompoundBufferTest::Prepend, base::Unretained(this)));
IterateOverPieces(kChunkSizes0,
base::BindRepeating(&CompoundBufferTest::Prepend,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::Prepend, base::Unretained(this)));
IterateOverPieces(kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::Prepend,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
}
TEST_F(CompoundBufferTest, PrependCopyOf) {
target_.Clear();
IterateOverPieces(kChunkSizes0, base::Bind(
&CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
IterateOverPieces(kChunkSizes0,
base::BindRepeating(&CompoundBufferTest::PrependCopyOf,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
IterateOverPieces(kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::PrependCopyOf,
base::Unretained(this)));
EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
}
TEST_F(CompoundBufferTest, CropFront) {
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(kCropSizes, base::Bind(
&CompoundBufferTest::TestCropFront, base::Unretained(this)));
IterateOverPieces(
kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(kCropSizes,
base::BindRepeating(&CompoundBufferTest::TestCropFront,
base::Unretained(this)));
}
TEST_F(CompoundBufferTest, CropBack) {
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(kCropSizes, base::Bind(
&CompoundBufferTest::TestCropBack, base::Unretained(this)));
IterateOverPieces(
kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(kCropSizes,
base::BindRepeating(&CompoundBufferTest::TestCropBack,
base::Unretained(this)));
}
TEST_F(CompoundBufferTest, CopyFrom) {
target_.Clear();
IterateOverPieces(kChunkSizes1, base::Bind(
&CompoundBufferTest::Append, base::Unretained(this)));
IterateOverPieces(
kChunkSizes1,
base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
{
SCOPED_TRACE("CopyFrom.kCopySizes0");
IterateOverPieces(kCopySizes0, base::Bind(
&CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
IterateOverPieces(kCopySizes0,
base::BindRepeating(&CompoundBufferTest::TestCopyFrom,
base::Unretained(this)));
}
{
SCOPED_TRACE("CopyFrom.kCopySizes1");
IterateOverPieces(kCopySizes1, base::Bind(
&CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
IterateOverPieces(kCopySizes1,
base::BindRepeating(&CompoundBufferTest::TestCopyFrom,
base::Unretained(this)));
}
}
......
......@@ -5,7 +5,7 @@ $$
$$ https://github.com/google/googletest/blob/master/googletest/docs/PumpManual.md
$$ MAX_ARITY controls the number of arguments that dispatch::Invoke() supports.
$$ It is choosen to match the number of arguments base::Bind() supports.
$$ It is choosen to match the number of arguments base::BindOnce() supports.
$var MAX_ARITY = 7
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
......
......@@ -25,14 +25,14 @@ void GaiaOAuthClient::GetCredentialsFromAuthCode(
const std::string& auth_code,
bool need_user_email,
CompletionCallback on_done) {
if (!on_done_.is_null()) {
pending_requests_.push(
Request(oauth_client_info, auth_code, need_user_email, on_done));
if (on_done_) {
pending_requests_.push(Request(oauth_client_info, auth_code,
need_user_email, std::move(on_done)));
return;
}
need_user_email_ = need_user_email;
on_done_ = on_done;
on_done_ = std::move(on_done);
// Map the authorization code to refresh and access tokens.
gaia_oauth_client_.GetTokensFromAuthCode(oauth_client_info, auth_code,
kMaxGaiaRetries, this);
......@@ -62,11 +62,12 @@ void GaiaOAuthClient::SendResponse(const std::string& user_email,
// Process the next request in the queue.
if (pending_requests_.size()) {
Request request = pending_requests_.front();
Request request = std::move(pending_requests_.front());
pending_requests_.pop();
// GetCredentialsFromAuthCode is asynchronous, so it's safe to call it here.
GetCredentialsFromAuthCode(request.oauth_client_info, request.auth_code,
request.need_user_email, request.on_done);
request.need_user_email,
std::move(request.on_done));
}
}
......@@ -90,10 +91,13 @@ GaiaOAuthClient::Request::Request(
this->oauth_client_info = oauth_client_info;
this->auth_code = auth_code;
this->need_user_email = need_user_email;
this->on_done = on_done;
this->on_done = std::move(on_done);
}
GaiaOAuthClient::Request::Request(const Request& other) = default;
GaiaOAuthClient::Request::Request(Request&& other) = default;
GaiaOAuthClient::Request& GaiaOAuthClient::Request::operator=(Request&& other) =
default;
GaiaOAuthClient::Request::~Request() = default;
......
......@@ -55,7 +55,8 @@ class GaiaOAuthClient : public OAuthClient,
const std::string& auth_code,
bool need_user_email,
CompletionCallback on_done);
Request(const Request& other);
Request(Request&& other);
Request& operator=(Request&& other);
virtual ~Request();
gaia::OAuthClientInfo oauth_client_info;
std::string auth_code;
......
......@@ -17,7 +17,7 @@ void MockOAuthClient::GetCredentialsFromAuthCode(
const std::string& auth_code,
bool need_user_email,
CompletionCallback on_done) {
on_done.Run(need_user_email ? user_email_ : "", refresh_token_);
std::move(on_done).Run(need_user_email ? user_email_ : "", refresh_token_);
}
} // namespace remoting
......@@ -20,8 +20,8 @@ class OAuthClient {
// Called when GetCredentialsFromAuthCode is completed, with the |user_email|
// and |refresh_token| that correspond to the given |auth_code|, or with empty
// strings on error.
typedef base::Callback<void(const std::string& user_email,
const std::string& refresh_token)>
typedef base::OnceCallback<void(const std::string& user_email,
const std::string& refresh_token)>
CompletionCallback;
virtual ~OAuthClient() {}
......
......@@ -23,6 +23,6 @@ int main(int argc, char** argv) {
mojo::core::ScopedIPCSupport::ShutdownPolicy::CLEAN);
return base::LaunchUnitTests(
argc, argv, base::Bind(&base::TestSuite::Run,
base::Unretained(&test_suite)));
argc, argv,
base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
}
......@@ -29,7 +29,7 @@ void SocketReader::Init(net::Socket* socket,
DCHECK(!socket_);
socket_ = socket;
read_result_callback_ = read_result_callback;
read_result_callback_ = std::move(read_result_callback);
DoRead();
}
......@@ -37,9 +37,8 @@ void SocketReader::DoRead() {
while (true) {
read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
int result = socket_->Read(
read_buffer_.get(),
kReadBufferSize,
base::Bind(&SocketReader::OnRead, weak_factory_.GetWeakPtr()));
read_buffer_.get(), kReadBufferSize,
base::BindOnce(&SocketReader::OnRead, weak_factory_.GetWeakPtr()));
HandleReadResult(result);
if (result <= 0)
break;
......@@ -64,7 +63,7 @@ void SocketReader::HandleReadResult(int result) {
}
void SocketReader::CallCallback(scoped_refptr<net::IOBuffer> data, int result) {
read_result_callback_.Run(data, result);
std::move(read_result_callback_).Run(data, result);
}
} // namespace remoting
......@@ -25,8 +25,9 @@ class SocketReader {
public:
// Callback that is called for each finished read. |data| may be set to NULL
// in case of an error (result < 0).
typedef base::Callback<void(scoped_refptr<net::IOBuffer> data,
int result)> ReadResultCallback;
typedef base::OnceCallback<void(scoped_refptr<net::IOBuffer> data,
int result)>
ReadResultCallback;
SocketReader();
~SocketReader();
......
......@@ -70,11 +70,11 @@ class FakeUrlRequestFactory : public UrlRequestFactory {
~FakeUrlRequestFactory() override { EXPECT_TRUE(expected_requests_.empty()); }
// Returns a respond closure. Run this closure to respond to the URL request.
base::Closure AddExpectedRequest(const std::string& exp_post,
const UrlRequest::Result& ret_result) {
base::OnceClosure AddExpectedRequest(const std::string& exp_post,
const UrlRequest::Result& ret_result) {
FakeUrlRequest* fakeRequest = new FakeUrlRequest(exp_post, ret_result);
base::Closure closure =
base::Bind(&FakeUrlRequest::Respond, base::Unretained(fakeRequest));
base::OnceClosure closure =
base::BindOnce(&FakeUrlRequest::Respond, base::Unretained(fakeRequest));
expected_requests_.push_back(std::unique_ptr<UrlRequest>(fakeRequest));
return closure;
}
......@@ -148,7 +148,7 @@ TEST_F(TelemetryLogWriterTest, PostOneLogImmediately) {
auto respond = request_factory_->AddExpectedRequest(
"{\"event\":[{\"id\":0}]}", success_result_);
LogFakeEvent();
respond.Run();
std::move(respond).Run();
}
TEST_F(TelemetryLogWriterTest, PostOneLogAndHaveTwoPendingLogs) {
......@@ -160,8 +160,8 @@ TEST_F(TelemetryLogWriterTest, PostOneLogAndHaveTwoPendingLogs) {
"{\"event\":[{\"id\":1},{\"id\":2}]}", success_result_);
LogFakeEvent();
LogFakeEvent();
respond1.Run();
respond2.Run();
std::move(respond1).Run();
std::move(respond2).Run();
}
TEST_F(TelemetryLogWriterTest, PostLogFailedAndRetry) {
......@@ -179,11 +179,11 @@ TEST_F(TelemetryLogWriterTest, PostLogFailedAndRetry) {
LogFakeEvent();
respond1.Run();
respond2.Run();
respond3.Run();
respond4.Run();
respond5.Run();
std::move(respond1).Run();
std::move(respond2).Run();
std::move(respond3).Run();
std::move(respond4).Run();
std::move(respond5).Run();
}
TEST_F(TelemetryLogWriterTest, PostOneLogFailedResendWithTwoPendingLogs) {
......@@ -196,8 +196,8 @@ TEST_F(TelemetryLogWriterTest, PostOneLogFailedResendWithTwoPendingLogs) {
LogFakeEvent();
LogFakeEvent();
respond1.Run();
respond2.Run();
std::move(respond1).Run();
std::move(respond2).Run();
}
TEST_F(TelemetryLogWriterTest, PostThreeLogsFailedAndResendWithOnePending) {
......@@ -212,15 +212,15 @@ TEST_F(TelemetryLogWriterTest, PostThreeLogsFailedAndResendWithOnePending) {
LogFakeEvent();
LogFakeEvent();
respond1.Run();
std::move(respond1).Run();
auto respond3 = request_factory_->AddExpectedRequest(
"{\"event\":[{\"id\":0},{\"id\":1},{\"id\":2},{\"id\":3}]}",
success_result_);
LogFakeEvent();
respond2.Run();
respond3.Run();
std::move(respond2).Run();
std::move(respond3).Run();
}
TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedCallClosureAndRetry) {
......@@ -230,8 +230,8 @@ TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedCallClosureAndRetry) {
auto respond2 = request_factory_->AddExpectedRequest(
"{\"event\":[{\"id\":0}]}", success_result_);
respond1.Run();
respond2.Run();
std::move(respond1).Run();
std::move(respond2).Run();
}
} // namespace remoting
......@@ -40,7 +40,7 @@ class UrlRequest {
std::string response_body;
};
typedef base::Callback<void(const Result& result)> OnResultCallback;
typedef base::OnceCallback<void(const Result& result)> OnResultCallback;
virtual ~UrlRequest() {}
......@@ -53,7 +53,7 @@ class UrlRequest {
// Sends a request to the server. |on_response_callback| will be called to
// return result of the request.
virtual void Start(const OnResultCallback& on_result_callback) = 0;
virtual void Start(OnResultCallback on_result_callback) = 0;
};
// Factory for UrlRequest instances.
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment