Rewrite most of the scopers in //base/mac to use ScopedTypeRef or ScopedGeneric.

base/message_loop/message_pump_io_ios.cc

 // Copyright 2012 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_loop/message_pump_io_ios.h"
 
 namespace base {
 
 MessagePumpIOSForIO::FileDescriptorWatcher::FileDescriptorWatcher()
     : is_persistent_(false),
       fdref_(NULL),
       callback_types_(0),
       fd_source_(NULL),
       watcher_(NULL) {
 }
 
 MessagePumpIOSForIO::FileDescriptorWatcher::~FileDescriptorWatcher() {
   StopWatchingFileDescriptor();
 }
 
 bool MessagePumpIOSForIO::FileDescriptorWatcher::StopWatchingFileDescriptor() {
   if (fdref_ == NULL)
     return true;
 
-  CFFileDescriptorDisableCallBacks(fdref_, callback_types_);
+  CFFileDescriptorDisableCallBacks(fdref_.get(), callback_types_);
   if (pump_)
     pump_->RemoveRunLoopSource(fd_source_);
   fd_source_.reset();
   fdref_.reset();
   callback_types_ = 0;
   pump_.reset();
   watcher_ = NULL;
   return true;
 }
 
 void MessagePumpIOSForIO::FileDescriptorWatcher::Init(
     CFFileDescriptorRef fdref,
     CFOptionFlags callback_types,
     CFRunLoopSourceRef fd_source,
     bool is_persistent) {
   DCHECK(fdref);
-  DCHECK(!fdref_);
+  DCHECK(!fdref_.is_valid());
 
   is_persistent_ = is_persistent;
   fdref_.reset(fdref);
   callback_types_ = callback_types;
   fd_source_.reset(fd_source);
 }
 
 void MessagePumpIOSForIO::FileDescriptorWatcher::OnFileCanReadWithoutBlocking(
     int fd,
     MessagePumpIOSForIO* pump) {
@@ skipping 37 matching lines @@
   source_context.info = controller;
 
   CFOptionFlags callback_types = 0;
   if (mode & WATCH_READ) {
     callback_types |= kCFFileDescriptorReadCallBack;
   }
   if (mode & WATCH_WRITE) {
     callback_types |= kCFFileDescriptorWriteCallBack;
   }
 
-  CFFileDescriptorRef fdref = controller->fdref_;
+  CFFileDescriptorRef fdref = controller->fdref_.get();
   if (fdref == NULL) {
     base::ScopedCFTypeRef<CFFileDescriptorRef> scoped_fdref(
         CFFileDescriptorCreate(
             kCFAllocatorDefault, fd, false, HandleFdIOEvent, &source_context));
     if (scoped_fdref == NULL) {
       NOTREACHED() << "CFFileDescriptorCreate failed";
       return false;
     }
 
     CFFileDescriptorEnableCallBacks(scoped_fdref, callback_types);
@@ skipping 56 matching lines @@
 void MessagePumpIOSForIO::DidProcessIOEvent() {
   FOR_EACH_OBSERVER(IOObserver, io_observers_, DidProcessIOEvent());
 }
 
 // static
 void MessagePumpIOSForIO::HandleFdIOEvent(CFFileDescriptorRef fdref,
                                           CFOptionFlags callback_types,
                                           void* context) {
   FileDescriptorWatcher* controller =
       static_cast<FileDescriptorWatcher*>(context);
-  DCHECK_EQ(fdref, controller->fdref_);
+  DCHECK_EQ(fdref, controller->fdref_.get());
 
   // Ensure that |fdref| will remain live for the duration of this function
   // call even if |controller| is deleted or |StopWatchingFileDescriptor()| is
   // called, either of which will cause |fdref| to be released.
   ScopedCFTypeRef<CFFileDescriptorRef> scoped_fdref(
       fdref, base::scoped_policy::RETAIN);
 
   int fd = CFFileDescriptorGetNativeDescriptor(fdref);
   MessagePumpIOSForIO* pump = controller->pump().get();
   DCHECK(pump);
   if (callback_types & kCFFileDescriptorWriteCallBack)
     controller->OnFileCanWriteWithoutBlocking(fd, pump);
 
   // Perform the read callback only if the file descriptor has not been
   // invalidated in the write callback. As |FileDescriptorWatcher| invalidates
   // its file descriptor on destruction, the file descriptor being valid also
   // guarantees that |controller| has not been deleted.
   if (callback_types & kCFFileDescriptorReadCallBack &&
       CFFileDescriptorIsValid(fdref)) {
-    DCHECK_EQ(fdref, controller->fdref_);
+    DCHECK_EQ(fdref, controller->fdref_.get());
     controller->OnFileCanReadWithoutBlocking(fd, pump);
   }
 
   // Re-enable callbacks after the read/write if the file descriptor is still
   // valid and the controller is persistent.
   if (CFFileDescriptorIsValid(fdref) && controller->is_persistent_) {
-    DCHECK_EQ(fdref, controller->fdref_);
+    DCHECK_EQ(fdref, controller->fdref_.get());
     CFFileDescriptorEnableCallBacks(fdref, callback_types);
   }
 }
 
 }  // namespace base