Reporting of policy errors via host-offline-reason: part 2b

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/message_loop/message_loop_proxy.h"
@@ skipping 32 matching lines @@
 const char kExpectedSequenceIdTag[] = "expected-sequence-id";
 
 const int64 kDefaultHeartbeatIntervalMs = 5 * 60 * 1000;  // 5 minutes.
 const int64 kResendDelayMs = 10 * 1000;  // 10 seconds.
 const int64 kResendDelayOnHostNotFoundMs = 10 * 1000; // 10 seconds.
 const int kMaxResendOnHostNotFoundCount = 12;  // 2 minutes (12 x 10 seconds).
 
 }  // namespace
 
 HeartbeatSender::HeartbeatSender(
-    Listener* listener,
+    const base::Closure& on_heartbeat_successful_callback,
+    const base::Closure& on_unknown_host_id_error,
     const std::string& host_id,
     SignalStrategy* signal_strategy,
     scoped_refptr<RsaKeyPair> key_pair,
     const std::string& directory_bot_jid)
-    : listener_(listener),
+    : on_heartbeat_successful_callback_(on_heartbeat_successful_callback),
+      on_unknown_host_id_error_(on_unknown_host_id_error),
       host_id_(host_id),
       signal_strategy_(signal_strategy),
       key_pair_(key_pair),
       directory_bot_jid_(directory_bot_jid),
       interval_ms_(kDefaultHeartbeatIntervalMs),
       sequence_id_(0),
       sequence_id_was_set_(false),
       sequence_id_recent_set_num_(0),
       heartbeat_succeeded_(false),
       failed_startup_heartbeat_count_(0) {
@@ skipping 91 matching lines @@
         failed_startup_heartbeat_count_++;
         if (!heartbeat_succeeded_ && (failed_startup_heartbeat_count_ <=
                 kMaxResendOnHostNotFoundCount)) {
           timer_resend_.Start(FROM_HERE,
                               base::TimeDelta::FromMilliseconds(
                                   kResendDelayOnHostNotFoundMs),
                               this,
                               &HeartbeatSender::ResendStanza);
           return;
         }
-        listener_->OnUnknownHostIdError();
+        on_unknown_host_id_error_.Run();
         return;
       }
     }
 
     LOG(ERROR) << "Received error in response to heartbeat: "
                << response->Str();
     return;
   }
 
   // This method must only be called for error or result stanzas.
@@ skipping 34 matching lines @@
         sequence_id_recent_set_num_++;
         did_set_sequence_id = true;
       }
     }
     if (!did_set_sequence_id) {
       // It seems the bot accepted our signature and our message.
       sequence_id_recent_set_num_ = 0;
 
       // Notify listener of the first successful heartbeat.
       if (!heartbeat_succeeded_) {
-        listener_->OnHeartbeatSuccessful();
+        on_heartbeat_successful_callback_.Run();
       }
       heartbeat_succeeded_ = true;
 
       // Notify caller of SetHostOfflineReason that we got an ack.
       if (is_offline_heartbeat_response) {
         if (!host_offline_reason_ack_callback_.is_null()) {
           base::MessageLoop::current()->PostTask(
               FROM_HERE,
               host_offline_reason_ack_callback_);
           host_offline_reason_ack_callback_.Reset();
@@ skipping 72 matching lines @@
 
   std::string message = signal_strategy_->GetLocalJid() + ' ' +
       base::IntToString(sequence_id_);
   std::string signature(key_pair_->SignMessage(message));
   signature_tag->AddText(signature);
 
   return signature_tag.Pass();
 }
 
 }  // namespace remoting