Fix up broken tests on 10.5

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 171 matching lines @@
   void OnListen();
 
   // Watcher overrides
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int fd);
 
  private:
   std::string name_;
   Domain domain_;
   Listener::Delegate* delegate_;
+  bool started_;
   int fd_;
   int token_;
   Lock switchboard_lock_;
   static LeopardSwitchboardThread* g_switchboard_thread_;
   base::MessagePumpLibevent::FileDescriptorWatcher watcher_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
 
   void StartLeopard();
   void StartSnowLeopard();
   DISALLOW_COPY_AND_ASSIGN(ListenerImpl);
@@ skipping 206 matching lines @@
 }
 
 void LeopardSwitchboardThread::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 LeopardSwitchboardThread* ListenerImpl::g_switchboard_thread_ = NULL;
 
 ListenerImpl::ListenerImpl(
     const std::string& name, Domain domain, Listener::Delegate* delegate)
-    : name_(name), domain_(domain), delegate_(delegate), fd_(-1), token_(-1) {
+    : name_(name), domain_(domain), delegate_(delegate), started_(false),
+      fd_(-1), token_(-1) {
 }
 
 ListenerImpl::~ListenerImpl() {
-  if (!UseLeopardSwitchboardThread()) {
-    if (fd_ != -1) {
-      uint32_t status = notify_cancel(token_);
-      DCHECK_EQ(status, static_cast<uint32_t>(NOTIFY_STATUS_OK));
-    }
-  } else {
-    base::AutoLock autolock(switchboard_lock_);
-    if (g_switchboard_thread_) {
-      std::string notification = AddPrefixToNotification(name_, domain_);
-      CHECK(g_switchboard_thread_->RemoveListener(this, notification));
+  if (started_) {
+    if (!UseLeopardSwitchboardThread()) {
+      if (fd_ != -1) {
+        uint32_t status = notify_cancel(token_);
+        DCHECK_EQ(status, static_cast<uint32_t>(NOTIFY_STATUS_OK));
+      }
+    } 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(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;
@@ skipping 26 matching lines @@
       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);
     }
   }
+  started_ = success;
   Task* task =
       new Listener::ListenerStartedTask(name_, domain_, delegate_, success);
   CHECK(message_loop_proxy_->PostTask(FROM_HERE, task));
 }
 
 void ListenerImpl::StartSnowLeopard() {
   DCHECK(!UseLeopardSwitchboardThread());
   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);
+    if (!success) {
+      uint32_t status = notify_cancel(token_);
+      DCHECK_EQ(status, static_cast<uint32_t>(NOTIFY_STATUS_OK));
+      fd_ = -1;
+    }
   }
+  started_ = success;
   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_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
   DCHECK_EQ(fd, fd_);
   int token;
@@ skipping 42 matching lines @@
   return impl_->name();
 }
 
 Domain Listener::domain() const {
   return impl_->domain();
 }
 
 }  // namespace multi_process_notification
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(multi_process_notification::ListenerImpl);