Fix up notifications so that they aren't only on Browser IOThread.

chrome/browser/multi_process_notification_mac.mm

 // 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.
 
 #include "chrome/browser/multi_process_notification.h"
 
 #import <Foundation/Foundation.h>
 #include <notify.h>
 #include <sys/select.h>
 #include <sys/socket.h>
@@ skipping 10 matching lines @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop_proxy.h"
 #include "base/message_pump_libevent.h"
 #include "base/path_service.h"
 #include "base/ref_counted.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/simple_thread.h"
-#include "chrome/browser/browser_thread.h"
 #include "chrome/common/chrome_paths.h"
 
 // Enable this to build with leopard_switchboard_thread
 // #define USE_LEOPARD_SWITCHBOARD_THREAD 1
 
 namespace {
 
 std::string AddPrefixToNotification(const std::string& name,
                                     multi_process_notification::Domain domain) {
   // The ordering of the components in the string returned by this function
@@ skipping 126 matching lines @@
   base::MessagePumpLibevent::FileDescriptorWatcher watcher_;
 };
 
 class ListenerImpl : public base::MessagePumpLibevent::Watcher {
  public:
   ListenerImpl(const std::string& name,
                Domain domain,
                Listener::Delegate* delegate);
   virtual ~ListenerImpl();
 
-  bool Start();
+  bool Start(MessageLoop* io_loop_to_listen_on);
+
+  std::string name() const { return name_; }
+  Domain domain() const { return domain_; }
+
   void OnListen();
 
   // Watcher overrides
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int fd);
 
  private:
   std::string name_;
   Domain domain_;
   Listener::Delegate* delegate_;
@@ skipping 234 matching lines @@
     }
   } else {
     base::AutoLock autolock(switchboard_lock_);
     if (g_switchboard_thread_) {
       std::string notification = AddPrefixToNotification(name_, domain_);
       CHECK(g_switchboard_thread_->RemoveListener(this, notification));
     }
   }
 }
 
-bool ListenerImpl::Start() {
+bool ListenerImpl::Start(MessageLoop* io_loop_to_listen_on) {
   DCHECK_EQ(fd_, -1);
   DCHECK_EQ(token_, -1);
+  if (io_loop_to_listen_on->type() != MessageLoop::TYPE_IO) {
+    DLOG(ERROR) << "io_loop_to_listen_on must be TYPE_IO";
+    return false;
+  }
   message_loop_proxy_ = base::MessageLoopProxy::CreateForCurrentThread();
   Task* task;
   if(UseLeopardSwitchboardThread()) {
     task = NewRunnableMethod(this, &ListenerImpl::StartLeopard);
   } else {
     task = NewRunnableMethod(this, &ListenerImpl::StartSnowLeopard);
   }
-  return BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, task);
+  io_loop_to_listen_on->PostTask(FROM_HERE, task);
+  return true;
 }
 
 void ListenerImpl::StartLeopard() {
   DCHECK(UseLeopardSwitchboardThread());
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   bool success = true;
   {
     base::AutoLock autolock(switchboard_lock_);
     if (g_switchboard_thread_ && g_switchboard_thread_->HasBeenJoined()) {
       // The only time this should ever occur is in unit tests.
       delete g_switchboard_thread_;
       g_switchboard_thread_ = NULL;
     }
     DCHECK(!(g_switchboard_thread_ && g_switchboard_thread_->finished()));
     if (!g_switchboard_thread_) {
       g_switchboard_thread_ = new LeopardSwitchboardThread();
       success = g_switchboard_thread_->Init();
       if (success) {
         g_switchboard_thread_->Start();
       }
     }
     if (success) {
       std::string notification = AddPrefixToNotification(name_, domain_);
       success = g_switchboard_thread_->AddListener(this, notification);
     }
   }
   Task* task =
       new Listener::ListenerStartedTask(name_, domain_, delegate_, success);
   CHECK(message_loop_proxy_->PostTask(FROM_HERE, task));
 }
 
 void ListenerImpl::StartSnowLeopard() {
   DCHECK(!UseLeopardSwitchboardThread());
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   bool success = true;
   std::string notification = AddPrefixToNotification(name_, domain_);
   uint32_t status = notify_register_file_descriptor(
       notification.c_str(), &fd_, 0, &token_);
   if (status != NOTIFY_STATUS_OK) {
     LOG(ERROR) << "unable to notify_register_file_descriptor for '"
                << notification << "' Status: " << status;
     success = false;
   }
   if (success) {
     MessageLoopForIO* io_loop = MessageLoopForIO::current();
     success = io_loop->WatchFileDescriptor(
         fd_, true, MessageLoopForIO::WATCH_READ, &watcher_, this);
   }
   Task* task =
       new Listener::ListenerStartedTask(name_, domain_, delegate_, success);
   CHECK(message_loop_proxy_->PostTask(FROM_HERE, task));
 }
 
 void ListenerImpl::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(!UseLeopardSwitchboardThread());
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   DCHECK_EQ(fd, fd_);
   int token;
   int status = HANDLE_EINTR(read(fd, &token, sizeof(token)));
   if (status < 0) {
     PLOG(ERROR) << "read";
   } else if (status == 0) {
     LOG(ERROR) << "external_fd_ closed";
   } else if (status != sizeof(token)) {
     LOG(ERROR) << "unexpected read size " << status;
   } else {
     // Have to swap to native endianness <http://openradar.appspot.com/8821081>.
     token = static_cast<int>(ntohl(token));
     if (token == token_) {
       OnListen();
     } else {
       LOG(ERROR) << "unexpected value " << token;
     }
   }
 }
 
 void ListenerImpl::OnListen() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   Task* task =
       new Listener::NotificationReceivedTask(name_, domain_, delegate_);
   CHECK(message_loop_proxy_->PostTask(FROM_HERE, task));
 }
 
 void ListenerImpl::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 Listener::Listener(
     const std::string& name, Domain domain, Listener::Delegate* delegate)
     : impl_(new ListenerImpl(name, domain, delegate)) {
 }
 
 Listener::~Listener() {
 }
 
-bool Listener::Start() {
-  return impl_->Start();
+bool Listener::Start(MessageLoop* io_loop_to_listen_on) {
+  return impl_->Start(io_loop_to_listen_on);
+}
+
+std::string Listener::name() const {
+  return impl_->name();
+}
+
+Domain Listener::domain() const {
+  return impl_->domain();
 }
 
 }  // namespace multi_process_notification
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(multi_process_notification::ListenerImpl);