Allow customization of HttpPostProviderFactory via ProfileSyncService

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"
@@ skipping 41 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 NetworkTimeUpdateCallback& network_time_update_callback,
-    CancelationSignal* cancelation_signal)
+    const NetworkTimeUpdateCallback& network_time_update_callback)
     : 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);
+      cancelation_signal_(NULL) {
 }
 
 HttpBridgeFactory::~HttpBridgeFactory() {
-  cancelation_signal_->UnregisterHandler(this);
+  if (cancelation_signal_ != NULL)
+    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 finished initializing.  There's no
     // point in initializating further; let's just return right away.
     return;
   }
 
   request_context_getter_ =
       new HttpBridge::RequestContextGetter(
           baseline_request_context_getter_, user_agent);
 }
 
+void HttpBridgeFactory::RegisterCancelationSignal(
+    CancelationSignal* cancelation_signal) {
+  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);
+}
+
 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(),
@@ skipping 281 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