Add PTHREAD_PRIO_INHERIT Locks for Mac

base/synchronization/lock.h

 // 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.
 
 #ifndef BASE_SYNCHRONIZATION_LOCK_H_
 #define BASE_SYNCHRONIZATION_LOCK_H_
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 namespace base {
 
+#if defined(OS_POSIX)
+
+// Determines which platforms can consider using priority inheritance locks. Use

[danakj, 2016/07/29 21:06:40]

OK my only nit is that I rather this lives in lock_impl_posix.cc and is an
implementation detail until we need it outside. LGTM otherwise.

[robliao, 2016/07/29 21:22:53]

sgtm. Moved and adjusted the comment for the more local scope.

+// this define for platform code that may not compile if priority inheritance
+// locks aren't available. Lock::PriorityInheritanceAvailable still must be
+// checked as the code may compile but the underlying platform still may not
+// support priority inheritance locks. If you do not require the conditional
+// inclusion at compile time, simply call Lock::PriorityInheritanceAvailable.
+#if defined(OS_NACL) || defined(OS_ANDROID)
+#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 0
+#else
+#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 1
+#endif
+
+#endif
+
 // A convenient wrapper for an OS specific critical section.  The only real
 // intelligence in this class is in debug mode for the support for the
 // AssertAcquired() method.
 class BASE_EXPORT Lock {
  public:
 #if !DCHECK_IS_ON()
    // Optimized wrapper implementation
   Lock() : lock_() {}
   ~Lock() {}
   void Acquire() { lock_.Lock(); }
@@ skipping 27 matching lines @@
     bool rv = lock_.Try();
     if (rv) {
       CheckUnheldAndMark();
     }
     return rv;
   }
 
   void AssertAcquired() const;
 #endif  // DCHECK_IS_ON()
 
+#if defined(OS_POSIX)
+  // Whether this platform has priority inheritance available. All locks will
+  // attempt to use the priority inheritance version if available.
+  static bool PriorityInheritanceAvailable() {
+    return internal::LockImpl::PriorityInheritanceAvailable();
+  }
+#endif
+
 #if defined(OS_POSIX) || defined(OS_WIN)
   // Both Windows and POSIX implementations of ConditionVariable need to be
   // able to see our lock and tweak our debugging counters, as they release and
   // acquire locks inside of their condition variable APIs.
   friend class ConditionVariable;
 #endif
 
  private:
 #if DCHECK_IS_ON()
   // Members and routines taking care of locks assertions.
@@ skipping 53 matching lines @@
   }
 
  private:
   Lock& lock_;
   DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SYNCHRONIZATION_LOCK_H_