[WTF] Add makeUnique<T>, which ensures T is fast-allocated, makeUnique / makeUniqueWi...
[WebKit-https.git] / Source / WebCore / platform / ThreadGlobalData.cpp
index 57e5158..27a7364 100644 (file)
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
 #include "CachedResourceRequestInitiators.h"
 #include "EventNames.h"
-#include "InspectorCounters.h"
+#include "QualifiedNameCache.h"
 #include "TextCodecICU.h"
 #include "ThreadTimers.h"
 #include <wtf/MainThread.h>
 #include <wtf/ThreadSpecific.h>
 #include <wtf/Threading.h>
-#include <wtf/WTFThreadData.h>
 #include <wtf/text/StringImpl.h>
 
-#if PLATFORM(MAC)
-#include "TextCodeCMac.h"
-#endif
-
-#if ENABLE(WEB_REPLAY)
-#include "ReplayInputTypes.h"
-#endif
-
 namespace WebCore {
 
-ThreadSpecific<ThreadGlobalData>* ThreadGlobalData::staticData;
-#if USE(WEB_THREAD)
-ThreadGlobalData* ThreadGlobalData::sharedMainThreadStaticData;
-#endif
-
 ThreadGlobalData::ThreadGlobalData()
-    : m_cachedResourceRequestInitiators(adoptPtr(new CachedResourceRequestInitiators))
-    , m_eventNames(adoptPtr(new EventNames))
-    , m_threadTimers(adoptPtr(new ThreadTimers))
-#if ENABLE(WEB_REPLAY)
-    , m_inputTypes(std::make_unique<ReplayInputTypes>())
-#endif
+    : m_cachedResourceRequestInitiators(makeUnique<CachedResourceRequestInitiators>())
+    , m_eventNames(EventNames::create())
+    , m_threadTimers(makeUnique<ThreadTimers>())
+    , m_qualifiedNameCache(makeUnique<QualifiedNameCache>())
 #ifndef NDEBUG
     , m_isMainThread(isMainThread())
 #endif
-    , m_cachedConverterICU(adoptPtr(new ICUConverterWrapper))
-#if PLATFORM(MAC)
-    , m_cachedConverterTEC(adoptPtr(new TECConverterWrapper))
-#endif
+    , m_cachedConverterICU(makeUnique<ICUConverterWrapper>())
 {
     // This constructor will have been called on the main thread before being called on
     // any other thread, and is only called once per thread - this makes this a convenient
     // point to call methods that internally perform a one-time initialization that is not
     // threadsafe.
-    wtfThreadData();
-    StringImpl::empty();
+    Thread::current();
 }
 
-ThreadGlobalData::~ThreadGlobalData()
-{
-}
+ThreadGlobalData::~ThreadGlobalData() = default;
 
 void ThreadGlobalData::destroy()
 {
-#if PLATFORM(MAC)
-    m_cachedConverterTEC.clear();
-#endif
-
-    m_cachedConverterICU.clear();
+    m_cachedConverterICU = nullptr;
 
-#if ENABLE(WEB_REPLAY)
-    m_inputTypes = nullptr;
-#endif
-
-    m_eventNames.clear();
-    m_threadTimers.clear();
+    m_eventNames = nullptr;
+    m_threadTimers = nullptr;
+    m_qualifiedNameCache = nullptr;
 }
 
 #if USE(WEB_THREAD)
+static ThreadSpecific<RefPtr<ThreadGlobalData>>* staticData { nullptr };
+static ThreadGlobalData* sharedMainThreadStaticData { nullptr };
+
 void ThreadGlobalData::setWebCoreThreadData()
 {
     ASSERT(isWebThread());
-    ASSERT(&threadGlobalData() != ThreadGlobalData::sharedMainThreadStaticData);
+    ASSERT(&threadGlobalData() != sharedMainThreadStaticData);
 
     // Set WebThread's ThreadGlobalData object to be the same as the main UI thread.
-    ThreadGlobalData::staticData->replace(ThreadGlobalData::sharedMainThreadStaticData);
+    **staticData = adoptRef(sharedMainThreadStaticData);
 
-    ASSERT(&threadGlobalData() == ThreadGlobalData::sharedMainThreadStaticData);
+    ASSERT(&threadGlobalData() == sharedMainThreadStaticData);
 }
-#endif
 
-ThreadGlobalData& threadGlobalData() 
+ThreadGlobalData& threadGlobalData()
 {
-#if USE(WEB_THREAD)
-    if (UNLIKELY(!ThreadGlobalData::staticData)) {
-        ThreadGlobalData::staticData = new ThreadSpecific<ThreadGlobalData>;
+    if (UNLIKELY(!staticData)) {
+        staticData = new ThreadSpecific<RefPtr<ThreadGlobalData>>;
+        auto& result = **staticData;
+        ASSERT(!result);
+        result = adoptRef(new ThreadGlobalData);
         // WebThread and main UI thread need to share the same object. Save it in a static
         // here, the WebThread will pick it up in setWebCoreThreadData().
-        if (pthread_main_np())
-            ThreadGlobalData::sharedMainThreadStaticData = *ThreadGlobalData::staticData;
+        if (pthread_main_np()) {
+            sharedMainThreadStaticData = result.get();
+            result->ref();
+        }
+        return *result;
     }
-    return **ThreadGlobalData::staticData;
+
+    auto& result = **staticData;
+    if (!result)
+        result = adoptRef(new ThreadGlobalData);
+    return *result;
+}
+
 #else
-    if (!ThreadGlobalData::staticData)
-        ThreadGlobalData::staticData = new ThreadSpecific<ThreadGlobalData>;
-    return **ThreadGlobalData::staticData;
-#endif
+
+static ThreadSpecific<ThreadGlobalData>* staticData { nullptr };
+
+ThreadGlobalData& threadGlobalData()
+{
+    if (UNLIKELY(!staticData))
+        staticData = new ThreadSpecific<ThreadGlobalData>;
+    return **staticData;
 }
 
+#endif
+
 } // namespace WebCore