Convert chromeos/timezone to base::Bind and base::Callback to Once/Repeating

Bug: 1007664
Change-Id: I975e8b03330961acc2b7f9dd6b96406e6bdd0ec5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1922734
Auto-Submit: Reilly Grant <reillyg@chromium.org>
Commit-Queue: Alexander Alekseev <alemate@chromium.org>
Reviewed-by: Alexander Alekseev <alemate@chromium.org>
Cr-Commit-Position: refs/heads/master@{#718366}

chromeos/timezone/timezone_provider.cc

@@ -35,12 +35,10 @@ void TimeZoneProvider::RequestTimezone(
 
   // TimeZoneProvider owns all requests. It is safe to pass unretained "this"
   // because destruction of TimeZoneProvider cancels all requests.
-  TimeZoneRequest::TimeZoneResponseCallback callback_tmp(
-      base::Bind(&TimeZoneProvider::OnTimezoneResponse,
-                 base::Unretained(this),
-                 request,
-                 callback));
-  request->MakeRequest(callback_tmp);
+  TimeZoneRequest::TimeZoneResponseCallback callback_tmp =
+      base::BindOnce(&TimeZoneProvider::OnTimezoneResponse,
+                     base::Unretained(this), request, std::move(callback));
+  request->MakeRequest(std::move(callback_tmp));
 }
 
 void TimeZoneProvider::OnTimezoneResponse(
@@ -59,7 +57,7 @@ void TimeZoneProvider::OnTimezoneResponse(
     requests_.resize(requests_.size() - 1);
   }
 
-  callback.Run(std::move(timezone), server_error);
+  std::move(callback).Run(std::move(timezone), server_error);
 }
 
 }  // namespace chromeos

chromeos/timezone/timezone_request.cc

@@ -355,7 +355,7 @@ void TimeZoneRequest::StartRequest() {
 }
 
 void TimeZoneRequest::MakeRequest(TimeZoneResponseCallback callback) {
-  callback_ = callback;
+  callback_ = std::move(callback);
   request_url_ =
       TimeZoneRequestURL(service_url_, geoposition_, false /* sensor */);
   StartRequest();
@@ -403,14 +403,14 @@ void TimeZoneRequest::OnSimpleLoaderComplete(
                                : TIMEZONE_REQUEST_RESULT_FAILURE));
   RecordUmaResult(result, retries_);
 
-  TimeZoneResponseCallback callback = callback_;
+  TimeZoneResponseCallback callback = std::move(callback_);
 
   // Empty callback is used to identify "completed or not yet started request".
   callback_.Reset();
 
   // callback.Run() usually destroys TimeZoneRequest, because this is the way
   // callback is implemented in TimeZoneProvider.
-  callback.Run(std::move(timezone), server_error);
+  std::move(callback).Run(std::move(timezone), server_error);
   // "this" is already destroyed here.
 }
 

chromeos/timezone/timezone_request.h

@@ -63,10 +63,9 @@ class COMPONENT_EXPORT(CHROMEOS_TIMEZONE) TimeZoneRequest {
   // The second argument indicates whether there was a server error or not.
   // It is true when there was a server or network error - either no response
   // or a 500 error code.
-  typedef base::Callback<void(
-      std::unique_ptr<TimeZoneResponseData> /* timezone */,
-      bool /* server_error */)>
-      TimeZoneResponseCallback;
+  using TimeZoneResponseCallback =
+      base::OnceCallback<void(std::unique_ptr<TimeZoneResponseData> timezone,
+                              bool server_error)>;
 
   // |url| is the server address to which the request wil be sent.
   // |geoposition| is the location to query timezone for.

chromeos/timezone/timezone_resolver.cc

@@ -192,13 +192,13 @@ void TZRequest::StartRequestOnNetworkAvailable() {
       base::TimeDelta::FromSeconds(kRefreshTimeZoneTimeoutSeconds),
       resolver_->ShouldSendWiFiGeolocationData(),
       resolver_->ShouldSendCellularGeolocationData(),
-      base::Bind(&TZRequest::OnLocationResolved, AsWeakPtr()));
+      base::BindOnce(&TZRequest::OnLocationResolved, AsWeakPtr()));
 }
 
 void TZRequest::Start() {
   // call to chromeos::DelayNetworkCall
   resolver_->delay_network_call().Run(
-      base::Bind(&TZRequest::StartRequestOnNetworkAvailable, AsWeakPtr()));
+      base::BindOnce(&TZRequest::StartRequestOnNetworkAvailable, AsWeakPtr()));
 }
 
 void TZRequest::OnLocationResolved(const Geoposition& position,
@@ -222,9 +222,8 @@ void TZRequest::OnLocationResolved(const Geoposition& position,
   }
 
   resolver_->timezone_provider()->RequestTimezone(
-      position,
-      timeout - elapsed,
-      base::Bind(&TZRequest::OnTimezoneResolved, AsWeakPtr()));
+      position, timeout - elapsed,
+      base::BindOnce(&TZRequest::OnTimezoneResolved, AsWeakPtr()));
 
   // Prevent |on_request_finished| from firing here.
   base::OnceClosure unused = on_request_finished.Release();
@@ -341,8 +340,8 @@ void TimeZoneResolver::TimeZoneResolverImpl::ScheduleRequest() {
   refresh_timer_.Stop();
   refresh_timer_.Start(
       FROM_HERE, interval,
-      base::Bind(&TimeZoneResolver::TimeZoneResolverImpl::CreateNewRequest,
-                 AsWeakPtr()));
+      base::BindOnce(&TimeZoneResolver::TimeZoneResolverImpl::CreateNewRequest,
+                     AsWeakPtr()));
 }
 
 void TimeZoneResolver::TimeZoneResolverImpl::CreateNewRequest() {

chromeos/timezone/timezone_resolver.h

@@ -31,7 +31,7 @@ class COMPONENT_EXPORT(CHROMEOS_TIMEZONE) TimeZoneResolver {
 
   // This callback will be called when new timezone arrives.
   using ApplyTimeZoneCallback =
-      base::Callback<void(const TimeZoneResponseData*)>;
+      base::RepeatingCallback<void(const TimeZoneResponseData*)>;
 
   // chromeos::DelayNetworkCall cannot be used directly due to link
   // restrictions.

chromeos/timezone/timezone_unittest.cc

@@ -178,8 +178,8 @@ TEST_F(TimeZoneTest, ResponseOK) {
 
   provider.RequestTimezone(simple_request.position,
                            base::TimeDelta::FromSeconds(1),
-                           base::Bind(&TimeZoneReceiver::OnRequestDone,
-                                      base::Unretained(&receiver)));
+                           base::BindOnce(&TimeZoneReceiver::OnRequestDone,
+                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
 
   EXPECT_EQ(simple_request.timezone.ToStringForDebug(),
@@ -203,8 +203,8 @@ TEST_F(TimeZoneTest, ResponseOKWithRetries) {
 
   provider.RequestTimezone(simple_request.position,
                            base::TimeDelta::FromSeconds(1),
-                           base::Bind(&TimeZoneReceiver::OnRequestDone,
-                                      base::Unretained(&receiver)));
+                           base::BindOnce(&TimeZoneReceiver::OnRequestDone,
+                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
   EXPECT_EQ(simple_request.timezone.ToStringForDebug(),
             receiver.timezone()->ToStringForDebug());
@@ -232,8 +232,8 @@ TEST_F(TimeZoneTest, InvalidResponse) {
 
   provider.RequestTimezone(simple_request.position,
                            base::TimeDelta::FromSeconds(timeout_seconds),
-                           base::Bind(&TimeZoneReceiver::OnRequestDone,
-                                      base::Unretained(&receiver)));
+                           base::BindOnce(&TimeZoneReceiver::OnRequestDone,
+                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
   EXPECT_EQ(
       "dstOffset=0.000000, rawOffset=0.000000, timeZoneId='', timeZoneName='', "