[WTF] Add makeUnique<T>, which ensures T is fast-allocated, makeUnique / makeUniqueWi...
[WebKit-https.git] / Source / WebCore / platform / ThreadGlobalData.cpp
index 6d7eb51..27a7364 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2008, 2014 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *    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 "config.h"
 #include "ThreadGlobalData.h"
 
+#include "CachedResourceRequestInitiators.h"
 #include "EventNames.h"
-#include "ThreadTimers.h"
-#include <wtf/UnusedParam.h>
-#include <wtf/WTFThreadData.h>
-#include <wtf/text/StringImpl.h>
-
-#if USE(ICU_UNICODE)
+#include "QualifiedNameCache.h"
 #include "TextCodecICU.h"
-#endif
-
-#if PLATFORM(MAC)
-#include "TextCodecMac.h"
-#endif
-
-#if ENABLE(WORKERS)
-#include <wtf/Threading.h>
+#include "ThreadTimers.h"
+#include <wtf/MainThread.h>
 #include <wtf/ThreadSpecific.h>
-using namespace WTF;
-#endif
+#include <wtf/Threading.h>
+#include <wtf/text/StringImpl.h>
 
 namespace WebCore {
 
-#if ENABLE(WORKERS)
-ThreadSpecific<ThreadGlobalData>* ThreadGlobalData::staticData;
-#else
-ThreadGlobalData* ThreadGlobalData::staticData;
-#endif
-
 ThreadGlobalData::ThreadGlobalData()
-    : m_eventNames(new EventNames)
-    , m_threadTimers(new ThreadTimers)
+    : m_cachedResourceRequestInitiators(makeUnique<CachedResourceRequestInitiators>())
+    , m_eventNames(EventNames::create())
+    , m_threadTimers(makeUnique<ThreadTimers>())
+    , m_qualifiedNameCache(makeUnique<QualifiedNameCache>())
 #ifndef NDEBUG
     , m_isMainThread(isMainThread())
 #endif
-#if USE(ICU_UNICODE)
-    , m_cachedConverterICU(new ICUConverterWrapper)
-#endif
-#if PLATFORM(MAC)
-    , m_cachedConverterTEC(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() = default;
+
+void ThreadGlobalData::destroy()
+{
+    m_cachedConverterICU = nullptr;
+
+    m_eventNames = nullptr;
+    m_threadTimers = nullptr;
+    m_qualifiedNameCache = nullptr;
 }
 
-ThreadGlobalData::~ThreadGlobalData()
+#if USE(WEB_THREAD)
+static ThreadSpecific<RefPtr<ThreadGlobalData>>* staticData { nullptr };
+static ThreadGlobalData* sharedMainThreadStaticData { nullptr };
+
+void ThreadGlobalData::setWebCoreThreadData()
 {
-    destroy();
+    ASSERT(isWebThread());
+    ASSERT(&threadGlobalData() != sharedMainThreadStaticData);
+
+    // Set WebThread's ThreadGlobalData object to be the same as the main UI thread.
+    **staticData = adoptRef(sharedMainThreadStaticData);
+
+    ASSERT(&threadGlobalData() == sharedMainThreadStaticData);
 }
 
-void ThreadGlobalData::destroy()
+ThreadGlobalData& threadGlobalData()
 {
-#if PLATFORM(MAC)
-    delete m_cachedConverterTEC;
-    m_cachedConverterTEC = 0;
-#endif
+    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()) {
+            sharedMainThreadStaticData = result.get();
+            result->ref();
+        }
+        return *result;
+    }
 
-#if USE(ICU_UNICODE)
-    delete m_cachedConverterICU;
-    m_cachedConverterICU = 0;
-#endif
+    auto& result = **staticData;
+    if (!result)
+        result = adoptRef(new ThreadGlobalData);
+    return *result;
+}
+
+#else
 
-    delete m_eventNames;
-    m_eventNames = 0;
-    delete m_threadTimers;
-    m_threadTimers = 0;
+static ThreadSpecific<ThreadGlobalData>* staticData { nullptr };
+
+ThreadGlobalData& threadGlobalData()
+{
+    if (UNLIKELY(!staticData))
+        staticData = new ThreadSpecific<ThreadGlobalData>;
+    return **staticData;
 }
 
+#endif
+
 } // namespace WebCore