Cheaper thread-safe atomic initialization of static references.

Source/platform/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 4760 matching lines @@
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1u, map->size());
     EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
     lifeObject.clear(); // Despite its name.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, map->size());
 }
 
 static Mutex& mainThreadMutex()
 {
-    AtomicallyInitializedStatic(Mutex&, mainMutex = *new Mutex);
+    AtomicallyInitializedStaticReference(Mutex, mainMutex, new Mutex);
     return mainMutex;
 }
 
 static ThreadCondition& mainThreadCondition()
 {
-    AtomicallyInitializedStatic(ThreadCondition&, mainCondition = *new ThreadCondition);
+    AtomicallyInitializedStaticReference(ThreadCondition, mainCondition, new ThreadCondition);
     return mainCondition;
 }
 
 static void parkMainThread()
 {
     mainThreadCondition().wait(mainThreadMutex());
 }
 
 static void wakeMainThread()
 {
     MutexLocker locker(mainThreadMutex());
     mainThreadCondition().signal();
 }
 
 static Mutex& workerThreadMutex()
 {
-    AtomicallyInitializedStatic(Mutex&, workerMutex = *new Mutex);
+    AtomicallyInitializedStaticReference(Mutex, workerMutex, new Mutex);
     return workerMutex;
 }
 
 static ThreadCondition& workerThreadCondition()
 {
-    AtomicallyInitializedStatic(ThreadCondition&, workerCondition = *new ThreadCondition);
+    AtomicallyInitializedStaticReference(ThreadCondition, workerCondition, new ThreadCondition);
     return workerCondition;
 }
 
 static void parkWorkerThread()
 {
     workerThreadCondition().wait(workerThreadMutex());
 }
 
 static void wakeWorkerThread()
 {
@@ skipping 255 matching lines @@
 // Passes if it doesn't crash.
 TEST(HeapTest, GarbageCollectionDuringMixinConstruction)
 {
     ClassWithGarbageCollectingMixinConstructor* a =
         new ClassWithGarbageCollectingMixinConstructor();
     a->verify();
 }
 
 static RecursiveMutex& recursiveMutex()
 {
-    AtomicallyInitializedStatic(RecursiveMutex&, recursiveMutex = *new RecursiveMutex);
+    AtomicallyInitializedStaticReference(RecursiveMutex, recursiveMutex, new RecursiveMutex);
     return recursiveMutex;
 }
 
 class DestructorLockingObject : public GarbageCollectedFinalized<DestructorLockingObject> {
 public:
     static DestructorLockingObject* create()
     {
         return new DestructorLockingObject();
     }
 
@@ skipping 435 matching lines @@
     // re-adjusting both start&end indices in terms of that expanded buffer.
     EXPECT_EQ(80u, deque->size());
     i = 0;
     for (const auto& intWrapper : *deque) {
         EXPECT_EQ(i + 50, intWrapper->value());
         i++;
     }
 }
 
 } // namespace blink