sync: Implement disabling of non blocking types

sync/internal_api/non_blocking_type_processor.cc

Index: sync/internal_api/non_blocking_type_processor.cc
diff --git a/sync/internal_api/non_blocking_type_processor.cc b/sync/internal_api/non_blocking_type_processor.cc
index d426443a03c961d3824a18a4873e1b7c2ec66a93..870c2963619898ab1d8baa75d6517b8730050f14 100644
--- a/sync/internal_api/non_blocking_type_processor.cc
+++ b/sync/internal_api/non_blocking_type_processor.cc
@@ -11,10 +11,12 @@
 namespace syncer {
 
 NonBlockingTypeProcessor::NonBlockingTypeProcessor(ModelType type)
-  : type_(type),
-    is_preferred_(false),
-    is_connected_(false),
-    weak_ptr_factory_(this) {}
+    : type_(type),
+      is_preferred_(false),
+      is_connected_(false),
+      weak_ptr_factory_for_ui_(this),
+      weak_ptr_factory_for_sync_(this) {
+}
 
 NonBlockingTypeProcessor::~NonBlockingTypeProcessor() {
 }
@@ -34,10 +36,14 @@ ModelType NonBlockingTypeProcessor::GetModelType() const {
   return type_;
 }
 
-void NonBlockingTypeProcessor::Enable(SyncCoreProxy* core_proxy) {
+void NonBlockingTypeProcessor::Enable(
+    scoped_ptr<SyncCoreProxy> sync_core_proxy) {
   DCHECK(CalledOnValidThread());
+  DVLOG(1) << "Asked to enable " << ModelTypeToString(type_);
   is_preferred_ = true;
-  core_proxy->ConnectTypeToCore(GetModelType(), AsWeakPtr());
+  sync_core_proxy_ = sync_core_proxy.Pass();
+  sync_core_proxy_->ConnectTypeToCore(GetModelType(),
+                                      weak_ptr_factory_for_sync_.GetWeakPtr());
 }
 
 void NonBlockingTypeProcessor::Disable() {
@@ -48,20 +54,30 @@ void NonBlockingTypeProcessor::Disable() {
 
 void NonBlockingTypeProcessor::Disconnect() {
   DCHECK(CalledOnValidThread());
+  DVLOG(1) << "Asked to disconnect " << ModelTypeToString(type_);
   is_connected_ = false;
+
+  if (sync_core_proxy_) {
+    sync_core_proxy_->Disconnect(GetModelType());
+    sync_core_proxy_.reset();
+  }
+
+  weak_ptr_factory_for_sync_.InvalidateWeakPtrs();
   core_ = base::WeakPtr<NonBlockingTypeProcessorCore>();
   sync_thread_ = scoped_refptr<base::SequencedTaskRunner>();
 }
 
-base::WeakPtr<NonBlockingTypeProcessor> NonBlockingTypeProcessor::AsWeakPtr() {
+base::WeakPtr<NonBlockingTypeProcessor>
+NonBlockingTypeProcessor::AsWeakPtrForUI() {
   DCHECK(CalledOnValidThread());
-  return weak_ptr_factory_.GetWeakPtr();
+  return weak_ptr_factory_for_ui_.GetWeakPtr();
 }
 
 void NonBlockingTypeProcessor::OnConnect(
     base::WeakPtr<NonBlockingTypeProcessorCore> core,
     scoped_refptr<base::SequencedTaskRunner> sync_thread) {
   DCHECK(CalledOnValidThread());
+  DVLOG(1) << "Successfully connected " << ModelTypeToString(type_);
   is_connected_ = true;
   core_ = core;
   sync_thread_ = sync_thread;