Move sync notifier contruction out of syncer thread.

chrome/browser/sync/notifier/p2p_notifier.cc

 // Copyright (c) 2011 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.
+//
+// Note: Since we need to shutdown TalkMediator on the method_thread, we are
+// calling Logout on TalkMediator when the last observer is removed.
+// Users will need to call UpdateCredentials again to use the same object.
 
 #include "chrome/browser/sync/notifier/p2p_notifier.h"
 
 #include "chrome/browser/sync/notifier/sync_notifier_observer.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/model_type_payload_map.h"
 #include "jingle/notifier/listener/mediator_thread_impl.h"
 #include "jingle/notifier/listener/talk_mediator_impl.h"
 
 namespace sync_notifier {
 
 namespace {
 const char kSyncNotificationChannel[] = "http://www.google.com/chrome/sync";
 const char kSyncNotificationData[] = "sync-ping-p2p";
 }  // namespace
 
 P2PNotifier::P2PNotifier(
     const notifier::NotifierOptions& notifier_options)
     : talk_mediator_(
         new notifier::TalkMediatorImpl(
             new notifier::MediatorThreadImpl(notifier_options),
             notifier_options)),
       logged_in_(false),
-      notifications_enabled_(false) {
+      notifications_enabled_(false),
+      construction_message_loop_(MessageLoop::current()),
+      method_message_loop_(NULL) {
   talk_mediator_->SetDelegate(this);
 }
 
-P2PNotifier::~P2PNotifier() {}
+P2PNotifier::~P2PNotifier() {
+  DCHECK_EQ(MessageLoop::current(), construction_message_loop_);
+}
 
 void P2PNotifier::AddObserver(SyncNotifierObserver* observer) {
+  // Can be the first method to be called. Assign method_message_loop_ if

[akalin, 2011/04/05 22:02:46]

See comment in TalkMediatorImpl

[nilesh, 2011/04/05 23:36:17]

Done.

+  // not already assigned.
+  if (!method_message_loop_) {
+    method_message_loop_ = MessageLoop::current();
+  } else {
+    DCHECK_EQ(MessageLoop::current(), method_message_loop_);
+  }
   observer_list_.AddObserver(observer);
 }
 
 void P2PNotifier::RemoveObserver(SyncNotifierObserver* observer) {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   observer_list_.RemoveObserver(observer);
+
+  // Logout after the last observer is removed.
+  if (observer_list_.size() == 0) {
+   talk_mediator_->Logout();
+  }
 }
 
-void P2PNotifier::SetState(const std::string& state) {}
+void P2PNotifier::SetState(const std::string& state) {
+  // Can be the first method to be called. Assign method_message_loop_ if
+  // not already assigned.
+  if (!method_message_loop_) {
+    method_message_loop_ = MessageLoop::current();
+  } else {
+    DCHECK_EQ(MessageLoop::current(), method_message_loop_);
+  }
+}
 
 void P2PNotifier::UpdateCredentials(
     const std::string& email, const std::string& token) {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   // If already logged in, the new credentials will take effect on the
   // next reconnection.
   talk_mediator_->SetAuthToken(email, token, SYNC_SERVICE_NAME);
   if (!logged_in_) {
     if (!talk_mediator_->Login()) {
       LOG(DFATAL) << "Could not login for " << email;
       return;
     }
 
     notifier::Subscription subscription;
     subscription.channel = kSyncNotificationChannel;
     // There may be some subtle issues around case sensitivity of the
     // from field, but it doesn't matter too much since this is only
     // used in p2p mode (which is only used in testing).
     subscription.from = email;
     talk_mediator_->AddSubscription(subscription);
 
     logged_in_ = true;
   }
 }
 
 void P2PNotifier::UpdateEnabledTypes(const syncable::ModelTypeSet& types) {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   enabled_types_ = types;
   MaybeEmitNotification();
 }
 
 void P2PNotifier::SendNotification() {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   VLOG(1) << "Sending XMPP notification...";
   notifier::Notification notification;
   notification.channel = kSyncNotificationChannel;
   notification.data = kSyncNotificationData;
   bool success = talk_mediator_->SendNotification(notification);
   if (success) {
     VLOG(1) << "Sent XMPP notification";
   } else {
     VLOG(1) << "Could not send XMPP notification";
   }
 }
 
 void P2PNotifier::OnNotificationStateChange(bool notifications_enabled) {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   notifications_enabled_ = notifications_enabled;
   FOR_EACH_OBSERVER(SyncNotifierObserver, observer_list_,
       OnNotificationStateChange(notifications_enabled_));
   MaybeEmitNotification();
 }
 
 void P2PNotifier::OnIncomingNotification(
     const notifier::Notification& notification) {
+  DCHECK_EQ(MessageLoop::current(), method_message_loop_);
   VLOG(1) << "Sync received P2P notification.";
   if (notification.channel != kSyncNotificationChannel) {
     LOG(WARNING) << "Notification fron unexpected source: "
                  << notification.channel;
   }
   MaybeEmitNotification();
 }
 
 void P2PNotifier::OnOutgoingNotification() {}
 
@@ skipping 11 matching lines @@
     return;
   }
   syncable::ModelTypePayloadMap type_payloads =
       syncable::ModelTypePayloadMapFromBitSet(
           syncable::ModelTypeBitSetFromSet(enabled_types_), std::string());
   FOR_EACH_OBSERVER(SyncNotifierObserver, observer_list_,
                     OnIncomingNotification(type_payloads));
 }
 
 }  // namespace sync_notifier