Remove unused pthread helpers. Looks like we don't use pthread_rw locks at al...

chrome/browser/sync/util/pthread_helpers.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_PTHREAD_HELPERS_H_
 #define CHROME_BROWSER_SYNC_UTIL_PTHREAD_HELPERS_H_
 
 #include <pthread.h>
 #include "base/logging.h"
 #include "build/build_config.h"
 
 #ifdef OS_WIN
 typedef void* thread_handle;
 #else
 typedef pthread_t thread_handle;
 #endif
 
 // Creates a pthread, detaches from it, and returns a Win32 HANDLE for it that
 // the caller must CloseHandle().
 thread_handle CreatePThread(void* (*start)(void* payload), void* parameter);
 
-class PThreadRWLock {
- public:
-  inline PThreadRWLock() {
-    int result = pthread_rwlock_init(&rwlock_, 0);
-    DCHECK_EQ(0, result);
-  }
-  ~PThreadRWLock() {
-    int result = pthread_rwlock_destroy(&rwlock_);
-    DCHECK_EQ(0, result);
-  }
-  pthread_rwlock_t rwlock_;
-
-  DISALLOW_COPY_AND_ASSIGN(PThreadRWLock);
-};
-
-// ScopedReadLock attempts to acquire a write lock in its constructor and then
-// releases it in its destructor.
-class ScopedWriteLock {
- public:
-  explicit ScopedWriteLock(pthread_rwlock_t* rwlock) : rwlock_(rwlock) {
-    int result = pthread_rwlock_wrlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
-
-  explicit ScopedWriteLock(PThreadRWLock* rwlock) : rwlock_(&rwlock->rwlock_) {
-    int result = pthread_rwlock_wrlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
-
-  ~ScopedWriteLock() {
-    int result = pthread_rwlock_unlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
-
- protected:
-  pthread_rwlock_t* rwlock_;
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedWriteLock);
-};
-
-// ScopedReadLock attempts to acquire a read lock in its constructor and then
-// releases it in its destructor.
-class ScopedReadLock {
- public:
-  explicit ScopedReadLock(pthread_rwlock_t* rwlock) : rwlock_(rwlock) {
-    int result = pthread_rwlock_rdlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
-
-  explicit ScopedReadLock(PThreadRWLock* rwlock) : rwlock_(&rwlock->rwlock_) {
-    int result = pthread_rwlock_rdlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
-
-  ~ScopedReadLock() {
-    int result = pthread_rwlock_unlock(rwlock_);
-    DCHECK_EQ(0, result);
-  }
- protected:
-  pthread_rwlock_t* rwlock_;
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedReadLock);
-};
-
 template <typename LockType>
 class PThreadScopedLock {
  public:
   explicit inline PThreadScopedLock(LockType* lock) : lock_(lock) {
     if (lock_)
       lock->Lock();
   }
   inline ~PThreadScopedLock() {
     Unlock();
   }
@@ skipping 59 matching lines @@
 
 #ifndef NDEBUG
   pthread_mutexattr_t mutex_attributes_;
   bool private_attributes_in_use_;
 #endif
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PThreadMutex);
 };
 
-class PThreadMutexAttr {
- public:
-  pthread_mutexattr_t attr;
-  inline PThreadMutexAttr(int type) {
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, type);
-  }
-  inline ~PThreadMutexAttr() {
-    pthread_mutexattr_destroy(&attr);
-  }
- private:
-  DISALLOW_COPY_AND_ASSIGN(PThreadMutexAttr);
-};
-
-class PThreadRecursiveMutex : public PThreadMutex {
- public:
-  inline PThreadRecursiveMutex() : PThreadMutex(recursive_attr()) {}
- private:
-  static inline pthread_mutexattr_t* recursive_attr() {
-    static PThreadMutexAttr recursive(PTHREAD_MUTEX_RECURSIVE);
-    return &recursive.attr;
-  }
-  DISALLOW_COPY_AND_ASSIGN(PThreadRecursiveMutex);
-};
-
-
-class PThreadScopedDisabledCancellation {
- public:
-  inline PThreadScopedDisabledCancellation() {
-    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancel_state_);
-  }
-  inline ~PThreadScopedDisabledCancellation() {
-    pthread_setcancelstate(old_cancel_state_, NULL);
-  }
- private:
-  int old_cancel_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(PThreadScopedDisabledCancellation);
-};
-
 class PThreadCondVar {
  public:
   inline PThreadCondVar() {
     int result = pthread_cond_init(&condvar_, 0);
     DCHECK_EQ(0, result);
   }
   ~PThreadCondVar() {
     int result = pthread_cond_destroy(&condvar_);
     DCHECK_EQ(0, result);
   }
   inline void Signal() {
     int result = pthread_cond_signal(&condvar_);
     DCHECK_EQ(0, result);
   }
   inline void Broadcast() {
     int result = pthread_cond_broadcast(&condvar_);
     DCHECK_EQ(0, result);
   }
   pthread_cond_t condvar_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PThreadCondVar);
 };
 
-template <typename ValueType>
-class PThreadThreadVar {
- public:
-  PThreadThreadVar(void (*destructor)(void* payload)) {
-    int result = pthread_key_create(&thread_key_, destructor);
-    DCHECK_EQ(0, result);
-  }
-  ~PThreadThreadVar() {
-    int result = pthread_key_delete(thread_key_);
-    DCHECK_EQ(0, result);
-  }
-  void SetValue(ValueType value) {
-    int result = pthread_setspecific(thread_key_, static_cast<void*>(value));
-    DCHECK_EQ(0, result);
-  }
-  ValueType GetValue() {
-    return static_cast<ValueType>(pthread_getspecific(thread_key_));
-  }
- private:
-  pthread_key_t thread_key_;
-  DISALLOW_COPY_AND_ASSIGN(PThreadThreadVar);
-};
-
 // Returns the absolute time ms milliseconds from now. Useful for passing
 // result to pthread_cond_timedwait().
 struct timespec GetPThreadAbsoluteTime(uint32 ms_from_now);
 
 // Assign a descriptive label to the current thread. This is useful to see
 // in a GUI debugger, but may not be implementable on all platforms.
 void NameCurrentThreadForDebugging(char* name);
 
 #endif  // CHROME_BROWSER_SYNC_UTIL_PTHREAD_HELPERS_H_