Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/mojo/edk/system/mutex.h

Index: third_party/mojo/src/mojo/edk/system/mutex.h
diff --git a/third_party/mojo/src/mojo/edk/system/mutex.h b/third_party/mojo/src/mojo/edk/system/mutex.h
new file mode 100644
index 0000000000000000000000000000000000000000..acb410aafef6733afe5e36d0bf79d312e10d973d
--- /dev/null
+++ b/third_party/mojo/src/mojo/edk/system/mutex.h
@@ -0,0 +1,93 @@
+// Copyright 2015 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.
+
+// A mutex class, with support for thread annotations.
+//
+// TODO(vtl): Currently, this is a fork of Chromium's
+// base/synchronization/lock.h (with names changed and minor modifications; it
+// still cheats and uses Chromium's lock_impl.*), but eventually we'll want our
+// own and, e.g., add support for non-exclusive (reader) locks.
+
+#ifndef MOJO_EDK_SYSTEM_MUTEX_H_
+#define MOJO_EDK_SYSTEM_MUTEX_H_
+
+#include "base/synchronization/lock_impl.h"
+#include "base/threading/platform_thread.h"
+#include "mojo/edk/system/system_impl_export.h"
+#include "mojo/edk/system/thread_annotations.h"
+#include "mojo/public/cpp/system/macros.h"
+
+namespace mojo {
+namespace system {
+
+// Mutex -----------------------------------------------------------------------
+
+class MOJO_SYSTEM_IMPL_EXPORT MOJO_LOCKABLE Mutex {

[hans, 2015/08/24 20:44:14]

This is failing to compile with Clang on Windows:

FAILED: ninja -t msvc -e environment.x86 --
"..\..\third_party/llvm-build/Release+Asserts/bin/clang-cl" -m32 /nologo
/showIncludes /FC
@obj\third_party\mojo\src\mojo\edk\embedder\mojo_system_impl.entrypoints.obj.rsp
/c ..\..\third_party\mojo\src\mojo\edk\embedder\entrypoints.cc
/Foobj\third_party\mojo\src\mojo\edk\embedder\mojo_system_impl.entrypoints.obj
/Fdobj\third_party\mojo\mojo_system_impl.cc.pdb 
In file included from
..\..\third_party\mojo\src\mojo\edk\embedder\entrypoints.cc:6:
In file included from ..\..\third_party\mojo\src\mojo/edk/system/core.h:16:
..\..\third_party\mojo\src\mojo/edk/system/mutex.h(26,1) :  error: declaration
of anonymous class must be a definition
class MOJO_SYSTEM_IMPL_EXPORT MOJO_LOCKABLE Mutex {
^
..\..\third_party\mojo\src\mojo/edk/system/mutex.h(26,1) :  error: declaration
does not declare anything [-Werror,-Wmissing-declarations]
class MOJO_SYSTEM_IMPL_EXPORT MOJO_LOCKABLE Mutex {
^
..\..\third_party\mojo\src\mojo/edk/system/mutex.h(76,1) :  error: declaration
of anonymous class must be a definition
class MOJO_SYSTEM_IMPL_EXPORT MOJO_SCOPED_LOCKABLE MutexLocker {
^
..\..\third_party\mojo\src\mojo/edk/system/mutex.h(76,1) :  error: declaration
does not declare anything [-Werror,-Wmissing-declarations]
class MOJO_SYSTEM_IMPL_EXPORT MOJO_SCOPED_LOCKABLE MutexLocker {
^

... and more errors further on as Mutex isn't recognized as a type.


The error message isn't so great, but what's happening is that after macro
expansion, we have:

  class __declspec(dllexport) __attribute__((lockable)) Mutex { };

Mixing declspec and GNU attributes is slightly sketchy territory, but Clang will
actually handle this if they're in the other order. I'll have a look and see
what it would take to fix this or if we'll need to revert.

(Clang bug for handling this better:
https://llvm.org/bugs/show_bug.cgi?id=24559)

+ public:
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+  Mutex() : lock_() {}
+  ~Mutex() {}
+
+  void Lock() MOJO_EXCLUSIVE_LOCK_FUNCTION() { lock_.Lock(); }
+  void Unlock() MOJO_UNLOCK_FUNCTION() { lock_.Unlock(); }
+
+  bool TryLock() MOJO_EXCLUSIVE_TRYLOCK_FUNCTION(true) { return lock_.Try(); }
+
+  void AssertHeld() const MOJO_ASSERT_EXCLUSIVE_LOCK() {}
+#else
+  Mutex();
+  ~Mutex();
+
+  void Lock() MOJO_EXCLUSIVE_LOCK_FUNCTION() {
+    lock_.Lock();
+    CheckUnheldAndMark();
+  }
+  void Unlock() MOJO_UNLOCK_FUNCTION() {
+    CheckHeldAndUnmark();
+    lock_.Unlock();
+  }
+
+  bool TryLock() MOJO_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    bool rv = lock_.Try();
+    if (rv)
+      CheckUnheldAndMark();
+    return rv;
+  }
+
+  void AssertHeld() const MOJO_ASSERT_EXCLUSIVE_LOCK();
+#endif  // NDEBUG && !DCHECK_ALWAYS_ON
+
+ private:
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+  void CheckHeldAndUnmark();
+  void CheckUnheldAndMark();
+
+  base::PlatformThreadRef owning_thread_ref_;
+#endif  // !NDEBUG || DCHECK_ALWAYS_ON
+
+  base::internal::LockImpl lock_;
+
+  MOJO_DISALLOW_COPY_AND_ASSIGN(Mutex);
+};
+
+// MutexLocker -----------------------------------------------------------------
+
+class MOJO_SYSTEM_IMPL_EXPORT MOJO_SCOPED_LOCKABLE MutexLocker {
+ public:
+  explicit MutexLocker(Mutex* mutex) MOJO_EXCLUSIVE_LOCK_FUNCTION(mutex)
+      : mutex_(mutex) {
+    this->mutex_->Lock();
+  }
+  ~MutexLocker() MOJO_UNLOCK_FUNCTION() { this->mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  MOJO_DISALLOW_COPY_AND_ASSIGN(MutexLocker);
+};
+
+}  // namespace system
+}  // namespace mojo
+
+#endif  // MOJO_EDK_SYSTEM_MUTEX_H_