Chromoting: stopping the service if the host ID is permanently not recognized by the could.

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/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "remoting/base/constants.h"
+#include "remoting/host/constants.h"
 #include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 #include "third_party/libjingle/source/talk/xmpp/constants.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
@@ skipping 10 matching lines @@
 
 const char kHeartbeatResultTag[] = "heartbeat-result";
 const char kSetIntervalTag[] = "set-interval";
 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).
 
-const int kExitCodeHostIdInvalid = 100;
-
 }  // namespace
 
 HeartbeatSender::HeartbeatSender(
+    Delegate* delegate,
     const std::string& host_id,
     SignalStrategy* signal_strategy,
     HostKeyPair* key_pair)
-    : host_id_(host_id),
+    : delegate_(delegate),
+      host_id_(host_id),
       signal_strategy_(signal_strategy),
       key_pair_(key_pair),
       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) {
   DCHECK(signal_strategy_);
   DCHECK(key_pair_);
@@ skipping 62 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;
         }
-        // TODO(lambroslambrou): Trigger an application-defined callback to
-        // shut down the host properly, instead of just exiting here
-        // (http://crbug.com/112160).
-        LOG(ERROR) << "Exit: Host ID not found";
-        exit(kExitCodeHostIdInvalid);
+        delegate_->OnUnknownHostIdError();
+        return;
       }
     }
 
     LOG(ERROR) << "Received error in response to heartbeat: "
                << response->Str();
     return;
   }
 
   heartbeat_succeeded_ = true;
 
@@ skipping 94 matching lines @@
 
   std::string message = signal_strategy_->GetLocalJid() + ' ' +
       base::IntToString(sequence_id_);
   std::string signature(key_pair_->GetSignature(message));
   signature_tag->AddText(signature);
 
   return signature_tag.Pass();
 }
 
 }  // namespace remoting