1 files changed, 0 insertions, 239 deletions
diff --git a/src/javascript/jsc/bindings/ExceptionOr.h b/src/javascript/jsc/bindings/ExceptionOr.h
deleted file mode 100644
index f3378466e..000000000
--- a/src/javascript/jsc/bindings/ExceptionOr.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
-
-Copyright (C) 2016-2017 Apple 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
-    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 INC. AND ITS CONTRIBUTORS ``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 INC. OR ITS 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 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#pragma once
-
-#include "root.h"
-
-#include "Exception.h"
-#include "wtf/CrossThreadCopier.h"
-#include "wtf/Expected.h"
-#include "wtf/StdLibExtras.h"
-
-namespace WebCore {
-
-template<typename T> class ExceptionOr {
-public:
-    using ReturnType = T;
-
-    ExceptionOr(Exception&&);
-    ExceptionOr(ReturnType&&);
-    template<typename OtherType> ExceptionOr(const OtherType&, typename std::enable_if<std::is_scalar<OtherType>::value && std::is_convertible<OtherType, ReturnType>::value>::type* = nullptr);
-
-    bool hasException() const;
-    const Exception& exception() const;
-    Exception releaseException();
-    const ReturnType& returnValue() const;
-    ReturnType releaseReturnValue();
-
-private:
-    Expected<ReturnType, Exception> m_value;
-#if ASSERT_ENABLED
-    bool m_wasReleased { false };
-#endif
-};
-
-template<typename T> class ExceptionOr<T&> {
-public:
-    using ReturnType = T&;
-    using ReturnReferenceType = T;
-
-    ExceptionOr(Exception&&);
-    ExceptionOr(ReturnReferenceType&);
-
-    bool hasException() const;
-    const Exception& exception() const;
-    Exception releaseException();
-    const ReturnReferenceType& returnValue() const;
-    ReturnReferenceType& releaseReturnValue();
-
-private:
-    ExceptionOr<ReturnReferenceType*> m_value;
-};
-
-template<> class ExceptionOr<void> {
-public:
-    using ReturnType = void;
-
-    ExceptionOr(Exception&&);
-    ExceptionOr() = default;
-
-    bool hasException() const;
-    const Exception& exception() const;
-    Exception releaseException();
-
-private:
-    Expected<void, Exception> m_value;
-#if ASSERT_ENABLED
-    bool m_wasReleased { false };
-#endif
-};
-
-ExceptionOr<void> isolatedCopy(ExceptionOr<void>&&);
-
-template<typename ReturnType> inline ExceptionOr<ReturnType>::ExceptionOr(Exception&& exception)
-    : m_value(makeUnexpected(WTFMove(exception)))
-{
-}
-
-template<typename ReturnType> inline ExceptionOr<ReturnType>::ExceptionOr(ReturnType&& returnValue)
-    : m_value(WTFMove(returnValue))
-{
-}
-
-template<typename ReturnType> template<typename OtherType> inline ExceptionOr<ReturnType>::ExceptionOr(const OtherType& returnValue, typename std::enable_if<std::is_scalar<OtherType>::value && std::is_convertible<OtherType, ReturnType>::value>::type*)
-    : m_value(static_cast<ReturnType>(returnValue))
-{
-}
-
-template<typename ReturnType> inline bool ExceptionOr<ReturnType>::hasException() const
-{
-    return !m_value.has_value();
-}
-
-template<typename ReturnType> inline const Exception& ExceptionOr<ReturnType>::exception() const
-{
-    ASSERT(!m_wasReleased);
-    return m_value.error();
-}
-
-template<typename ReturnType> inline Exception ExceptionOr<ReturnType>::releaseException()
-{
-    ASSERT(!std::exchange(m_wasReleased, true));
-    return WTFMove(m_value.error());
-}
-
-template<typename ReturnType> inline const ReturnType& ExceptionOr<ReturnType>::returnValue() const
-{
-    ASSERT(!m_wasReleased);
-    return m_value.value();
-}
-
-template<typename ReturnType> inline ReturnType ExceptionOr<ReturnType>::releaseReturnValue()
-{
-    ASSERT(!std::exchange(m_wasReleased, true));
-    return WTFMove(m_value.value());
-}
-
-template<typename ReturnReferenceType> inline ExceptionOr<ReturnReferenceType&>::ExceptionOr(Exception&& exception)
-    : m_value(WTFMove(exception))
-{
-}
-
-template<typename ReturnReferenceType> inline ExceptionOr<ReturnReferenceType&>::ExceptionOr(ReturnReferenceType& returnValue)
-    : m_value(&returnValue)
-{
-}
-
-template<typename ReturnReferenceType> inline bool ExceptionOr<ReturnReferenceType&>::hasException() const
-{
-    return m_value.hasException();
-}
-
-template<typename ReturnReferenceType> inline const Exception& ExceptionOr<ReturnReferenceType&>::exception() const
-{
-    return m_value.exception();
-}
-
-template<typename ReturnReferenceType> inline Exception ExceptionOr<ReturnReferenceType&>::releaseException()
-{
-    return m_value.releaseException();
-}
-
-template<typename ReturnReferenceType> inline const ReturnReferenceType& ExceptionOr<ReturnReferenceType&>::returnValue() const
-{
-    return *m_value.returnValue();
-}
-
-template<typename ReturnReferenceType> inline ReturnReferenceType& ExceptionOr<ReturnReferenceType&>::releaseReturnValue()
-{
-    return *m_value.releaseReturnValue();
-}
-
-inline ExceptionOr<void>::ExceptionOr(Exception&& exception)
-    : m_value(makeUnexpected(WTFMove(exception)))
-{
-}
-
-inline bool ExceptionOr<void>::hasException() const
-{
-    return !m_value.has_value();
-}
-
-inline const Exception& ExceptionOr<void>::exception() const
-{
-    ASSERT(!m_wasReleased);
-    return m_value.error();
-}
-
-inline Exception ExceptionOr<void>::releaseException()
-{
-    ASSERT(!std::exchange(m_wasReleased, true));
-    return WTFMove(m_value.error());
-}
-
-inline ExceptionOr<void> isolatedCopy(ExceptionOr<void>&& value)
-{
-    if (value.hasException())
-        return isolatedCopy(value.releaseException());
-    return {};
-}
-
-template<typename T> inline constexpr bool IsExceptionOr = WTF::IsTemplate<std::decay_t<T>, ExceptionOr>::value;
-
-template<typename T, bool isExceptionOr = IsExceptionOr<T>> struct TypeOrExceptionOrUnderlyingTypeImpl;
-template<typename T> struct TypeOrExceptionOrUnderlyingTypeImpl<T, true> {
-    using Type = typename T::ReturnType;
-};
-template<typename T> struct TypeOrExceptionOrUnderlyingTypeImpl<T, false> {
-    using Type = T;
-};
-template<typename T> using TypeOrExceptionOrUnderlyingType = typename TypeOrExceptionOrUnderlyingTypeImpl<T>::Type;
-
-}
-
-namespace WTF {
-template<typename T> struct CrossThreadCopierBase<false, false, WebCore::ExceptionOr<T>> {
-    typedef WebCore::ExceptionOr<T> Type;
-    static Type copy(const Type& source)
-    {
-        if (source.hasException())
-            return crossThreadCopy(source.exception());
-        return crossThreadCopy(source.returnValue());
-    }
-};
-
-template<> struct CrossThreadCopierBase<false, false, WebCore::ExceptionOr<void>> {
-    typedef WebCore::ExceptionOr<void> Type;
-    static Type copy(const Type& source)
-    {
-        if (source.hasException())
-            return crossThreadCopy(source.exception());
-        return {};
-    }
-};
-
-}