Use base::ResetAndReturn() in remoting.

remoting/host/heartbeat_sender.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/heartbeat_sender.h"
 
 #include <math.h>
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringize_macros.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/server_log_entry_host.h"
 #include "remoting/signaling/iq_sender.h"
 #include "remoting/signaling/server_log_entry.h"
@@ skipping 78 matching lines @@
 }
 
 bool HeartbeatSender::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
 void HeartbeatSender::OnHostOfflineReasonTimeout() {
   DCHECK(!host_offline_reason_ack_callback_.is_null());
 
-  base::Callback<void(bool)> local_callback = host_offline_reason_ack_callback_;
-  host_offline_reason_ack_callback_.Reset();
-  local_callback.Run(false);
+  base::ResetAndReturn(&host_offline_reason_ack_callback_).Run(false);
 }
 
 void HeartbeatSender::OnHostOfflineReasonAck() {
   if (host_offline_reason_ack_callback_.is_null()) {
     DCHECK(!host_offline_reason_timeout_timer_.IsRunning());
     return;
   }
 
   DCHECK(host_offline_reason_timeout_timer_.IsRunning());
   host_offline_reason_timeout_timer_.Stop();
 
   // Run the ACK callback under a clean stack via PostTask() (because the
   // callback can end up deleting |this| HeartbeatSender [i.e. when used from
   // HostSignalingManager]).
-  base::Closure fully_bound_ack_callback =
-      base::Bind(host_offline_reason_ack_callback_, true);
-  host_offline_reason_ack_callback_.Reset();
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                fully_bound_ack_callback);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(base::ResetAndReturn(&host_offline_reason_ack_callback_),
+                 true));
 }
 
 void HeartbeatSender::SetHostOfflineReason(
     const std::string& host_offline_reason,
     const base::TimeDelta& timeout,
     const base::Callback<void(bool success)>& ack_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(host_offline_reason_ack_callback_.is_null());
   host_offline_reason_ = host_offline_reason;
   host_offline_reason_ack_callback_ = ack_callback;
@@ skipping 195 matching lines @@
 
   std::string message = signal_strategy_->GetLocalJid() + ' ' +
       base::IntToString(sequence_id_);
   std::string signature(host_key_pair_->SignMessage(message));
   signature_tag->AddText(signature);
 
   return signature_tag.Pass();
 }
 
 }  // namespace remoting