Cheaper thread-safe atomic initialization of static references.

Source/wtf/ArrayBufferContents.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 40 matching lines @@
     // of the caller to make sure JS knows about external memory.
     ArrayBufferContents(void* data, unsigned sizeInBytes, ArrayBufferDeallocationObserver*);
 
     ~ArrayBufferContents();
 
     void clear();
 
     void* data() const { return m_data; }
     unsigned sizeInBytes() const { return m_sizeInBytes; }
 
-    void setDeallocationObserver(ArrayBufferDeallocationObserver* observer)
+    void setDeallocationObserver(ArrayBufferDeallocationObserver& observer)
     {
         if (!m_deallocationObserver) {
-            m_deallocationObserver = observer;
+            m_deallocationObserver = &observer;

[haraken, 2015/01/21 15:23:33]

Do we need m_deallocationObserver? I guess m_deallocationObserver is always
ArrayBufferDeallocationObserver::instance().

[sof, 2015/01/21 15:51:38]

It looks that way; is having a more general interface worthwhile? I can't say,
but I can handle that separately should it not be.

(+Cc: yukishiino)

[haraken, 2015/01/21 16:59:17]

You can handle this in a follow-up either way :)

[Yuki, 2015/01/22 04:27:39]

m_deallocationObserver must always be
**DOM**ArrayBufferDeallocationObserver::instance(), not
ArrayBufferDeallocationObserver::instance().

Since wtf/ArrayBufferContents cannot (directly) depend on
core/dom/DOMArrayBufferDeallocationObserver, we need m_deallocationObserver.

[Yuki, 2015/01/22 04:35:20]

Additional note:
We've made all the DOM objects inherit from ScriptWrappable, so ArrayBuffer.idl
(implemented as core/dom/DOMArrayBuffer) as well.  We no longer need
wtf/ArrayBuffer, so we're planning to remove old wtf/ArrayBuffer family except
for ArrayBufferContents.

wtf/ArrayBufferContents is not a DOM object, and some code (especially
platform/graphics/) need a class which represents a memory block which can be
efficiently converted to DOMArrayBuffer.  So my plan is keep
wtf/ArrayBufferContents as is in wtf/, and let platform/ code use it.

Then, m_deallocationObserver is useful to pass
core/dom/DOMArrayBufferDeallocationObserver to wtf/ArrayBufferContents.

             m_deallocationObserver->blinkAllocatedMemory(m_sizeInBytes);
         }
     }
-    void setDeallocationObserverWithoutAllocationNotification(ArrayBufferDeallocationObserver* observer)
+    void setDeallocationObserverWithoutAllocationNotification(ArrayBufferDeallocationObserver& observer)
     {
         if (!m_deallocationObserver) {
-            m_deallocationObserver = observer;
+            m_deallocationObserver = &observer;
         }
     }
 
     void transfer(ArrayBufferContents& other);
     void copyTo(ArrayBufferContents& other);
 
     static void allocateMemory(size_t, InitializationPolicy, void*&);
     static void freeMemory(void*, size_t);
 
 private:
     void* m_data;
     unsigned m_sizeInBytes;
     ArrayBufferDeallocationObserver* m_deallocationObserver;
 };
 
 } // namespace WTF
 
 #endif // ArrayBufferContents_h