Sync: Remove pthreads from event_sys code. Remove asynch version of GaiaAuthe...

chrome/browser/sync/util/event_sys-inl.h

 // Copyright (c) 2009 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.
 
 #ifndef CHROME_BROWSER_SYNC_UTIL_EVENT_SYS_INL_H_
 #define CHROME_BROWSER_SYNC_UTIL_EVENT_SYS_INL_H_
 
 #include <map>
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
+#include "base/condition_variable.h"
+#include "base/lock.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "base/port.h"
-#include "chrome/browser/sync/util/compat_pthread.h"
 #include "chrome/browser/sync/util/event_sys.h"
-#include "chrome/browser/sync/util/pthread_helpers.h"
 #include "chrome/browser/sync/util/sync_types.h"
 
 // How to use Channels:
 
 // 0. Assume Bob is the name of the class from which you want to broadcast
 //    events.
 // 1. Choose an EventType. This could be an Enum or something more complicated.
 // 2. Create an EventTraits class for your EventType. It must have
 //    two members:
 //
@@ skipping 24 matching lines @@
 // An Event Channel is a source, or broadcaster of events. Listeners subscribe
 // by calling the AddListener() method. The owner of the channel calls the
 // NotifyListeners() method.
 //
 // Don't inherit from this class. Just make an event_channel member and an
 // event_channel() accessor.
 
 // No reason why CallbackWaiters has to be templatized.
 class CallbackWaiters {
  public:
-  CallbackWaiters() : waiter_count_(0), callback_done_(false) {
+  CallbackWaiters() : waiter_count_(0),
+                      callback_done_(false),
+                      condvar_(&mutex_) {
   }
   ~CallbackWaiters() {
     DCHECK_EQ(0, waiter_count_);
   }
-  void WaitForCallbackToComplete(PThreadMutex* listeners_mutex) {
+  void WaitForCallbackToComplete(Lock* listeners_mutex) {
     {
-      PThreadScopedLock<PThreadMutex> lock(&mutex_);
+      AutoLock lock(mutex_);
       waiter_count_ += 1;
-      listeners_mutex->Unlock();
+      listeners_mutex->Release();
       while (!callback_done_)
-        pthread_cond_wait(&condvar_.condvar_, &mutex_.mutex_);
+        condvar_.Wait();
       waiter_count_ -= 1;
       if (0 != waiter_count_)
         return;
     }
     delete this;
   }
 
   void Signal() {
-    PThreadScopedLock<PThreadMutex> lock(&mutex_);
+    AutoLock lock(mutex_);
     callback_done_ = true;
-    pthread_cond_broadcast(&condvar_.condvar_);
+    condvar_.Broadcast();
   }
 
  protected:
   int waiter_count_;
   bool callback_done_;
-  PThreadMutex mutex_;
-  PThreadCondVar condvar_;
+  Lock mutex_;
+  ConditionVariable condvar_;
 };
 
 template <typename EventTraitsType, typename NotifyLock,
           typename ScopedNotifyLocker>
 class EventChannel {
  public:
   typedef EventTraitsType EventTraits;
   typedef typename EventTraits::EventType EventType;
   typedef EventListener<EventType> Listener;
 
  protected:
   typedef std::map<Listener*, bool> Listeners;
-  typedef PThreadScopedLock<PThreadMutex> ScopedListenersLock;
 
  public:
   // The shutdown event gets send in the EventChannel's destructor.
   explicit EventChannel(const EventType& shutdown_event)
     : current_listener_callback_(NULL),
       callback_waiters_(NULL),
       shutdown_event_(shutdown_event) {
   }
 
   ~EventChannel() {
     // Tell all the listeners that the channel is being deleted.
     NotifyListeners(shutdown_event_);
 
     // Make sure all the listeners have been disconnected. Otherwise, they
     // will try to call RemoveListener() at a later date.
 #ifdef DEBUG
-    ScopedListenersLock lock(&listeners_mutex_);
+    AutoLock lock(listeners_mutex_);
     for (typename Listeners::iterator i = listeners_.begin();
          i != listeners_.end(); ++i) {
       DCHECK(i->second) << "Listener not disconnected";
     }
 #endif
   }
 
   // Never call this twice for the same listener.
   //
   // Thread safe.
   void AddListener(Listener* listener) {
-    ScopedListenersLock lock(&listeners_mutex_);
+    AutoLock lock(listeners_mutex_);
     typename Listeners::iterator found = listeners_.find(listener);
     if (found == listeners_.end()) {
       listeners_.insert(std::make_pair(listener,
                                        false));  // Not dead yet.
     } else {
       DCHECK(found->second) << "Attempted to add the same listener twice.";
       found->second = false;  // Not dead yet.
     }
   }
 
   // If listener's callback is currently executing, this method waits until the
   // callback completes before returning.
   //
   // Thread safe.
   void RemoveListener(Listener* listener) {
     bool wait = false;
-    listeners_mutex_.Lock();
+    listeners_mutex_.Acquire();
     typename Listeners::iterator found = listeners_.find(listener);
     if (found != listeners_.end()) {
       found->second = true;  // Mark as dead.
       wait = (found->first == current_listener_callback_ &&
-              (!pthread_equal(current_listener_callback_thread_id_,
-                              pthread_self())));
+          (MessageLoop::current() != current_listener_callback_message_loop_));
     }
     if (!wait) {
-      listeners_mutex_.Unlock();
+      listeners_mutex_.Release();
       return;
     }
     if (NULL == callback_waiters_)
       callback_waiters_ = new CallbackWaiters;
     callback_waiters_->WaitForCallbackToComplete(&listeners_mutex_);
   }
 
   // Blocks until all listeners have been notified.
   //
   // NOT thread safe.  Must only be called by one thread at a time.
   void NotifyListeners(const EventType& event) {
-    ScopedNotifyLocker lock_notify(&notify_lock_);
-    listeners_mutex_.Lock();
+    ScopedNotifyLocker lock_notify(notify_lock_);
+    listeners_mutex_.Acquire();
     DCHECK(NULL == current_listener_callback_);
-    current_listener_callback_thread_id_ = pthread_self();
+    current_listener_callback_message_loop_ = MessageLoop::current();
     typename Listeners::iterator i = listeners_.begin();
     while (i != listeners_.end()) {
       if (i->second) {  // Clean out dead listeners
         listeners_.erase(i++);
         continue;
       }
       current_listener_callback_ = i->first;
-      listeners_mutex_.Unlock();
+      listeners_mutex_.Release();
 
       i->first->HandleEvent(event);
 
-      listeners_mutex_.Lock();
+      listeners_mutex_.Acquire();
       current_listener_callback_ = NULL;
       if (NULL != callback_waiters_) {
         callback_waiters_->Signal();
         callback_waiters_ = NULL;
       }
 
       ++i;
     }
-    listeners_mutex_.Unlock();
+    listeners_mutex_.Release();
   }
 
   // A map iterator remains valid until the element it points to gets removed
   // from the map, so a map is perfect for our needs.
   //
   // Map value is a bool, true means the Listener is dead.
   Listeners listeners_;
   // NULL means no callback is currently being called.
   Listener* current_listener_callback_;
   // Only valid when current_listener is not NULL.
   // The thread on which the callback is executing.
-  pthread_t current_listener_callback_thread_id_;
+  MessageLoop* current_listener_callback_message_loop_;
   // Win32 Event that is usually NULL. Only created when another thread calls
   // Remove while in callback. Owned and closed by the thread calling Remove().
   CallbackWaiters* callback_waiters_;
 
-  PThreadMutex listeners_mutex_;  // Protects all members above.
+  Lock listeners_mutex_;  // Protects all members above.
   const EventType shutdown_event_;
   NotifyLock notify_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(EventChannel);
 };
 
 // An EventListenerHookup hooks up a method in your class to an EventChannel.
 // Deleting the hookup disconnects from the EventChannel.
 //
 // Contains complexity of inheriting from Listener class and managing lifetimes.
@@ skipping 110 matching lines @@
                                             CallbackObject* cbobject,
                                             CallbackMethod cbmethod,
                                             CallbackArg0 arg0) {
   return new ArgHookup<EventChannel,
     typename EventChannel::EventTraits,
     CallbackObject, CallbackMethod, CallbackArg0>(channel, cbobject,
                                                   cbmethod, arg0);
 }
 
 #endif  // CHROME_BROWSER_SYNC_UTIL_EVENT_SYS_INL_H_