Retry: sync: Gracefully handle early shutdown

sync/internal_api/http_bridge.cc

 // Copyright 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/internal_api/public/http_bridge.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
+#include "sync/internal_api/public/base/cancelation_signal.h"
 
 namespace syncer {
 
 HttpBridge::RequestContextGetter::RequestContextGetter(
     net::URLRequestContextGetter* baseline_context_getter,
     const std::string& user_agent)
     : baseline_context_getter_(baseline_context_getter),
       network_task_runner_(
           baseline_context_getter_->GetNetworkTaskRunner()),
       user_agent_(user_agent) {
@@ skipping 19 matching lines @@
   return context_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 HttpBridge::RequestContextGetter::GetNetworkTaskRunner() const {
   return network_task_runner_;
 }
 
 HttpBridgeFactory::HttpBridgeFactory(
     net::URLRequestContextGetter* baseline_context_getter,
-    const std::string& user_agent,
-    const NetworkTimeUpdateCallback& network_time_update_callback)
-    : request_context_getter_(
-        new HttpBridge::RequestContextGetter(
-            baseline_context_getter, user_agent)),
-      network_time_update_callback_(network_time_update_callback) {
+    const NetworkTimeUpdateCallback& network_time_update_callback,
+    CancelationSignal* cancelation_signal)
+    : baseline_request_context_getter_(baseline_context_getter),
+      network_time_update_callback_(network_time_update_callback),
+      cancelation_signal_(cancelation_signal) {
+  // Registration should never fail.  This should happen on the UI thread during
+  // init.  It would be impossible for a shutdown to have been requested at this
+  // point.
+  bool result = cancelation_signal_->TryRegisterHandler(this);
+  DCHECK(result);
 }
 
 HttpBridgeFactory::~HttpBridgeFactory() {
+  cancelation_signal_->UnregisterHandler(this);
+}
+
+void HttpBridgeFactory::Init(const std::string& user_agent) {
+  base::AutoLock lock(context_getter_lock_);
+
+  if (!baseline_request_context_getter_.get()) {
+    // Uh oh.  We've been aborted before we finsihed initializing.
+    // There's no point in initializating further; let's just return
+    // right away.
+  }
+
+  request_context_getter_ =
+      new HttpBridge::RequestContextGetter(
+          baseline_request_context_getter_, user_agent);
 }
 
 HttpPostProviderInterface* HttpBridgeFactory::Create() {
   base::AutoLock lock(context_getter_lock_);
+
+  // If we've been asked to shut down (something which may happen asynchronously
+  // and at pretty much any time), then we won't have a request_context_getter_.
+  // Some external mechanism must ensure that this function is not called after
+  // we've been asked to shut down.
   CHECK(request_context_getter_.get());
+
   HttpBridge* http = new HttpBridge(request_context_getter_.get(),
                                     network_time_update_callback_);
   http->AddRef();
   return http;
 }
 
 void HttpBridgeFactory::Destroy(HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
-void HttpBridgeFactory::Shutdown() {
+void HttpBridgeFactory::OnSignalReceived() {
   base::AutoLock lock(context_getter_lock_);
-  // Release |request_context_getter_| as soon as possible so that it is
-  // destroyed in the right order on its network task runner.
+  // Release |baseline_request_context_getter_| as soon as possible so that it
+  // is destroyed in the right order on its network task runner.  The
+  // |request_context_getter_| has a reference to the baseline, so we must
+  // drop our reference to it, too.
+  baseline_request_context_getter_ = NULL;
   request_context_getter_ = NULL;
 }
 
 HttpBridge::RequestContext::RequestContext(
     net::URLRequestContext* baseline_context,
     const scoped_refptr<base::SingleThreadTaskRunner>&
         network_task_runner,
     const std::string& user_agent)
     : baseline_context_(baseline_context),
       network_task_runner_(network_task_runner) {
@@ skipping 255 matching lines @@
   int64 sane_time_ms = 0;
   if (base::StringToInt64(sane_time_str, &sane_time_ms)) {
     network_time_update_callback_.Run(
         base::Time::FromJsTime(sane_time_ms),
         base::TimeDelta::FromMilliseconds(1),
         fetch_state_.end_time - fetch_state_.start_time);
   }
 }
 
 }  // namespace syncer