Revert 212948 "Made MessagePump a non-thread safe class."

trunk/src/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),
+      pump_(NULL),
       watcher_(NULL) {
 }
 
 MessagePumpIOSForIO::FileDescriptorWatcher::~FileDescriptorWatcher() {
   StopWatchingFileDescriptor();
 }
 
 bool MessagePumpIOSForIO::FileDescriptorWatcher::StopWatchingFileDescriptor() {
   if (fdref_ == NULL)
     return true;
 
   CFFileDescriptorDisableCallBacks(fdref_, callback_types_);
-  if (pump_)
-    pump_->RemoveRunLoopSource(fd_source_);
+  pump_->RemoveRunLoopSource(fd_source_);
   fd_source_.reset();
   fdref_.reset();
   callback_types_ = 0;
-  pump_.reset();
+  pump_ = NULL;
   watcher_ = NULL;
   return true;
 }
 
 void MessagePumpIOSForIO::FileDescriptorWatcher::Init(
     CFFileDescriptorRef fdref,
     CFOptionFlags callback_types,
     CFRunLoopSourceRef fd_source,
     bool is_persistent) {
   DCHECK(fdref);
@@ skipping 16 matching lines @@
 
 void MessagePumpIOSForIO::FileDescriptorWatcher::OnFileCanWriteWithoutBlocking(
     int fd,
     MessagePumpIOSForIO* pump) {
   DCHECK(callback_types_ & kCFFileDescriptorWriteCallBack);
   pump->WillProcessIOEvent();
   watcher_->OnFileCanWriteWithoutBlocking(fd);
   pump->DidProcessIOEvent();
 }
 
-MessagePumpIOSForIO::MessagePumpIOSForIO() : weak_factory_(this) {
+MessagePumpIOSForIO::MessagePumpIOSForIO() {
 }
 
 MessagePumpIOSForIO::~MessagePumpIOSForIO() {
 }
 
 bool MessagePumpIOSForIO::WatchFileDescriptor(
     int fd,
     bool persistent,
     int mode,
     FileDescriptorWatcher *controller,
@@ skipping 57 matching lines @@
       return false;
     }
 
     // Combine old/new event masks.
     CFFileDescriptorDisableCallBacks(fdref, controller->callback_types_);
     controller->callback_types_ |= callback_types;
     CFFileDescriptorEnableCallBacks(fdref, controller->callback_types_);
   }
 
   controller->set_watcher(delegate);
-  controller->set_pump(weak_factory_.GetWeakPtr());
+  controller->set_pump(this);
 
   return true;
 }
 
 void MessagePumpIOSForIO::RemoveRunLoopSource(CFRunLoopSourceRef source) {
   CFRunLoopRemoveSource(run_loop(), source, kCFRunLoopCommonModes);
 }
 
 void MessagePumpIOSForIO::AddIOObserver(IOObserver *obs) {
   io_observers_.AddObserver(obs);
@@ skipping 19 matching lines @@
       static_cast<FileDescriptorWatcher*>(context);
   DCHECK_EQ(fdref, controller->fdref_);
 
   // 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);
+  MessagePumpIOSForIO* pump = controller->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_);
     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_);
     CFFileDescriptorEnableCallBacks(fdref, callback_types);
   }
 }
 
 }  // namespace base