Give a CFRunLoop to the IO message loop type on Mac OS X.

base/message_pump_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 "base/message_pump_mac.h"
 
 #import <AppKit/AppKit.h>
 #import <Foundation/Foundation.h>
 
 #include <limits>
 
 #include "base/logging.h"
+#include "base/mac/scoped_cftyperef.h"
 #include "base/time.h"
 
 namespace {
 
 void NoOp(void* info) {
 }
 
 const CFTimeInterval kCFTimeIntervalMax =
     std::numeric_limits<CFTimeInterval>::max();
 
 }  // namespace
 
 namespace base {
 
+MessagePumpCFRunLoopBase::FileDescriptorWatcher::FileDescriptorWatcher()
+    : is_persistent_(false),
+      fdref_(NULL),
+      callback_types_(0),
+      fd_source_(NULL),
+      pump_(NULL),
+      watcher_(NULL) {
+}
+
+MessagePumpCFRunLoopBase::FileDescriptorWatcher::~FileDescriptorWatcher() {
+  if (fdref_) {
+    StopWatchingFileDescriptor();
+  }
+}
+
+bool MessagePumpCFRunLoopBase::
+    FileDescriptorWatcher::StopWatchingFileDescriptor() {
+  CFFileDescriptorRef fdref = ReleaseCFFileDescriptor();
+  if (fdref == NULL)
+    return true;
+
+  CFFileDescriptorDisableCallBacks(fdref, callback_types_);
+  pump_->RemoveRunLoopSource(fd_source_);
+  CFRelease(fd_source_);
+  fd_source_ = NULL;
+  CFFileDescriptorInvalidate(fdref);
+  CFRelease(fdref);
+  callback_types_ = 0;
+  pump_ = NULL;
+  watcher_ = NULL;
+  return true;
+}
+
+void MessagePumpCFRunLoopBase::FileDescriptorWatcher::Init(
+    CFFileDescriptorRef fdref,
+    CFOptionFlags callback_types,
+    CFRunLoopSourceRef fd_source,
+    bool is_persistent) {
+  DCHECK(fdref);
+  DCHECK(!fdref_);
+
+  is_persistent_ = is_persistent;
+  fdref_ = fdref;
+  callback_types_ = callback_types;
+  fd_source_ = fd_source;
+}
+
+CFFileDescriptorRef
+MessagePumpCFRunLoopBase::FileDescriptorWatcher::ReleaseCFFileDescriptor() {
+  CFFileDescriptorRef fdref = fdref_;
+  fdref_ = NULL;
+  return fdref;
+}
+
+void MessagePumpCFRunLoopBase::
+    FileDescriptorWatcher::OnFileCanReadWithoutBlocking(
+    int fd,
+    MessagePumpCFRunLoopBase* pump) {
+  pump->WillProcessIOEvent();
+  watcher_->OnFileCanReadWithoutBlocking(fd);
+  pump->DidProcessIOEvent();
+}
+
+void MessagePumpCFRunLoopBase::
+    FileDescriptorWatcher::OnFileCanWriteWithoutBlocking(
+    int fd,
+    MessagePumpCFRunLoopBase* pump) {
+  pump->WillProcessIOEvent();
+  watcher_->OnFileCanWriteWithoutBlocking(fd);
+  pump->DidProcessIOEvent();
+}
+
 // A scoper for autorelease pools created from message pump run loops.
 // Avoids dirtying up the ScopedNSAutoreleasePool interface for the rare
 // case where an autorelease pool needs to be passed in.
 class MessagePumpScopedAutoreleasePool {
  public:
   explicit MessagePumpScopedAutoreleasePool(MessagePumpCFRunLoopBase* pump) :
       pool_(pump->CreateAutoreleasePool()) {
   }
    ~MessagePumpScopedAutoreleasePool() {
     [pool_ drain];
@@ skipping 104 matching lines @@
 
   CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);
   CFRelease(work_source_);
 
   CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
   CFRelease(delayed_work_timer_);
 
   CFRelease(run_loop_);
 }
 
+// static
+void MessagePumpCFRunLoopBase::HandleFdIOEvent(CFFileDescriptorRef fdref,
+                                               CFOptionFlags callback_types,
+                                               void* info) {
+  int fd = CFFileDescriptorGetNativeDescriptor(fdref);
+
+  FileDescriptorWatcher* controller =
+      static_cast<FileDescriptorWatcher*>(info);
+
+  CHECK_EQ(fdref, controller->fdref_);
+  bool persistent = controller->is_persistent_;
+
+  MessagePumpCFRunLoopBase* pump = controller->pump();
+
+  if (callback_types & kCFFileDescriptorWriteCallBack) {
+    controller->OnFileCanWriteWithoutBlocking(fd, pump);
+  }
+  if (callback_types & kCFFileDescriptorReadCallBack) {
+    controller->OnFileCanReadWithoutBlocking(fd, pump);
+  }
+
+  // Must read/write from the fd before re-enabling the callbacks.
+  // |controller| may have been deleted, and |fdref| may have been
+  // invalidated.
+  if (CFFileDescriptorIsValid(fdref) && persistent)
+    CFFileDescriptorEnableCallBacks(fdref, callback_types);
+}
+
+bool MessagePumpCFRunLoopBase::WatchFileDescriptor(
+    int fd,
+    bool persistent,
+    Mode mode,
+    FileDescriptorWatcher *controller,
+    Watcher *delegate) {
+  DCHECK_GE(fd, 0);
+  DCHECK(controller);
+  DCHECK(delegate);
+  DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE);
+  // WatchFileDescriptor should be called on the pump thread. It is not
+  // threadsafe, and your watcher may never be registered.
+  DCHECK(watch_file_descriptor_caller_checker_.CalledOnValidThread());
+
+  CFFileDescriptorContext source_context = CFFileDescriptorContext();
+  source_context.version = 0;
+  source_context.info = controller;
+
+  CFOptionFlags callback_types = 0;
+  if ((mode & WATCH_READ) != 0) {
+    callback_types |= kCFFileDescriptorReadCallBack;
+  }
+  if ((mode & WATCH_WRITE) != 0) {
+    callback_types |= kCFFileDescriptorWriteCallBack;
+  }
+
+  base::mac::ScopedCFTypeRef<CFFileDescriptorRef> fdref(
+      controller->ReleaseCFFileDescriptor());
+  if (fdref == NULL) {
+    // Ownership is transferred to the controller.
+    fdref.reset(CFFileDescriptorCreate(kCFAllocatorDefault,
+                                       fd, false,
+                                       HandleFdIOEvent,
+                                       &source_context));
+    if (fdref == NULL) {
+      NOTREACHED() << "CFFileDescriptorCreate failed";
+      return false;
+    }
+    CFFileDescriptorEnableCallBacks(fdref, callback_types);
+
+    // TODO(wtc): what should the 'order' argument be?
+    CFRunLoopSourceRef fd_source = CFFileDescriptorCreateRunLoopSource(
+        kCFAllocatorDefault, fdref, 0);
+    if (fd_source == NULL) {
+      NOTREACHED() << "CFFileDescriptorCreateRunLoopSource failed";
+      return false;
+    }
+    CFRunLoopAddSource(run_loop_, fd_source, kCFRunLoopCommonModes);
+
+    // Transfer ownership of fdref to controller.
+    controller->Init(fdref.release(), callback_types, fd_source, persistent);
+  } else {
+    // It's illegal to use this function to listen on 2 separate fds with the
+    // same |controller|.
+    if (CFFileDescriptorGetNativeDescriptor(fdref) != fd) {
+      NOTREACHED() << "FDs don't match"
+                   << CFFileDescriptorGetNativeDescriptor(fdref)<< "!=" << fd;
+      return false;
+    }
+    if (persistent != controller->is_persistent_) {
+      NOTREACHED() << "persistent don't match";
+      return false;
+    }
+
+    // Combine old/new event masks.
+    CFFileDescriptorDisableCallBacks(fdref, controller->callback_types_);
+    controller->callback_types_ |= callback_types;
+    CFFileDescriptorEnableCallBacks(fdref, controller->callback_types_);
+    controller->fdref_ = fdref.release();
+  }
+
+  controller->set_watcher(delegate);
+  controller->set_pump(this);
+
+  return true;
+}
+
+void MessagePumpCFRunLoopBase::RemoveRunLoopSource(
+    CFRunLoopSourceRef source) {
+  CFRunLoopRemoveSource(run_loop_, source, kCFRunLoopCommonModes);
+}
+
+void MessagePumpCFRunLoopBase::AddIOObserver(IOObserver *obs) {
+  io_observers_.AddObserver(obs);
+}
+
+void MessagePumpCFRunLoopBase::RemoveIOObserver(IOObserver *obs) {
+  io_observers_.RemoveObserver(obs);
+}
+
 // Must be called on the run loop thread.
 void MessagePumpCFRunLoopBase::Run(Delegate* delegate) {
   // nesting_level_ will be incremented in EnterExitRunLoop, so set
   // run_nesting_level_ accordingly.
   int last_run_nesting_level = run_nesting_level_;
   run_nesting_level_ = nesting_level_ + 1;
 
   Delegate* last_delegate = delegate_;
   delegate_ = delegate;
 
@@ skipping 45 matching lines @@
     exploded.day_of_month,
     exploded.hour,
     exploded.minute,
     seconds
   };
   delayed_work_fire_time_ = CFGregorianDateGetAbsoluteTime(gregorian, NULL);
 
   CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);
 }
 
+void MessagePumpCFRunLoopBase::WillProcessIOEvent() {
+  FOR_EACH_OBSERVER(IOObserver, io_observers_, WillProcessIOEvent());
+}
+
+void MessagePumpCFRunLoopBase::DidProcessIOEvent() {
+  FOR_EACH_OBSERVER(IOObserver, io_observers_, DidProcessIOEvent());
+}
+
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::RunDelayedWorkTimer(CFRunLoopTimerRef timer,
                                                    void* info) {
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 
   // The timer won't fire again until it's reset.
   self->delayed_work_fire_time_ = kCFTimeIntervalMax;
 
   // CFRunLoopTimers fire outside of the priority scheme for CFRunLoopSources.
@@ skipping 408 matching lines @@
 // static
 MessagePump* MessagePumpMac::Create() {
   if ([NSThread isMainThread]) {
     return new MessagePumpNSApplication;
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base