Retry: sync: Gracefully handle early shutdown

sync/engine/net/server_connection_manager.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 "sync/engine/net/server_connection_manager.h"
 
 #include <errno.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
 #include "sync/engine/net/url_translator.h"
 #include "sync/engine/syncer.h"
+#include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "url/gurl.h"
 
 namespace syncer {
 
 using std::ostream;
 using std::string;
 using std::vector;
 
@@ skipping 141 matching lines @@
 }
 
 ScopedServerStatusWatcher::~ScopedServerStatusWatcher() {
   conn_mgr_->SetServerStatus(response_->server_status);
 }
 
 ServerConnectionManager::ServerConnectionManager(
     const string& server,
     int port,
     bool use_ssl,
-    bool use_oauth2_token)
+    bool use_oauth2_token,
+    CancelationSignal* cancelation_signal)
     : sync_server_(server),
       sync_server_port_(port),
       use_ssl_(use_ssl),
       use_oauth2_token_(use_oauth2_token),
       proto_sync_path_(kSyncServerSyncPath),
       server_status_(HttpResponse::NONE),
       terminated_(false),
-      active_connection_(NULL) {
+      active_connection_(NULL),
+      cancelation_signal_(cancelation_signal),
+      signal_handler_registered_(false) {
+  signal_handler_registered_ = cancelation_signal_->TryRegisterHandler(this);
+  if (!signal_handler_registered_) {
+    // Calling a virtual function from a constructor.  We can get away with it
+    // here because ServerConnectionManager::OnSignalReceived() is the function
+    // we want to call.
+    OnSignalReceived();
+  }
 }
 
 ServerConnectionManager::~ServerConnectionManager() {
+  if (signal_handler_registered_) {
+    cancelation_signal_->UnregisterHandler(this);
+  }
 }
 
 ServerConnectionManager::Connection*
 ServerConnectionManager::MakeActiveConnection() {
   base::AutoLock lock(terminate_connection_lock_);
   DCHECK(!active_connection_);
   if (terminated_)
     return NULL;
 
   active_connection_ = MakeConnection();
@@ skipping 139 matching lines @@
     ServerConnectionEventListener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.RemoveObserver(listener);
 }
 
 ServerConnectionManager::Connection* ServerConnectionManager::MakeConnection()
 {
   return NULL;  // For testing.
 }
 
-void ServerConnectionManager::TerminateAllIO() {
+void ServerConnectionManager::OnSignalReceived() {
   base::AutoLock lock(terminate_connection_lock_);
   terminated_ = true;
   if (active_connection_)
     active_connection_->Abort();
 
   // Sever our ties to this connection object. Note that it still may exist,
   // since we don't own it, but it has been neutered.
   active_connection_ = NULL;
 }
 
 std::ostream& operator << (std::ostream& s, const struct HttpResponse& hr) {
   s << " Response Code (bogus on error): " << hr.response_code;
   s << " Content-Length (bogus on error): " << hr.content_length;
   s << " Server Status: "
     << HttpResponse::GetServerConnectionCodeString(hr.server_status);
   return s;
 }
 
 }  // namespace syncer