Hold global GC heap lock while making audio thread access.

third_party/WebKit/Source/platform/heap/PersistentNode.h

 // 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.
 
 #ifndef PersistentNode_h
 #define PersistentNode_h
 
 #include <memory>
 #include "platform/PlatformExport.h"
 #include "platform/heap/ThreadState.h"
@@ skipping 184 matching lines @@
     if (!persistent_node)
       return;
     persistent_region_->FreePersistentNode(persistent_node);
     ReleaseStore(reinterpret_cast<void* volatile*>(&persistent_node), nullptr);
   }
 
   class LockScope final {
     STACK_ALLOCATED();
 
    public:
-    LockScope(CrossThreadPersistentRegion& persistent_region)
-        : persistent_region_(persistent_region) {
-      persistent_region_.lock();
+    LockScope(CrossThreadPersistentRegion& persistent_region,
+              bool try_lock = false)
+        : persistent_region_(persistent_region), locked_(true) {
+      if (try_lock)
+        locked_ = persistent_region_.TryLock();
+      else
+        persistent_region_.lock();
     }
-    ~LockScope() { persistent_region_.unlock(); }
+    ~LockScope() {
+      if (locked_)
+        persistent_region_.unlock();
+    }
+
+    // If the lock scope is set up with |try_lock| set to |true|, caller/user
+    // is responsible for checking whether the GC lock was taken via
+    // |HasLock()|.
+    bool HasLock() const { return locked_; }
 
    private:
     CrossThreadPersistentRegion& persistent_region_;
+    bool locked_;
   };
 
   void TracePersistentNodes(Visitor* visitor) {
 // If this assert triggers, you're tracing without being in a LockScope.
 #if DCHECK_IS_ON()
     DCHECK(mutex_.Locked());
 #endif
     persistent_region_->TracePersistentNodes(
         visitor, CrossThreadPersistentRegion::ShouldTracePersistentNode);
   }
 
   void PrepareForThreadStateTermination(ThreadState*);
 
   NO_SANITIZE_ADDRESS
   static bool ShouldTracePersistentNode(Visitor*, PersistentNode*);
 
 #if defined(ADDRESS_SANITIZER)
   void UnpoisonCrossThreadPersistents();
 #endif
 
  private:
   friend class LockScope;
 
   void lock() { mutex_.lock(); }
 
   void unlock() { mutex_.unlock(); }
 
+  bool TryLock() { return mutex_.TryLock(); }
+
   // We don't make CrossThreadPersistentRegion inherit from PersistentRegion
   // because we don't want to virtualize performance-sensitive methods
   // such as PersistentRegion::allocate/freePersistentNode.
   std::unique_ptr<PersistentRegion> persistent_region_;
 
   // Recursive as prepareForThreadStateTermination() clears a PersistentNode's
   // associated Persistent<> -- it in turn freeing the PersistentNode. And both
   // CrossThreadPersistentRegion operations need a lock on the region before
   // mutating.
   RecursiveMutex mutex_;
 };
 
 }  // namespace blink
 
 #endif