Attachment #349336 for bug #189277

View Details Raw Unified Return to Bug 189277

| Differences between



2018-09-08  Jiewen Tan  <jiewen_tan@apple.com>

        [WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=189277
        <rdar://problem/44115936>

        Reviewed by Chris Dumez.

        This patch aims to polish AuthenticatorManager such that:
        1) It is no longer a singleton. Instead, it will live with Page. It was a singleton simply because static
        PublicKeyCredential::isUserVerifyingPlatformAuthenticatorAvailable() have to access it. However, this request
        can be fulfilled by adding an attribute [CallWith=Document] to the IDL defination. Therefore, there is no
        such need. Also, the singleton is illy implemented as it owns a single IPC proxy to UI Process which means
        different web pages will talk to the same web page proxy. Anyway, making it live with Page should fix everything.
        2) Since we are now planning to support external authenticators, the manager of all authenticators will then
        have to live in UI Process which makes this AuthenticatorManager obsolete. Instead, rename it to AuthenticatorCoordinator.
        3) Rename CredentialsMessenger to AuthenticatorCoordinatorClient to tight it to WebAuthN. Also, simplify the
        message reply model as PublicKeyCredentialCreationOptions/PublicKeyCredentialRequestOptions =>
        ExceptionData/PublicKeyCredentialData for makeCredential/getAssertion operations.
        4) Restrict one request per time, i.e. makeCredential/getAssertion for a single page.
        5) Unifying makeCredentialReply/getAssertionReply/exceptionReply into requestReply for IPC. Correspondingly,
        unify callback and exceptionCallback into callback as well for LocalAuthenticator.
        6) Enhance PublicKeyCredentialCreationOptions encoding/decoding with encoder.encodeFixedLengthData/decoder.decodeFixedLengthData.

        Covered by existing tests.

        * DerivedSources.make:
        * Modules/credentialmanagement/CredentialsContainer.cpp:
        (WebCore::CredentialsContainer::get):
        (WebCore::CredentialsContainer::isCreate):
        * Modules/credentialmanagement/CredentialsContainer.h:
        * Modules/credentialmanagement/CredentialsMessenger.cpp: Removed.
        * Modules/credentialmanagement/CredentialsMessenger.h: Removed.
        * Modules/webauthn/AuthenticatorAssertionResponse.cpp: Removed.
        * Modules/webauthn/AuthenticatorAssertionResponse.h:
        (WebCore::AuthenticatorAssertionResponse::create):
        (WebCore::AuthenticatorAssertionResponse::authenticatorData const):
        (WebCore::AuthenticatorAssertionResponse::signature const):
        (WebCore::AuthenticatorAssertionResponse::userHandle const):
        (WebCore::AuthenticatorAssertionResponse::AuthenticatorAssertionResponse):
        * Modules/webauthn/AuthenticatorAttestationResponse.cpp: Removed.
        * Modules/webauthn/AuthenticatorAttestationResponse.h:
        (WebCore::AuthenticatorAttestationResponse::create):
        (WebCore::AuthenticatorAttestationResponse::attestationObject const):
        (WebCore::AuthenticatorAttestationResponse::AuthenticatorAttestationResponse):
        * Modules/webauthn/AuthenticatorCoordinator.cpp: Renamed from Source/WebCore/Modules/webauthn/AuthenticatorManager.cpp.
        (WebCore::AuthenticatorCoordinatorInternal::produceClientDataJson):
        (WebCore::AuthenticatorCoordinatorInternal::produceClientDataJsonHash):
        (WebCore::AuthenticatorCoordinatorInternal::initTimeoutTimer):
        (WebCore::AuthenticatorCoordinatorInternal::didTimeoutTimerFire):
        (WebCore::AuthenticatorCoordinator::AuthenticatorCoordinator):
        (WebCore::AuthenticatorCoordinator::setClient):
        (WebCore::AuthenticatorCoordinator::create const):
        (WebCore::AuthenticatorCoordinator::discoverFromExternalSource const):
        (WebCore::AuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable const):
        * Modules/webauthn/AuthenticatorCoordinator.h: Renamed from Source/WebCore/Modules/webauthn/AuthenticatorManager.h.
        * Modules/webauthn/AuthenticatorCoordinatorClient.cpp: Added.
        (WebCore::AuthenticatorCoordinatorClient::~AuthenticatorCoordinatorClient):
        (WebCore::AuthenticatorCoordinatorClient::requestReply):
        (WebCore::AuthenticatorCoordinatorClient::isUserVerifyingPlatformAuthenticatorAvailableReply):
        (WebCore::AuthenticatorCoordinatorClient::setRequestCompletionHandler):
        (WebCore::AuthenticatorCoordinatorClient::addQueryCompletionHandler):
        * Modules/webauthn/AuthenticatorCoordinatorClient.h: Copied from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.h.
        * Modules/webauthn/AuthenticatorResponse.cpp: Removed.
        * Modules/webauthn/AuthenticatorResponse.h:
        (WebCore::AuthenticatorResponse::AuthenticatorResponse):
        (WebCore::AuthenticatorResponse::clientDataJSON const):
        * Modules/webauthn/PublicKeyCredential.cpp:
        (WebCore::PublicKeyCredential::create):
        (WebCore::PublicKeyCredential::tryCreate):
        (WebCore::PublicKeyCredential::PublicKeyCredential):
        (WebCore::PublicKeyCredential::isUserVerifyingPlatformAuthenticatorAvailable):
        * Modules/webauthn/PublicKeyCredential.h:
        * Modules/webauthn/PublicKeyCredential.idl:
        * Modules/webauthn/PublicKeyCredentialCreationOptions.h:
        (WebCore::PublicKeyCredentialCreationOptions::encode const):
        (WebCore::PublicKeyCredentialCreationOptions::decode):
        * Modules/webauthn/PublicKeyCredentialData.h: Added.
        (WebCore::PublicKeyCredentialData::encode const):
        (WebCore::PublicKeyCredentialData::decode):
        * Modules/webauthn/cocoa/LocalAuthenticator.h:
        * Modules/webauthn/cocoa/LocalAuthenticator.mm:
        (WebCore::LocalAuthenticator::makeCredential):
        (WebCore::LocalAuthenticator::getAssertion):
        * Sources.txt:
        * WebCore.xcodeproj/project.pbxproj:
        * page/Page.cpp:
        * page/Page.h:
        (WebCore::Page::authenticatorCoordinator const):
        * page/PageConfiguration.cpp:
        * page/PageConfiguration.h:
        * testing/Internals.cpp:
        (WebCore::Internals::Internals):
        (WebCore::Internals::mockAuthenticatorCoordinator const):
        (WebCore::Internals::mockCredentialsMessenger const): Deleted.
        * testing/Internals.h:
        * testing/Internals.idl:
        * testing/MockAuthenticatorCoordinator.cpp: Added.
        (WebCore::MockAuthenticatorCoordinator::setCreationReturnBundle):
        (WebCore::MockAuthenticatorCoordinator::setAssertionReturnBundle):
        (WebCore::MockAuthenticatorCoordinator::makeCredential):
        (WebCore::MockAuthenticatorCoordinator::getAssertion):
        (WebCore::MockAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable):
        * testing/MockAuthenticatorCoordinator.h: Renamed from Source/WebCore/testing/MockCredentialsMessenger.h.
        * testing/MockAuthenticatorCoordinator.idl: Renamed from Source/WebCore/testing/MockCredentialsMessenger.idl.
        * testing/MockCredentialsMessenger.cpp: Removed.

2018-09-08  Andy Estes  <aestes@apple.com>

        [Apple Pay] Dispatch a paymentmethodchange event when the payment method changes



2018-09-08  Jiewen Tan  <jiewen_tan@apple.com>

        [WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=189277
        <rdar://problem/44115936>

        Reviewed by Chris Dumez.

        * DerivedSources.make:
        * SourcesCocoa.txt:
        * UIProcess/CredentialManagement/WebCredentialsMessengerProxy.cpp: Removed.
        * UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp: Added.
        (WebKit::WebAuthenticatorCoordinatorProxy::WebAuthenticatorCoordinatorProxy):
        (WebKit::WebAuthenticatorCoordinatorProxy::~WebAuthenticatorCoordinatorProxy):
        (WebKit::WebAuthenticatorCoordinatorProxy::makeCredential):
        (WebKit::WebAuthenticatorCoordinatorProxy::getAssertion):
        (WebKit::WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailable):
        (WebKit::WebAuthenticatorCoordinatorProxy::requestReply):
        (WebKit::WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailableReply):
        * UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.h: Renamed from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.h.
        * UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.messages.in: Renamed from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.messages.in.
        * UIProcess/WebPageProxy.cpp:
        (WebKit::m_resetRecentCrashCountTimer):
        (WebKit::WebPageProxy::reattachToWebProcess):
        * UIProcess/WebPageProxy.h:
        * WebKit.xcodeproj/project.pbxproj:
        * WebProcess/CredentialManagement/WebCredentialsMessenger.cpp: Removed.
        * WebProcess/WebAuthentication/WebAuthenticatorCoordinator.cpp: Added.
        (WebKit::WebAuthenticatorCoordinator::WebAuthenticatorCoordinator):
        (WebKit::WebAuthenticatorCoordinator::~WebAuthenticatorCoordinator):
        (WebKit::WebAuthenticatorCoordinator::makeCredential):
        (WebKit::WebAuthenticatorCoordinator::getAssertion):
        (WebKit::WebAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable):
        * WebProcess/WebAuthentication/WebAuthenticatorCoordinator.h: Renamed from Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.h.
        * WebProcess/WebAuthentication/WebAuthenticatorCoordinator.messages.in: Renamed from Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.messages.in.
        * WebProcess/WebPage/WebPage.cpp:
        (WebKit::m_cpuLimit):
        (WebKit::m_credentialsMessenger): Deleted.
        * WebProcess/WebPage/WebPage.h:

2018-09-08  Tim Horton  <timothy_horton@apple.com>

        Unify most of the WebKit Objective-C API sources



    $(WebCore)/testing/Internals.idl \
    $(WebCore)/testing/MallocStatistics.idl \
    $(WebCore)/testing/MemoryInfo.idl \
    $(WebCore)/testing/MockAuthenticatorCoordinator.idl \
    $(WebCore)/testing/MockCDMFactory.idl \
    $(WebCore)/testing/MockContentFilterSettings.idl \
    $(WebCore)/testing/MockCredentialsMessenger.idl \
    $(WebCore)/testing/MockPageOverlay.idl \
    $(WebCore)/testing/MockPaymentAddress.idl \
    $(WebCore)/testing/MockPaymentCoordinator.idl \



#include "Document.h"
#include "ExceptionOr.h"
#include "JSDOMPromiseDeferred.h"
#include "Page.h"
#include "SecurityOrigin.h"

namespace WebCore {

{
    // The following implements https://www.w3.org/TR/credential-management-1/#algorithm-request as of 4 August 2017
    // with enhancement from 14 November 2017 Editor's Draft.
    if (!m_document || !m_document->page()) {
        promise.reject(Exception { NotSupportedError });
        return;
    }

        return;
    }

    m_document->page()->authenticatorCoordinator().discoverFromExternalSource(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
    AuthenticatorManager::singleton().discoverFromExternalSource(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
}

void CredentialsContainer::store(const BasicCredential&, CredentialPromise&& promise)

{
    // The following implements https://www.w3.org/TR/credential-management-1/#algorithm-create as of 4 August 2017
    // with enhancement from 14 November 2017 Editor's Draft.
    if (!m_document || !m_document->page()) {
        promise.reject(Exception { NotSupportedError });
        return;
    }

        return;
    }

    m_document->page()->authenticatorCoordinator().create(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
    AuthenticatorManager::singleton().create(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
}

void CredentialsContainer::preventSilentAccess(DOMPromiseDeferred<void>&& promise) const

Lines 28-34 a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.h_sec1
- a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.h -1 / +1 lines
28		28
29	#if ENABLE(WEB_AUTHN)	29	#if ENABLE(WEB_AUTHN)
30		30
31	#include "AuthenticatorManager.h"	31	#include "AuthenticatorCoordinator.h"
32	#include <wtf/RefCounted.h>	32	#include <wtf/RefCounted.h>
33	#include <wtf/WeakPtr.h>	33	#include <wtf/WeakPtr.h>
34		34



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "CredentialsMessenger.h"

#if ENABLE(WEB_AUTHN)

namespace WebCore {

namespace CredentialsMessengerInternal {

const uint64_t maxMessageId = 0xFFFFFFFFFFFFFF; // 56 bits
const size_t callBackClassifierOffset = 56;

}

void CredentialsMessenger::exceptionReply(uint64_t messageId, const ExceptionData& exception)
{
    using namespace CredentialsMessengerInternal;

    if (!(messageId >> callBackClassifierOffset ^ CallBackClassifier::Creation)) {
        auto handler = takeCreationCompletionHandler(messageId);
        handler(exception.toException());
        return;
    }
    if (!(messageId >> callBackClassifierOffset ^ CallBackClassifier::Request)) {
        auto handler = takeRequestCompletionHandler(messageId);
        handler(exception.toException());
        return;
    }
}

uint64_t CredentialsMessenger::addCreationCompletionHandler(CreationCompletionHandler&& handler)
{
    using namespace CredentialsMessengerInternal;

    uint64_t messageId = m_accumulatedMessageId++;
    ASSERT(messageId <= maxMessageId);
    messageId = messageId | CallBackClassifier::Creation << callBackClassifierOffset;
    auto addResult = m_pendingCreationCompletionHandlers.add(messageId, WTFMove(handler));
    ASSERT_UNUSED(addResult, addResult.isNewEntry);
    return messageId;
}

CreationCompletionHandler CredentialsMessenger::takeCreationCompletionHandler(uint64_t messageId)
{
    return m_pendingCreationCompletionHandlers.take(messageId);
}

uint64_t CredentialsMessenger::addRequestCompletionHandler(RequestCompletionHandler&& handler)
{
    using namespace CredentialsMessengerInternal;

    uint64_t messageId = m_accumulatedMessageId++;
    ASSERT(messageId <= maxMessageId);
    messageId = messageId | CallBackClassifier::Request << callBackClassifierOffset;
    auto addResult = m_pendingRequestCompletionHandlers.add(messageId, WTFMove(handler));
    ASSERT_UNUSED(addResult, addResult.isNewEntry);
    return messageId;
}

RequestCompletionHandler CredentialsMessenger::takeRequestCompletionHandler(uint64_t messageId)
{
    return m_pendingRequestCompletionHandlers.take(messageId);
}

uint64_t CredentialsMessenger::addQueryCompletionHandler(QueryCompletionHandler&& handler)
{
    using namespace CredentialsMessengerInternal;

    uint64_t messageId = m_accumulatedMessageId++;
    ASSERT(messageId < maxMessageId);
    messageId = messageId | CallBackClassifier::Query << callBackClassifierOffset;
    auto addResult = m_pendingQueryCompletionHandlers.add(messageId, WTFMove(handler));
    ASSERT_UNUSED(addResult, addResult.isNewEntry);
    return messageId;
}

QueryCompletionHandler CredentialsMessenger::takeQueryCompletionHandler(uint64_t messageId)
{
    return m_pendingQueryCompletionHandlers.take(messageId);
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "ExceptionData.h"
#include "ExceptionOr.h"
#include <JavaScriptCore/ArrayBuffer.h>
#include <wtf/CompletionHandler.h>
#include <wtf/HashMap.h>
#include <wtf/WeakPtr.h>

namespace WebCore {

class DeferredPromise;

struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialRequestOptions;

struct CreationReturnBundle {
    CreationReturnBundle(Ref<ArrayBuffer>&& credentialId, Ref<ArrayBuffer>&& attestationObject)
        : credentialId(WTFMove(credentialId))
        , attestationObject(WTFMove(attestationObject))
    {
    }

    Ref<ArrayBuffer> credentialId;
    Ref<ArrayBuffer> attestationObject;
};
struct AssertionReturnBundle {
    AssertionReturnBundle(Ref<ArrayBuffer>&& credentialId, Ref<ArrayBuffer>&& authenticatorData, Ref<ArrayBuffer>&& signature, Ref<ArrayBuffer>&& userHandle)
        : credentialId(WTFMove(credentialId))
        , authenticatorData(WTFMove(authenticatorData))
        , signature(WTFMove(signature))
        , userHandle(WTFMove(userHandle))
    {
    }

    Ref<ArrayBuffer> credentialId;
    Ref<ArrayBuffer> authenticatorData;
    Ref<ArrayBuffer> signature;
    Ref<ArrayBuffer> userHandle;
};

using CreationCompletionHandler = CompletionHandler<void(ExceptionOr<CreationReturnBundle>&&)>;
using RequestCompletionHandler = CompletionHandler<void(ExceptionOr<AssertionReturnBundle>&&)>;
using QueryCompletionHandler = CompletionHandler<void(bool)>;

class CredentialsMessenger : public CanMakeWeakPtr<CredentialsMessenger> {
    WTF_MAKE_FAST_ALLOCATED;
    WTF_MAKE_NONCOPYABLE(CredentialsMessenger);
public:
    CredentialsMessenger() = default;

    // Senders.
    virtual void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, CreationCompletionHandler&&) = 0;
    virtual void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&&) = 0;
    virtual void isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&&) = 0;

    // Receivers.
    WEBCORE_EXPORT void exceptionReply(uint64_t messageId, const ExceptionData&);
    virtual void makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject) = 0;
    virtual void getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle) = 0;
    virtual void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool) = 0;

protected:
    virtual ~CredentialsMessenger() = default;

    WEBCORE_EXPORT uint64_t addCreationCompletionHandler(CreationCompletionHandler&&);
    WEBCORE_EXPORT CreationCompletionHandler takeCreationCompletionHandler(uint64_t);
    WEBCORE_EXPORT uint64_t addRequestCompletionHandler(RequestCompletionHandler&&);
    WEBCORE_EXPORT RequestCompletionHandler takeRequestCompletionHandler(uint64_t);
    WEBCORE_EXPORT uint64_t addQueryCompletionHandler(QueryCompletionHandler&&);
    WEBCORE_EXPORT QueryCompletionHandler takeQueryCompletionHandler(uint64_t);

private:
    enum CallBackClassifier : uint64_t {
        Creation = 0x01,
        Request = 0x02,
        Query = 0x03,
    };
    // The most significant byte is reserved as callback classifier.
    uint64_t m_accumulatedMessageId { 1 };
    HashMap<uint64_t, CreationCompletionHandler> m_pendingCreationCompletionHandlers;
    HashMap<uint64_t, RequestCompletionHandler> m_pendingRequestCompletionHandlers;
    HashMap<uint64_t, QueryCompletionHandler> m_pendingQueryCompletionHandlers;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorAssertionResponse.h"

#if ENABLE(WEB_AUTHN)

namespace WebCore {

AuthenticatorAssertionResponse::AuthenticatorAssertionResponse(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& authenticatorData, RefPtr<ArrayBuffer>&& signature, RefPtr<ArrayBuffer>&& userHandle)
    : AuthenticatorResponse(WTFMove(clientDataJSON))
    , m_authenticatorData(WTFMove(authenticatorData))
    , m_signature(WTFMove(signature))
    , m_userHandle(WTFMove(userHandle))
{
}

ArrayBuffer* AuthenticatorAssertionResponse::authenticatorData() const
{
    return m_authenticatorData.get();
}

ArrayBuffer* AuthenticatorAssertionResponse::signature() const
{
    return m_signature.get();
}

ArrayBuffer* AuthenticatorAssertionResponse::userHandle() const
{
    return m_userHandle.get();
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)




class AuthenticatorAssertionResponse : public AuthenticatorResponse {
public:
    static Ref<AuthenticatorAssertionResponse> create(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& authenticatorData, Ref<ArrayBuffer>&& signature, Ref<ArrayBuffer>&& userHandle)
    {
        return adoptRef(*new AuthenticatorAssertionResponse(WTFMove(clientDataJSON), WTFMove(authenticatorData), WTFMove(signature), WTFMove(userHandle)));
    }

    virtual ~AuthenticatorAssertionResponse() = default;

    ArrayBuffer* authenticatorData() const { return m_authenticatorData.ptr(); }
    ArrayBuffer* signature() const { return m_signature.ptr(); }
    ArrayBuffer* userHandle() const { return m_userHandle.ptr(); }

private:
    AuthenticatorAssertionResponse(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& authenticatorData, Ref<ArrayBuffer>&& signature, Ref<ArrayBuffer>&& userHandle)
        : AuthenticatorResponse(WTFMove(clientDataJSON))
        , m_authenticatorData(WTFMove(authenticatorData))
        , m_signature(WTFMove(signature))
        , m_userHandle(WTFMove(userHandle))
    {
    }

    Type type() const final { return Type::Assertion; }

    Ref<ArrayBuffer> m_authenticatorData;
    Ref<ArrayBuffer> m_signature;
    Ref<ArrayBuffer> m_userHandle;
};

} // namespace WebCore



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorAttestationResponse.h"

#if ENABLE(WEB_AUTHN)

namespace WebCore {

AuthenticatorAttestationResponse::AuthenticatorAttestationResponse(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& attestationObject)
    : AuthenticatorResponse(WTFMove(clientDataJSON))
    , m_attestationObject(WTFMove(attestationObject))
{
}

ArrayBuffer* AuthenticatorAttestationResponse::attestationObject() const
{
    return m_attestationObject.get();
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)




class AuthenticatorAttestationResponse : public AuthenticatorResponse {
public:
    static Ref<AuthenticatorAttestationResponse> create(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& attestationObject)
    {
        return adoptRef(*new AuthenticatorAttestationResponse(WTFMove(clientDataJSON), WTFMove(attestationObject)));
    }

    virtual ~AuthenticatorAttestationResponse() = default;

    ArrayBuffer* attestationObject() const { return m_attestationObject.ptr(); }

private:
    AuthenticatorAttestationResponse(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& attestationObject)
        : AuthenticatorResponse(WTFMove(clientDataJSON))
        , m_attestationObject(WTFMove(attestationObject))
    {
    }

    Type type() const final { return Type::Attestation; }

    Ref<ArrayBuffer> m_attestationObject;
};

} // namespace WebCore



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorCoordinator.h"

#if ENABLE(WEB_AUTHN)

#include "AbortSignal.h"
#include "AuthenticatorAssertionResponse.h"
#include "AuthenticatorAttestationResponse.h"
#include "AuthenticatorCoordinatorClient.h"
#include "JSBasicCredential.h"
#include "PublicKeyCredential.h"
#include "PublicKeyCredentialCreationOptions.h"
#include "PublicKeyCredentialData.h"
#include "PublicKeyCredentialRequestOptions.h"
#include "SecurityOrigin.h"
#include "Timer.h"
#include <pal/crypto/CryptoDigest.h>
#include <wtf/JSONValues.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/text/Base64.h>

namespace WebCore {

namespace AuthenticatorCoordinatorInternal {

enum class ClientDataType {
    Create,
    Get
};

// FIXME(181948): Add token binding ID and extensions.
static Ref<ArrayBuffer> produceClientDataJson(ClientDataType type, const BufferSource& challenge, const SecurityOrigin& origin)
{
    auto object = JSON::Object::create();
    switch (type) {
    case ClientDataType::Create:
        object->setString("type"_s, "webauthn.create"_s);
        break;
    case ClientDataType::Get:
        object->setString("type"_s, "webauthn.get"_s);
        break;
    }
    object->setString("challenge"_s, WTF::base64URLEncode(challenge.data(), challenge.length()));
    object->setString("origin"_s, origin.toRawString());
    // FIXME: This might be platform dependent.
    object->setString("hashAlgorithm"_s, "SHA-256"_s);

    auto utf8JSONString = object->toJSONString().utf8();
    return ArrayBuffer::create(utf8JSONString.data(), utf8JSONString.length());
}

static Vector<uint8_t> produceClientDataJsonHash(const ArrayBuffer& clientDataJson)
{
    // FIXME: This might be platform dependent.
    auto crypto = PAL::CryptoDigest::create(PAL::CryptoDigest::Algorithm::SHA_256);
    crypto->addBytes(clientDataJson.data(), clientDataJson.byteLength());
    return crypto->computeHash();
}

// FIXME(181947): We should probably trim timeOutInMs to some max allowable number.
static std::unique_ptr<Timer> initTimeoutTimer(std::optional<unsigned long> timeOutInMs, const CredentialPromise& promise)
{
    if (!timeOutInMs)
        return nullptr;

    auto timer = std::make_unique<Timer>([promise = promise] () mutable {
        promise.reject(Exception { NotAllowedError, "Operation timed out."_s });
    });
    timer->startOneShot(Seconds::fromMilliseconds(*timeOutInMs));
    return timer;
}

static bool didTimeoutTimerFire(Timer* timer)
{
    if (!timer)
        return false;
    if (!timer->isActive())
        return true;
    timer->stop();
    return false;
}

} // namespace AuthenticatorCoordinatorInternal

AuthenticatorCoordinator::AuthenticatorCoordinator(std::unique_ptr<AuthenticatorCoordinatorClient>&& client)
    : m_client(WTFMove(client))
{
}

void AuthenticatorCoordinator::setClient(std::unique_ptr<AuthenticatorCoordinatorClient>&& client)
{
    m_client = WTFMove(client);
}

void AuthenticatorCoordinator::create(const SecurityOrigin& callerOrigin, const PublicKeyCredentialCreationOptions& options, bool sameOriginWithAncestors, RefPtr<AbortSignal>&& abortSignal, CredentialPromise&& promise) const
{
    using namespace AuthenticatorCoordinatorInternal;

    // The following implements https://www.w3.org/TR/webauthn/#createCredential as of 5 December 2017.
    // FIXME: Extensions are not supported yet. Skip Step 11-12.
    // Step 1, 3, 16 are handled by the caller.
    // Step 2.
    if (!sameOriginWithAncestors) {
        promise.reject(Exception { NotAllowedError, "The origin of the document is not the same as its ancestors."_s });
        return;
    }

    // Step 4 & 17.
    std::unique_ptr<Timer> timeoutTimer = initTimeoutTimer(options.timeout, promise);

    // Step 5-7.
    // FIXME(181950): We lack fundamental support from SecurityOrigin to determine if a host is a valid domain or not.
    // Step 6 is therefore skipped. Also, we lack the support to determine whether a domain is a registrable
    // domain suffix of another domain. Hence restrict the comparison to equal in Step 7.
    if (!options.rp.id.isEmpty() && callerOrigin.host() != options.rp.id) {
        promise.reject(Exception { SecurityError, "The origin of the document is not a registrable domain suffix of the provided RP ID."_s });
        return;
    }
    if (options.rp.id.isEmpty())
        options.rp.id = callerOrigin.host();

    // Step 8-10.
    // Most of the jobs are done by bindings. However, we can't know if the JSValue of options.pubKeyCredParams
    // is empty or not. Return NotSupportedError as long as it is empty.
    if (options.pubKeyCredParams.isEmpty()) {
        promise.reject(Exception { NotSupportedError, "No desired properties of the to be created credential are provided."_s });
        return;
    }

    // Step 13-15.
    auto clientDataJson = produceClientDataJson(ClientDataType::Create, options.challenge, callerOrigin);
    auto clientDataJsonHash = produceClientDataJsonHash(clientDataJson);

    // Step 18-21.
    // Only platform attachments will be supported at this stage. Assuming one authenticator per device.
    // Also, resident keys, user verifications and direct attestation are enforced at this tage.
    // For better performance, transports of options.excludeCredentials are checked in LocalAuthenticator.
    if (!m_client)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    auto completionHandler = [clientDataJson = WTFMove(clientDataJson), promise = WTFMove(promise), timeoutTimer = WTFMove(timeoutTimer), abortSignal = WTFMove(abortSignal)] (const WebCore::PublicKeyCredentialData& data, const WebCore::ExceptionData& exception) mutable {
        if (didTimeoutTimerFire(timeoutTimer.get()))
            return;
        if (abortSignal && abortSignal->aborted()) {
            promise.reject(Exception { AbortError, "Aborted by AbortSignal."_s });
            return;
        }

        data.clientDataJSON = WTFMove(clientDataJson);
        if (auto publicKeyCredential = PublicKeyCredential::tryCreate(data)) {
            promise.resolve(publicKeyCredential.get());
            return;
        }
        ASSERT(!exception.message.isNull());
        promise.reject(exception.toException());
    };
    // Async operations are dispatched and handled in the messenger.
    m_client->makeCredential(clientDataJsonHash, options, WTFMove(completionHandler));
}

void AuthenticatorCoordinator::discoverFromExternalSource(const SecurityOrigin& callerOrigin, const PublicKeyCredentialRequestOptions& options, bool sameOriginWithAncestors, RefPtr<AbortSignal>&& abortSignal, CredentialPromise&& promise) const
{
    using namespace AuthenticatorCoordinatorInternal;

    // The following implements https://www.w3.org/TR/webauthn/#createCredential as of 5 December 2017.
    // FIXME: Extensions are not supported yet. Skip Step 8-9.
    // Step 1, 3, 13 are handled by the caller.
    // Step 2.
    if (!sameOriginWithAncestors) {
        promise.reject(Exception { NotAllowedError, "The origin of the document is not the same as its ancestors."_s });
        return;
    }

    // Step 4 & 16.
    std::unique_ptr<Timer> timeoutTimer = initTimeoutTimer(options.timeout, promise);

    // Step 5-7.
    // FIXME(181950): We lack fundamental support from SecurityOrigin to determine if a host is a valid domain or not.
    // Step 6 is therefore skipped. Also, we lack the support to determine whether a domain is a registrable
    // domain suffix of another domain. Hence restrict the comparison to equal in Step 7.
    if (!options.rpId.isEmpty() && callerOrigin.host() != options.rpId) {
        promise.reject(Exception { SecurityError, "The origin of the document is not a registrable domain suffix of the provided RP ID."_s });
        return;
    }
    if (options.rpId.isEmpty())
        options.rpId = callerOrigin.host();

    // Step 10-12.
    auto clientDataJson = produceClientDataJson(ClientDataType::Get, options.challenge, callerOrigin);
    auto clientDataJsonHash = produceClientDataJsonHash(clientDataJson);

    // Step 14-15, 17-19.
    // Only platform attachments will be supported at this stage. Assuming one authenticator per device.
    // Also, resident keys, user verifications and direct attestation are enforced at this tage.
    // For better performance, filtering of options.allowCredentials is done in LocalAuthenticator.
    if (!m_client)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    auto completionHandler = [clientDataJson = WTFMove(clientDataJson), promise = WTFMove(promise), timeoutTimer = WTFMove(timeoutTimer), abortSignal = WTFMove(abortSignal)] (const WebCore::PublicKeyCredentialData& data, const WebCore::ExceptionData& exception) mutable {
        if (didTimeoutTimerFire(timeoutTimer.get()))
            return;
        if (abortSignal && abortSignal->aborted()) {
            promise.reject(Exception { AbortError, "Aborted by AbortSignal."_s });
            return;
        }

        data.clientDataJSON = WTFMove(clientDataJson);
        if (auto publicKeyCredential = PublicKeyCredential::tryCreate(data)) {
            promise.resolve(publicKeyCredential.get());
            return;
        }
        ASSERT(!exception.message.isNull());
        promise.reject(exception.toException());
    };
    // Async operations are dispatched and handled in the messenger.
    m_client->getAssertion(clientDataJsonHash, options, WTFMove(completionHandler));
}

void AuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable(DOMPromiseDeferred<IDLBoolean>&& promise) const
{
    // The following implements https://www.w3.org/TR/webauthn/#isUserVerifyingPlatformAuthenticatorAvailable
    // as of 5 December 2017.
    if (!m_client)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    // FIXME(182767): We should consider more on the assessment of the return value. Right now, we return true/false
    // immediately according to platform specific procedures.
    auto completionHandler = [promise = WTFMove(promise)] (bool result) mutable {
        promise.resolve(result);
    };
    // Async operation are dispatched and handled in the messenger.
    m_client->isUserVerifyingPlatformAuthenticatorAvailable(WTFMove(completionHandler));
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "JSDOMPromiseDeferred.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>

namespace WebCore {

class AbortSignal;
class AuthenticatorCoordinatorClient;
class BasicCredential;
class SecurityOrigin;

struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialRequestOptions;

using CredentialPromise = DOMPromiseDeferred<IDLNullable<IDLInterface<BasicCredential>>>;

class AuthenticatorCoordinator {
    WTF_MAKE_NONCOPYABLE(AuthenticatorCoordinator);
public:
    WEBCORE_EXPORT explicit AuthenticatorCoordinator(std::unique_ptr<AuthenticatorCoordinatorClient>&&);
    WEBCORE_EXPORT void setClient(std::unique_ptr<AuthenticatorCoordinatorClient>&&);

    // The following methods implement static methods of PublicKeyCredential.
    void create(const SecurityOrigin&, const PublicKeyCredentialCreationOptions&, bool sameOriginWithAncestors, RefPtr<AbortSignal>&&, CredentialPromise&&) const;
    void discoverFromExternalSource(const SecurityOrigin&, const PublicKeyCredentialRequestOptions&, bool sameOriginWithAncestors, RefPtr<AbortSignal>&&, CredentialPromise&&) const;
    void isUserVerifyingPlatformAuthenticatorAvailable(DOMPromiseDeferred<IDLBoolean>&&) const;

private:
    AuthenticatorCoordinator() = default;

    std::unique_ptr<AuthenticatorCoordinatorClient> m_client;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorCoordinatorClient.h"

#if ENABLE(WEB_AUTHN)

#include "PublicKeyCredentialData.h"

namespace WebCore {

AuthenticatorCoordinatorClient::~AuthenticatorCoordinatorClient()
{
    // Just to call handlers to avoid any assertion failures.
    if (m_pendingCompletionHandler)
        m_pendingCompletionHandler({ }, { NotAllowedError, "Operation timed out."_s });
    for (auto itr = m_pendingQueryCompletionHandlers.begin(); itr !=  m_pendingQueryCompletionHandlers.end(); ++itr)
        itr->value(false);
}

void AuthenticatorCoordinatorClient::requestReply(const WebCore::PublicKeyCredentialData& data, const WebCore::ExceptionData& exception)
{
    m_pendingCompletionHandler(data, exception);
}

void AuthenticatorCoordinatorClient::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
{
    auto handler = m_pendingQueryCompletionHandlers.take(messageId);
    handler(result);
}

bool AuthenticatorCoordinatorClient::setRequestCompletionHandler(RequestCompletionHandler&& handler)
{
    if (m_pendingCompletionHandler) {
        handler({ }, { NotAllowedError, "A request is pending."_s });
        return false;
    }

    m_pendingCompletionHandler = WTFMove(handler);
    return true;
}

uint64_t AuthenticatorCoordinatorClient::addQueryCompletionHandler(QueryCompletionHandler&& handler)
{
    uint64_t messageId = m_accumulatedMessageId++;
    auto addResult = m_pendingQueryCompletionHandlers.add(messageId, WTFMove(handler));
    ASSERT_UNUSED(addResult, addResult.isNewEntry);
    return messageId;
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "ExceptionData.h"
#include <wtf/CompletionHandler.h>
#include <wtf/HashMap.h>
#include <wtf/WeakPtr.h>

namespace WebCore {

class DeferredPromise;

struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialData;
struct PublicKeyCredentialRequestOptions;

using RequestCompletionHandler = CompletionHandler<void(const WebCore::PublicKeyCredentialData&, const WebCore::ExceptionData&)>;
using QueryCompletionHandler = CompletionHandler<void(bool)>;

class WEBCORE_EXPORT AuthenticatorCoordinatorClient : public CanMakeWeakPtr<AuthenticatorCoordinatorClient> {
    WTF_MAKE_FAST_ALLOCATED;
    WTF_MAKE_NONCOPYABLE(AuthenticatorCoordinatorClient);
public:
    AuthenticatorCoordinatorClient() = default;
    virtual ~AuthenticatorCoordinatorClient();

    // Senders.
    virtual void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, RequestCompletionHandler&&) = 0;
    virtual void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&&) = 0;
    virtual void isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&&) = 0;

    // Receivers.
    void requestReply(const WebCore::PublicKeyCredentialData&, const WebCore::ExceptionData&);
    void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool);

protected:
    // Only one request is allowed at one time. It returns false whenever there is an existing pending request.
    // And invokes the provided handler with NotAllowedError.
    bool setRequestCompletionHandler(RequestCompletionHandler&&);
    uint64_t addQueryCompletionHandler(QueryCompletionHandler&&);

private:
    RequestCompletionHandler m_pendingCompletionHandler;
    uint64_t m_accumulatedMessageId { 1 };
    HashMap<uint64_t, QueryCompletionHandler> m_pendingQueryCompletionHandlers;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorManager.h"

#if ENABLE(WEB_AUTHN)

#include "AbortSignal.h"
#include "AuthenticatorAssertionResponse.h"
#include "AuthenticatorAttestationResponse.h"
#include "CredentialsMessenger.h"
#include "JSBasicCredential.h"
#include "PublicKeyCredential.h"
#include "PublicKeyCredentialCreationOptions.h"
#include "PublicKeyCredentialRequestOptions.h"
#include "SecurityOrigin.h"
#include "Timer.h"
#include <pal/crypto/CryptoDigest.h>
#include <wtf/JSONValues.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/text/Base64.h>

namespace WebCore {

namespace AuthenticatorManagerInternal {

enum class ClientDataType {
    Create,
    Get
};

// FIXME(181948): Add token binding ID and extensions.
static Ref<ArrayBuffer> produceClientDataJson(ClientDataType type, const BufferSource& challenge, const SecurityOrigin& origin)
{
    auto object = JSON::Object::create();
    switch (type) {
    case ClientDataType::Create:
        object->setString("type"_s, "webauthn.create"_s);
        break;
    case ClientDataType::Get:
        object->setString("type"_s, "webauthn.get"_s);
        break;
    }
    object->setString("challenge"_s, WTF::base64URLEncode(challenge.data(), challenge.length()));
    object->setString("origin"_s, origin.toRawString());
    // FIXME: This might be platform dependent.
    object->setString("hashAlgorithm"_s, "SHA-256"_s);

    auto utf8JSONString = object->toJSONString().utf8();
    return ArrayBuffer::create(utf8JSONString.data(), utf8JSONString.length());
}

static Vector<uint8_t> produceClientDataJsonHash(const ArrayBuffer& clientDataJson)
{
    // FIXME: This might be platform dependent.
    auto crypto = PAL::CryptoDigest::create(PAL::CryptoDigest::Algorithm::SHA_256);
    crypto->addBytes(clientDataJson.data(), clientDataJson.byteLength());
    return crypto->computeHash();
}

// FIXME(181947): We should probably trim timeOutInMs to some max allowable number.
static std::unique_ptr<Timer> initTimeoutTimer(std::optional<unsigned long> timeOutInMs, const CredentialPromise& promise)
{
    if (!timeOutInMs)
        return nullptr;

    auto timer = std::make_unique<Timer>([promise = promise] () mutable {
        promise.reject(Exception { NotAllowedError, "Operation timed out."_s });
    });
    timer->startOneShot(Seconds::fromMilliseconds(*timeOutInMs));
    return timer;
}

static bool didTimeoutTimerFire(Timer* timer)
{
    if (!timer)
        return false;
    if (!timer->isActive())
        return true;
    timer->stop();
    return false;
}

} // namespace AuthenticatorManagerInternal

AuthenticatorManager& AuthenticatorManager::singleton()
{
    ASSERT(isMainThread());
    static NeverDestroyed<AuthenticatorManager> authenticator;
    return authenticator;
}

void AuthenticatorManager::setMessenger(CredentialsMessenger& messenger)
{
    m_messenger = makeWeakPtr(messenger);
}

void AuthenticatorManager::create(const SecurityOrigin& callerOrigin, const PublicKeyCredentialCreationOptions& options, bool sameOriginWithAncestors, RefPtr<AbortSignal>&& abortSignal, CredentialPromise&& promise) const
{
    using namespace AuthenticatorManagerInternal;

    // The following implements https://www.w3.org/TR/webauthn/#createCredential as of 5 December 2017.
    // FIXME: Extensions are not supported yet. Skip Step 11-12.
    // Step 1, 3, 16 are handled by the caller.
    // Step 2.
    if (!sameOriginWithAncestors) {
        promise.reject(Exception { NotAllowedError, "The origin of the document is not the same as its ancestors."_s });
        return;
    }

    // Step 4 & 17.
    std::unique_ptr<Timer> timeoutTimer = initTimeoutTimer(options.timeout, promise);

    // Step 5-7.
    // FIXME(181950): We lack fundamental support from SecurityOrigin to determine if a host is a valid domain or not.
    // Step 6 is therefore skipped. Also, we lack the support to determine whether a domain is a registrable
    // domain suffix of another domain. Hence restrict the comparison to equal in Step 7.
    if (!options.rp.id.isEmpty() && callerOrigin.host() != options.rp.id) {
        promise.reject(Exception { SecurityError, "The origin of the document is not a registrable domain suffix of the provided RP ID."_s });
        return;
    }
    if (options.rp.id.isEmpty())
        options.rp.id = callerOrigin.host();

    // Step 8-10.
    // Most of the jobs are done by bindings. However, we can't know if the JSValue of options.pubKeyCredParams
    // is empty or not. Return NotSupportedError as long as it is empty.
    if (options.pubKeyCredParams.isEmpty()) {
        promise.reject(Exception { NotSupportedError, "No desired properties of the to be created credential are provided."_s });
        return;
    }

    // Step 13-15.
    auto clientDataJson = produceClientDataJson(ClientDataType::Create, options.challenge, callerOrigin);
    auto clientDataJsonHash = produceClientDataJsonHash(clientDataJson);

    // Step 18-21.
    // Only platform attachments will be supported at this stage. Assuming one authenticator per device.
    // Also, resident keys, user verifications and direct attestation are enforced at this tage.
    // For better performance, transports of options.excludeCredentials are checked in LocalAuthenticator.
    if (!m_messenger)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    auto completionHandler = [clientDataJson = WTFMove(clientDataJson), promise = WTFMove(promise), timeoutTimer = WTFMove(timeoutTimer), abortSignal = WTFMove(abortSignal)] (ExceptionOr<CreationReturnBundle>&& result) mutable {
        if (didTimeoutTimerFire(timeoutTimer.get()))
            return;
        if (abortSignal && abortSignal->aborted()) {
            promise.reject(Exception { AbortError, "Aborted by AbortSignal."_s });
            return;
        }
        if (result.hasException()) {
            promise.reject(result.exception());
            return;
        }

        auto bundle = result.releaseReturnValue();
        promise.resolve(PublicKeyCredential::create(WTFMove(bundle.credentialId), AuthenticatorAttestationResponse::create(WTFMove(clientDataJson), ArrayBuffer::create(WTFMove(bundle.attestationObject)))).ptr());
    };
    // Async operations are dispatched and handled in the messenger.
    m_messenger->makeCredential(clientDataJsonHash, options, WTFMove(completionHandler));
}

void AuthenticatorManager::discoverFromExternalSource(const SecurityOrigin& callerOrigin, const PublicKeyCredentialRequestOptions& options, bool sameOriginWithAncestors, RefPtr<AbortSignal>&& abortSignal, CredentialPromise&& promise) const
{
    using namespace AuthenticatorManagerInternal;

    // The following implements https://www.w3.org/TR/webauthn/#createCredential as of 5 December 2017.
    // FIXME: Extensions are not supported yet. Skip Step 8-9.
    // Step 1, 3, 13 are handled by the caller.
    // Step 2.
    if (!sameOriginWithAncestors) {
        promise.reject(Exception { NotAllowedError, "The origin of the document is not the same as its ancestors."_s });
        return;
    }

    // Step 4 & 16.
    std::unique_ptr<Timer> timeoutTimer = initTimeoutTimer(options.timeout, promise);

    // Step 5-7.
    // FIXME(181950): We lack fundamental support from SecurityOrigin to determine if a host is a valid domain or not.
    // Step 6 is therefore skipped. Also, we lack the support to determine whether a domain is a registrable
    // domain suffix of another domain. Hence restrict the comparison to equal in Step 7.
    if (!options.rpId.isEmpty() && callerOrigin.host() != options.rpId) {
        promise.reject(Exception { SecurityError, "The origin of the document is not a registrable domain suffix of the provided RP ID."_s });
        return;
    }
    if (options.rpId.isEmpty())
        options.rpId = callerOrigin.host();

    // Step 10-12.
    auto clientDataJson = produceClientDataJson(ClientDataType::Get, options.challenge, callerOrigin);
    auto clientDataJsonHash = produceClientDataJsonHash(clientDataJson);

    // Step 14-15, 17-19.
    // Only platform attachments will be supported at this stage. Assuming one authenticator per device.
    // Also, resident keys, user verifications and direct attestation are enforced at this tage.
    // For better performance, filtering of options.allowCredentials is done in LocalAuthenticator.
    if (!m_messenger)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    auto completionHandler = [clientDataJson = WTFMove(clientDataJson), promise = WTFMove(promise), timeoutTimer = WTFMove(timeoutTimer), abortSignal = WTFMove(abortSignal)] (ExceptionOr<AssertionReturnBundle>&& result) mutable {
        if (didTimeoutTimerFire(timeoutTimer.get()))
            return;
        if (abortSignal && abortSignal->aborted()) {
            promise.reject(Exception { AbortError, "Aborted by AbortSignal."_s });
            return;
        }
        if (result.hasException()) {
            promise.reject(result.exception());
            return;
        }

        auto bundle = result.releaseReturnValue();
        promise.resolve(PublicKeyCredential::create(WTFMove(bundle.credentialId), AuthenticatorAssertionResponse::create(WTFMove(clientDataJson), WTFMove(bundle.authenticatorData), WTFMove(bundle.signature), WTFMove(bundle.userHandle))).ptr());
    };
    // Async operations are dispatched and handled in the messenger.
    m_messenger->getAssertion(clientDataJsonHash, options, WTFMove(completionHandler));
}

void AuthenticatorManager::isUserVerifyingPlatformAuthenticatorAvailable(DOMPromiseDeferred<IDLBoolean>&& promise) const
{
    // The following implements https://www.w3.org/TR/webauthn/#isUserVerifyingPlatformAuthenticatorAvailable
    // as of 5 December 2017.
    if (!m_messenger)  {
        promise.reject(Exception { UnknownError, "Unknown internal error."_s });
        return;
    }

    // FIXME(182767): We should consider more on the assessment of the return value. Right now, we return true/false
    // immediately according to platform specific procedures.
    auto completionHandler = [promise = WTFMove(promise)] (bool result) mutable {
        promise.resolve(result);
    };
    // Async operation are dispatched and handled in the messenger.
    m_messenger->isUserVerifyingPlatformAuthenticatorAvailable(WTFMove(completionHandler));
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "JSDOMPromiseDeferred.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
#include <wtf/WeakPtr.h>

namespace WebCore {

class AbortSignal;
class BasicCredential;
class CredentialsMessenger;
class SecurityOrigin;

struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialRequestOptions;

using CredentialPromise = DOMPromiseDeferred<IDLNullable<IDLInterface<BasicCredential>>>;

class AuthenticatorManager {
    WTF_MAKE_NONCOPYABLE(AuthenticatorManager);
    friend class NeverDestroyed<AuthenticatorManager>;
public:
    WEBCORE_EXPORT static AuthenticatorManager& singleton();
    WEBCORE_EXPORT void setMessenger(CredentialsMessenger&);

    // The following methods implement static methods of PublicKeyCredential.
    void create(const SecurityOrigin&, const PublicKeyCredentialCreationOptions&, bool sameOriginWithAncestors, RefPtr<AbortSignal>&&, CredentialPromise&&) const;
    void discoverFromExternalSource(const SecurityOrigin&, const PublicKeyCredentialRequestOptions&, bool sameOriginWithAncestors, RefPtr<AbortSignal>&&, CredentialPromise&&) const;
    void isUserVerifyingPlatformAuthenticatorAvailable(DOMPromiseDeferred<IDLBoolean>&&) const;

private:
    AuthenticatorManager() = default;

    WeakPtr<CredentialsMessenger> m_messenger;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "AuthenticatorResponse.h"

#if ENABLE(WEB_AUTHN)

namespace WebCore {

AuthenticatorResponse::AuthenticatorResponse(RefPtr<ArrayBuffer>&& clientDataJSON)
    : m_clientDataJSON(WTFMove(clientDataJSON))
{
}

ArrayBuffer* AuthenticatorResponse::clientDataJSON() const
{
    return m_clientDataJSON.get();
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



        Attestation
    };

    explicit AuthenticatorResponse(Ref<ArrayBuffer>&& clientDataJSON)
        : m_clientDataJSON(WTFMove(clientDataJSON))
    {
    }
    virtual ~AuthenticatorResponse() = default;

    virtual Type type() const = 0;

    ArrayBuffer* clientDataJSON() const { return m_clientDataJSON.ptr(); }

private:
    Ref<ArrayBuffer> m_clientDataJSON;
};

} // namespace WebCore




#if ENABLE(WEB_AUTHN)

#include "AuthenticatorCoordinator.h"
#include "Document.h"
#include "JSDOMPromiseDeferred.h"
#include "Page.h"
#include "PublicKeyCredentialData.h"
#include <wtf/text/Base64.h>

namespace WebCore {

Ref<PublicKeyCredential> PublicKeyCredential::create(Ref<ArrayBuffer>&& id, Ref<AuthenticatorResponse>&& response)
{
    return adoptRef(*new PublicKeyCredential(WTFMove(id), WTFMove(response)));
}

RefPtr<PublicKeyCredential> PublicKeyCredential::tryCreate(const PublicKeyCredentialData& data)
{
    if (!data.rawId || !data.clientDataJSON)
        return nullptr;

    if (data.isAuthenticatorAttestationResponse) {
        if (!data.attestationObject)
            return nullptr;

        return adoptRef(*new PublicKeyCredential(data.rawId.releaseNonNull(), AuthenticatorAttestationResponse::create(data.clientDataJSON.releaseNonNull(), data.attestationObject.releaseNonNull())));
    }

    if (!data.authenticatorData || !data.signature || !data.userHandle)
        return nullptr;

    return adoptRef(*new PublicKeyCredential(data.rawId.releaseNonNull(), AuthenticatorAssertionResponse::create(data.clientDataJSON.releaseNonNull(), data.authenticatorData.releaseNonNull(), data.signature.releaseNonNull(), data.userHandle.releaseNonNull())));
}

PublicKeyCredential::PublicKeyCredential(Ref<ArrayBuffer>&& id, Ref<AuthenticatorResponse>&& response)
    : BasicCredential(WTF::base64URLEncode(id->data(), id->byteLength()), Type::PublicKey, Discovery::Remote)
    , m_rawId(WTFMove(id))
    , m_response(WTFMove(response))

    return Exception { NotSupportedError };
}

void PublicKeyCredential::isUserVerifyingPlatformAuthenticatorAvailable(Document& document, DOMPromiseDeferred<IDLBoolean>&& promise)
{
    document.page()->authenticatorCoordinator().isUserVerifyingPlatformAuthenticatorAvailable(WTFMove(promise));
}

} // namespace WebCore



namespace WebCore {

class AuthenticatorResponse;
class Document;

struct PublicKeyCredentialData;

class PublicKeyCredential final : public BasicCredential {
public:
    static Ref<PublicKeyCredential> create(Ref<ArrayBuffer>&& id, Ref<AuthenticatorResponse>&&);
    static RefPtr<PublicKeyCredential> tryCreate(const PublicKeyCredentialData&);
        return adoptRef(*new PublicKeyCredential(WTFMove(id), WTFMove(response)));
    }

    ArrayBuffer* rawId() const { return m_rawId.ptr(); }
    AuthenticatorResponse* response() const { return m_response.ptr(); }
    // Not support yet. Always throws.
    ExceptionOr<bool> getClientExtensionResults() const;

    static void isUserVerifyingPlatformAuthenticatorAvailable(Document&, DOMPromiseDeferred<IDLBoolean>&&);

private:
    PublicKeyCredential(Ref<ArrayBuffer>&& id, Ref<AuthenticatorResponse>&&);

    Type credentialType() const final { return Type::PublicKey; }

    Ref<ArrayBuffer> m_rawId;
    Ref<AuthenticatorResponse> m_response;
};

} // namespace WebCore

Lines 35-39 typedef boolean AuthenticationExtensions; a/Source/WebCore/Modules/webauthn/PublicKeyCredential.idl_sec1
- a/Source/WebCore/Modules/webauthn/PublicKeyCredential.idl -1 / +1 lines
35	[SameObject] readonly attribute AuthenticatorResponse response;	35	[SameObject] readonly attribute AuthenticatorResponse response;
36	[MayThrowException] AuthenticationExtensions getClientExtensionResults();	36	[MayThrowException] AuthenticationExtensions getClientExtensionResults();
37		37
38	static Promise<boolean> isUserVerifyingPlatformAuthenticatorAvailable();	38	[CallWith=Document] static Promise<boolean> isUserVerifyingPlatformAuthenticatorAvailable();
39	};	39	};



void PublicKeyCredentialCreationOptions::encode(Encoder& encoder) const
{
    encoder << rp.id << rp.name << rp.icon;
    encoder << static_cast<uint64_t>(user.id.length());
    encoder.encodeFixedLengthData(user.id.data(), user.id.length(), 1);
    encoder << user.displayName << user.name << user.icon << pubKeyCredParams << excludeCredentials;
}

template<class Decoder>

        return std::nullopt;
    if (!decoder.decode(result.rp.icon))
        return std::nullopt;

    std::optional<uint64_t> userIdLength;
    decoder >> userIdLength;
    if (!userIdLength)
        return std::nullopt;
    result.user.idVector.reserveCapacity(userIdLength.value());
    if (!decoder.decodeFixedLengthData(result.user.idVector.data(), userIdLength.value(), 1))
        return std::nullopt;

    if (!decoder.decode(result.user.displayName))
        return std::nullopt;
    if (!decoder.decode(result.user.name))



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include <JavaScriptCore/ArrayBuffer.h>
#include <wtf/Forward.h>

namespace WebCore {

class AuthenticatorResponse;

struct PublicKeyCredentialData {
    mutable RefPtr<ArrayBuffer> rawId;

    // AuthenticatorResponse
    bool isAuthenticatorAttestationResponse;
    mutable RefPtr<ArrayBuffer> clientDataJSON;

    // AuthenticatorAttestationResponse
    mutable RefPtr<ArrayBuffer> attestationObject;

    // AuthenticatorAssertionResponse
    mutable RefPtr<ArrayBuffer> authenticatorData;
    mutable RefPtr<ArrayBuffer> signature;
    mutable RefPtr<ArrayBuffer> userHandle;

    template<class Encoder> void encode(Encoder&) const;
    template<class Decoder> static std::optional<PublicKeyCredentialData> decode(Decoder&);
};

// Noted: clientDataJSON is never encoded or decoded as it is never sent across different processes.
template<class Encoder>
void PublicKeyCredentialData::encode(Encoder& encoder) const
{
    encoder << static_cast<uint64_t>(rawId->byteLength());
    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(rawId->data()), rawId->byteLength(), 1);

    encoder << isAuthenticatorAttestationResponse;

    if (isAuthenticatorAttestationResponse) {
        encoder << static_cast<uint64_t>(attestationObject->byteLength());
        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(attestationObject->data()), attestationObject->byteLength(), 1);
        return;
    }

    encoder << static_cast<uint64_t>(authenticatorData->byteLength());
    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(authenticatorData->data()), authenticatorData->byteLength(), 1);
    encoder << static_cast<uint64_t>(signature->byteLength());
    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(signature->data()), signature->byteLength(), 1);
    encoder << static_cast<uint64_t>(userHandle->byteLength());
    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(userHandle->data()), userHandle->byteLength(), 1);
}

template<class Decoder>
std::optional<PublicKeyCredentialData> PublicKeyCredentialData::decode(Decoder& decoder)
{
    PublicKeyCredentialData result;

    std::optional<uint64_t> rawIdLength;
    decoder >> rawIdLength;
    if (!rawIdLength)
        return std::nullopt;

    result.rawId = ArrayBuffer::create(rawIdLength.value(), sizeof(uint8_t));
    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(result.rawId->data()), rawIdLength.value(), 1))
        return std::nullopt;

    std::optional<bool> isAuthenticatorAttestationResponse;
    decoder >> isAuthenticatorAttestationResponse;
    if (!isAuthenticatorAttestationResponse)
        return std::nullopt;
    result.isAuthenticatorAttestationResponse = isAuthenticatorAttestationResponse.value();

    if (result.isAuthenticatorAttestationResponse) {
        std::optional<uint64_t> attestationObjectLength;
        decoder >> attestationObjectLength;
        if (!attestationObjectLength)
            return std::nullopt;

        result.attestationObject = ArrayBuffer::create(attestationObjectLength.value(), sizeof(uint8_t));
        if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(result.attestationObject->data()), attestationObjectLength.value(), 1))
            return std::nullopt;

        return result;
    }

    std::optional<uint64_t> authenticatorDataLength;
    decoder >> authenticatorDataLength;
    if (!authenticatorDataLength)
        return std::nullopt;

    result.authenticatorData = ArrayBuffer::create(authenticatorDataLength.value(), sizeof(uint8_t));
    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(result.authenticatorData->data()), authenticatorDataLength.value(), 1))
        return std::nullopt;

    std::optional<uint64_t> signatureLength;
    decoder >> signatureLength;
    if (!signatureLength)
        return std::nullopt;

    result.signature = ArrayBuffer::create(signatureLength.value(), sizeof(uint8_t));
    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(result.signature->data()), signatureLength.value(), 1))
        return std::nullopt;

    std::optional<uint64_t> userHandleLength;
    decoder >> userHandleLength;
    if (!userHandleLength)
        return std::nullopt;

    result.userHandle = ArrayBuffer::create(userHandleLength.value(), sizeof(uint8_t));
    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(result.userHandle->data()), userHandleLength.value(), 1))
        return std::nullopt;

    return result;
}
    
} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)




struct ExceptionData;
struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialData;
struct PublicKeyCredentialRequestOptions;

using Callback = Function<void(Variant<PublicKeyCredentialData, ExceptionData>&&)>;
using RequestCallback = Function<void(const Vector<uint8_t>&, const Vector<uint8_t>&, const Vector<uint8_t>&, const Vector<uint8_t>&)>;
using ExceptionCallback = Function<void(const WebCore::ExceptionData&)>;

typedef void (^CompletionBlock)(SecKeyRef _Nullable referenceKey, NSArray * _Nullable certificates, NSError * _Nullable error);


    LocalAuthenticator();
    virtual ~LocalAuthenticator() = default;

    void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, Callback&&);
    void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, Callback&&);
    bool isAvailable() const;

protected:



#import "COSEConstants.h"
#import "ExceptionData.h"
#import "PublicKeyCredentialCreationOptions.h"
#import "PublicKeyCredentialData.h"
#import "PublicKeyCredentialRequestOptions.h"
#import <Security/SecItem.h>
#import <pal/crypto/CryptoDigest.h>

    RELEASE_ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessCredentials));
}

void LocalAuthenticator::makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions& options, Callback&& callback)
{
    using namespace LocalAuthenticatorInternal;


    ASSERT_UNUSED(hash, hash == hash);
    ASSERT_UNUSED(options, !options.rp.id.isEmpty());
    ASSERT_UNUSED(callback, callback);
    callback(ExceptionData { NotAllowedError, "No avaliable authenticators."_s });
#else
    // The following implements https://www.w3.org/TR/webauthn/#op-make-cred as of 5 December 2017.
    // Skip Step 4-5 as requireResidentKey and requireUserVerification are enforced.

        }
    }
    if (!canFullfillPubKeyCredParams) {
        callback(ExceptionData { NotSupportedError, "The platform attached authenticator doesn't support any provided PublicKeyCredentialParameters."_s });
        return;
    }


        OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &attributesArrayRef);
        if (status && status != errSecItemNotFound) {
            LOG_ERROR("Couldn't query Keychain: %d", status);
            callback(ExceptionData { UnknownError, "Unknown internal error."_s });
            return;
        }
        auto retainAttributesArray = adoptCF(attributesArrayRef);

        for (NSDictionary *nsAttributes in (NSArray *)attributesArrayRef) {
            NSData *nsCredentialId = nsAttributes[(id)kSecAttrApplicationLabel];
            if (excludeCredentialIds.contains(String(reinterpret_cast<const char*>(nsCredentialId.bytes), nsCredentialId.length))) {
                callback(ExceptionData { NotAllowedError, "At least one credential matches an entry of the excludeCredentials list in the platform attached authenticator."_s });
                return;
            }
        }

    if (![context canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics error:&error]) {
        LOG_ERROR("Couldn't evaluate authentication with biometrics policy: %@", error);
        // FIXME(182767)
        callback(ExceptionData { NotAllowedError, "No avaliable authenticators."_s });
        return;
    }

    NSString *reason = [NSString stringWithFormat:@"Allow %@ to create a public key credential for %@", (id)options.rp.id, (id)options.user.name];
    // FIXME(183534): Optimize the following nested callbacks and threading.
    [context evaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics localizedReason:reason reply:BlockPtr<void(BOOL, NSError *)>::fromCallable([weakThis = makeWeakPtr(*this), callback = WTFMove(callback), options = crossThreadCopy(options), hash] (BOOL success, NSError *error) mutable {
        ASSERT(!isMainThread());
        if (!success || error) {
            LOG_ERROR("Couldn't authenticate with biometrics: %@", error);
            callback(ExceptionData { NotAllowedError, "Couldn't get user consent."_s });
            return;
        }


        OSStatus status = SecItemDelete((__bridge CFDictionaryRef)deleteQuery);
        if (status && status != errSecItemNotFound) {
            LOG_ERROR("Couldn't detele older credential: %d", status);
            callback(ExceptionData { UnknownError, "Unknown internal error."_s });
            return;
        }


        // FIXME(183534)
        if (!weakThis)
            return;
        weakThis->issueClientCertificate(options.rp.id, options.user.name, hash, BlockPtr<void(SecKeyRef, NSArray *, NSError *)>::fromCallable([callback = WTFMove(callback), options = crossThreadCopy(options)] (_Nullable SecKeyRef privateKey, NSArray * _Nullable certificates, NSError * _Nullable error) {
            ASSERT(!isMainThread());
            if (error) {
                LOG_ERROR("Couldn't attest: %@", error);
                callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                return;
            }
            // Attestation Certificate and Attestation Issuing CA

                OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)credentialIdQuery, &attributesRef);
                if (status) {
                    LOG_ERROR("Couldn't get Credential ID: %d", status);
                    callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                    return;
                }
                auto retainAttributes = adoptCF(attributesRef);

                status = SecItemUpdate((__bridge CFDictionaryRef)updateQuery, (__bridge CFDictionaryRef)updateParams);
                if (status) {
                    LOG_ERROR("Couldn't update the Keychain item: %d", status);
                    callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                    return;
                }
            }

                    auto retainError = adoptCF(errorRef);
                    if (errorRef) {
                        LOG_ERROR("Couldn't export the public key: %@", (NSError*)errorRef);
                        callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                        return;
                    }
                    ASSERT(((NSData *)publicKeyDataRef.get()).length == (1 + 2 * ES256KeySizeInBytes)); // 04 | X | Y

                auto cosePublicKey = cbor::CBORWriter::write(cbor::CBORValue(WTFMove(publicKeyMap)));
                if (!cosePublicKey) {
                    LOG_ERROR("Couldn't encode the public key into COSE binaries.");
                    callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                    return;
                }
                attestedCredentialData.appendVector(cosePublicKey.value());

                    auto retainError = adoptCF(errorRef);
                    if (errorRef) {
                        LOG_ERROR("Couldn't generate the signature: %@", (NSError*)errorRef);
                        callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                        return;
                    }
                    auto nsSignature = (NSData *)signatureRef.get();

            auto attestationObject = cbor::CBORWriter::write(cbor::CBORValue(WTFMove(attestationObjectMap)));
            if (!attestationObject) {
                LOG_ERROR("Couldn't encode the attestation object.");
                callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                return;
            }

            callback(PublicKeyCredentialData { ArrayBuffer::create(credentialId.data(), credentialId.size()), true, nullptr, ArrayBuffer::create(attestationObject.value().data(), attestationObject.value().size()), nullptr, nullptr, nullptr });
        }).get());
    }).get()];
#endif // !PLATFORM(IOS)
}

void LocalAuthenticator::getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions& options, Callback&& callback)
{
    using namespace LocalAuthenticatorInternal;


    ASSERT_UNUSED(hash, hash == hash);
    ASSERT_UNUSED(options, !options.rpId.isEmpty());
    ASSERT_UNUSED(callback, callback);
    callback(ExceptionData { NotAllowedError, "No avaliable authenticators."_s });
#else
    // The following implements https://www.w3.org/TR/webauthn/#op-get-assertion as of 5 December 2017.
    // Skip Step 2 as requireUserVerification is enforced.

    // Step 3-5. Unlike the spec, if an allow list is provided and there is no intersection between existing ones and the allow list, we always return NotAllowedError.
    HashSet<String> allowCredentialIds = produceHashSet(options.allowCredentials);
    if (!options.allowCredentials.isEmpty() && allowCredentialIds.isEmpty()) {
        callback(ExceptionData { NotAllowedError, "No matched credentials are found in the platform attached authenticator."_s });
        return;
    }


    OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &attributesArrayRef);
    if (status && status != errSecItemNotFound) {
        LOG_ERROR("Couldn't query Keychain: %d", status);
        callback(ExceptionData { UnknownError, "Unknown internal error."_s });
        return;
    }
    auto retainAttributesArray = adoptCF(attributesArrayRef);

        intersectedCredentialsAttributes = result;
    }
    if (!intersectedCredentialsAttributes.count) {
        callback(ExceptionData { NotAllowedError, "No matched credentials are found in the platform attached authenticator."_s });
        return;
    }


        auto retainContext = adoptNS(context);
        LOG_ERROR("Couldn't evaluate authentication with biometrics policy: %@", error);
        // FIXME(182767)
        callback(ExceptionData { NotAllowedError, "No avaliable authenticators."_s });
        return;
    }


    Vector<uint8_t> userhandle;
    NSData *nsUserhandle = selectedCredentialAttributes[(id)kSecAttrApplicationTag];
    userhandle.append(reinterpret_cast<const uint8_t*>(nsUserhandle.bytes), nsUserhandle.length);
    auto reply = BlockPtr<void(BOOL, NSError *)>::fromCallable([callback = WTFMove(callback), rpId = options.rpId.isolatedCopy(), hash, credentialId = WTFMove(credentialId), userhandle = WTFMove(userhandle), context = adoptNS(context)] (BOOL success, NSError *error) mutable {
        ASSERT(!isMainThread());
        if (!success || error) {
            LOG_ERROR("Couldn't authenticate with biometrics: %@", error);
            callback(ExceptionData { NotAllowedError, "Couldn't get user consent."_s });
            return;
        }


            OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &privateKeyRef);
            if (status) {
                LOG_ERROR("Couldn't get the private key reference: %d", status);
                callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                return;
            }
            auto privateKey = adoptCF(privateKeyRef);

            auto retainError = adoptCF(errorRef);
            if (errorRef) {
                LOG_ERROR("Couldn't generate the signature: %@", (NSError*)errorRef);
                callback(ExceptionData { UnknownError, "Unknown internal error."_s });
                return;
            }
            auto nsSignature = (NSData *)signatureRef.get();

        }

        // Step 13.
        callback(PublicKeyCredentialData { ArrayBuffer::create(credentialId.data(), credentialId.size()), false, nullptr, nullptr, ArrayBuffer::create(authData.data(), authData.size()), ArrayBuffer::create(signature.data(), signature.size()), ArrayBuffer::create(userhandle.data(), userhandle.size()) });
    });

    // FIXME(183533): Use userhandle instead of username due to the stated Keychain limitations.




Modules/credentialmanagement/BasicCredential.cpp
Modules/credentialmanagement/CredentialsContainer.cpp
Modules/credentialmanagement/CredentialsMessenger.cpp
Modules/credentialmanagement/NavigatorCredentials.cpp

Modules/entriesapi/ErrorCallback.cpp

Modules/webaudio/WaveShaperNode.cpp
Modules/webaudio/WaveShaperProcessor.cpp

Modules/webauthn/AuthenticatorCoordinator.cpp
Modules/webauthn/AuthenticatorCoordinatorClient.cpp
Modules/webauthn/AuthenticatorManager.cpp
Modules/webauthn/AuthenticatorResponse.cpp
Modules/webauthn/PublicKeyCredential.cpp
Modules/webauthn/cbor/CBORReader.cpp
Modules/webauthn/cbor/CBORValue.cpp



		57303C222009AF0300355965 /* JSAuthenticatorAttestationResponse.h in Headers */ = {isa = PBXBuildFile; fileRef = 57303C212009AEF600355965 /* JSAuthenticatorAttestationResponse.h */; };
		57303C2C2009B4A800355965 /* AuthenticatorAssertionResponse.h in Headers */ = {isa = PBXBuildFile; fileRef = 57303C272009B2FC00355965 /* AuthenticatorAssertionResponse.h */; };
		57303C2F2009B7E100355965 /* JSAuthenticatorAssertionResponse.h in Headers */ = {isa = PBXBuildFile; fileRef = 57303C2D2009B7D900355965 /* JSAuthenticatorAssertionResponse.h */; };
		57303C4620105D2F00355965 /* AuthenticatorCoordinator.h in Headers */ = {isa = PBXBuildFile; fileRef = 57303C4320105B3D00355965 /* AuthenticatorCoordinator.h */; settings = {ATTRIBUTES = (Private, ); }; };
		573489391DAC6B6E00DC0667 /* CryptoAlgorithmParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 573489381DAC6B6D00DC0667 /* CryptoAlgorithmParameters.h */; };
		5739E12F1DAC7F7800E14383 /* JSCryptoAlgorithmParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 5739E12E1DAC7F7800E14383 /* JSCryptoAlgorithmParameters.h */; };
		574F55E0204F3ACE002948C6 /* LocalAuthenticator.h in Headers */ = {isa = PBXBuildFile; fileRef = 574F55DE204F3744002948C6 /* LocalAuthenticator.h */; settings = {ATTRIBUTES = (Private, ); }; };

		5750A9821E6A150800705C4A /* JSEcKeyParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 5750A9801E6A150800705C4A /* JSEcKeyParams.h */; };
		5750A9871E6A216800705C4A /* CryptoAlgorithmECDH.h in Headers */ = {isa = PBXBuildFile; fileRef = 5750A9851E6A216800705C4A /* CryptoAlgorithmECDH.h */; };
		5754719F1ECE628300DD63B2 /* JSRsaPssParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 575471991ECE5D2A00DD63B2 /* JSRsaPssParams.h */; };
		5760827220215A5500116678 /* AuthenticatorCoordinatorClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 576082702021513F00116678 /* AuthenticatorCoordinatorClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
		5760827A2024EA5C00116678 /* MockAuthenticatorCoordinator.h in Headers */ = {isa = PBXBuildFile; fileRef = 5760827820244DAB00116678 /* MockAuthenticatorCoordinator.h */; };
		5760827B2024ED2900116678 /* MockAuthenticatorCoordinator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5760827920244DAC00116678 /* MockAuthenticatorCoordinator.cpp */; };
		5760828620256AFA00116678 /* JSMockCredentialsMessenger.h in Headers */ = {isa = PBXBuildFile; fileRef = 576082822025679700116678 /* JSMockCredentialsMessenger.h */; };
		5760828820256AFD00116678 /* JSMockCredentialsMessenger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 576082812025679600116678 /* JSMockCredentialsMessenger.cpp */; };
		5768142A1E6F99C100E77754 /* CryptoAlgorithmEcdhKeyDeriveParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 576814291E6F99C100E77754 /* CryptoAlgorithmEcdhKeyDeriveParams.h */; };
		576814411E709FA400E77754 /* JSEcdhKeyDeriveParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 5768143E1E709C3600E77754 /* JSEcdhKeyDeriveParams.h */; };
		576814451E70CB1F00E77754 /* JSAesKeyParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 576814431E70CB1000E77754 /* JSAesKeyParams.h */; };

		57B5F7F91E5BE84000F34F90 /* CryptoAlgorithmAES_GCM.h in Headers */ = {isa = PBXBuildFile; fileRef = 57B5F7F71E5BE84000F34F90 /* CryptoAlgorithmAES_GCM.h */; };
		57B5F8091E5D1A9800F34F90 /* CryptoAlgorithmAesGcmParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 57B5F8081E5D1A9800F34F90 /* CryptoAlgorithmAesGcmParams.h */; };
		57B5F8101E5E2A4E00F34F90 /* JSAesGcmParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 57B5F80B1E5D22DA00F34F90 /* JSAesGcmParams.h */; };
		57C7A68C1E56967500C67D71 /* BasicCredential.h in Headers */ = {isa = PBXBuildFile; fileRef = 57C7A68B1E56967500C67D71 /* BasicCredential.h */; settings = {ATTRIBUTES = (Private, ); }; };
		57C7A69F1E57917800C67D71 /* JSBasicCredential.h in Headers */ = {isa = PBXBuildFile; fileRef = 57C7A69D1E57910D00C67D71 /* JSBasicCredential.h */; };
		57D0018D1DD5413200ED19D9 /* JSCryptoKeyUsage.h in Headers */ = {isa = PBXBuildFile; fileRef = 57D0018C1DD5413200ED19D9 /* JSCryptoKeyUsage.h */; };
		57D846281FE8960500CA3682 /* NavigatorCredentials.h in Headers */ = {isa = PBXBuildFile; fileRef = 57D846261FE895F800CA3682 /* NavigatorCredentials.h */; };
		57D8462E1FEAF69900CA3682 /* PublicKeyCredential.h in Headers */ = {isa = PBXBuildFile; fileRef = 57D8462B1FEAF68F00CA3682 /* PublicKeyCredential.h */; settings = {ATTRIBUTES = (Private, ); }; };
		57D846351FEAFCD300CA3682 /* JSPublicKeyCredential.h in Headers */ = {isa = PBXBuildFile; fileRef = 57D846301FEAFC2F00CA3682 /* JSPublicKeyCredential.h */; };
		57DCED672140775B0016B847 /* JSMockAuthenticatorCoordinator.h in Headers */ = {isa = PBXBuildFile; fileRef = 57DCED622140763C0016B847 /* JSMockAuthenticatorCoordinator.h */; };
		57DCED69214077640016B847 /* JSMockAuthenticatorCoordinator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 57DCED632140763C0016B847 /* JSMockAuthenticatorCoordinator.cpp */; };
		57DCED74214305F00016B847 /* PublicKeyCredentialData.h in Headers */ = {isa = PBXBuildFile; fileRef = 57DCED72214305F00016B847 /* PublicKeyCredentialData.h */; settings = {ATTRIBUTES = (Private, ); }; };
		57E1E5A31E8C91B500EE37C9 /* CryptoAlgorithmAES_CTR.h in Headers */ = {isa = PBXBuildFile; fileRef = 57E1E5A11E8C91B500EE37C9 /* CryptoAlgorithmAES_CTR.h */; };
		57E1E5A71E8DBD3E00EE37C9 /* CryptoAlgorithmAesCtrParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 57E1E5A61E8DBD3E00EE37C9 /* CryptoAlgorithmAesCtrParams.h */; };
		57E1E5AD1E8DD09B00EE37C9 /* JSAesCtrParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 57E1E5AB1E8DD09B00EE37C9 /* JSAesCtrParams.h */; };

		57303BBE2006E00400355965 /* CBORReader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CBORReader.cpp; sourceTree = "<group>"; };
		57303BBF2006E00C00355965 /* CBORReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CBORReader.h; sourceTree = "<group>"; };
		57303BCF20087A8300355965 /* AuthenticatorResponse.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AuthenticatorResponse.h; sourceTree = "<group>"; };
		57303BD020087A8300355965 /* AuthenticatorResponse.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticatorResponse.cpp; sourceTree = "<group>"; };
		57303BD120087A8300355965 /* AuthenticatorResponse.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = AuthenticatorResponse.idl; sourceTree = "<group>"; };
		57303BDD20095B2600355965 /* JSAuthenticatorResponse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAuthenticatorResponse.h; sourceTree = "<group>"; };
		57303BDE20095B2700355965 /* JSAuthenticatorResponse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAuthenticatorResponse.cpp; sourceTree = "<group>"; };

		57303C132009A25700355965 /* JSPublicKeyCredentialCreationOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSPublicKeyCredentialCreationOptions.h; sourceTree = "<group>"; };
		57303C142009A25700355965 /* JSPublicKeyCredentialCreationOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPublicKeyCredentialCreationOptions.cpp; sourceTree = "<group>"; };
		57303C1B2009A98600355965 /* AuthenticatorAttestationResponse.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AuthenticatorAttestationResponse.h; sourceTree = "<group>"; };
		57303C1C2009A98600355965 /* AuthenticatorAttestationResponse.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticatorAttestationResponse.cpp; sourceTree = "<group>"; };
		57303C1D2009A98600355965 /* AuthenticatorAttestationResponse.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = AuthenticatorAttestationResponse.idl; sourceTree = "<group>"; };
		57303C202009AEF500355965 /* JSAuthenticatorAttestationResponse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAuthenticatorAttestationResponse.cpp; sourceTree = "<group>"; };
		57303C212009AEF600355965 /* JSAuthenticatorAttestationResponse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAuthenticatorAttestationResponse.h; sourceTree = "<group>"; };
		57303C272009B2FC00355965 /* AuthenticatorAssertionResponse.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AuthenticatorAssertionResponse.h; sourceTree = "<group>"; };
		57303C282009B2FC00355965 /* AuthenticatorAssertionResponse.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticatorAssertionResponse.cpp; sourceTree = "<group>"; };
		57303C292009B2FC00355965 /* AuthenticatorAssertionResponse.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = AuthenticatorAssertionResponse.idl; sourceTree = "<group>"; };
		57303C2D2009B7D900355965 /* JSAuthenticatorAssertionResponse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAuthenticatorAssertionResponse.h; sourceTree = "<group>"; };
		57303C2E2009B7DA00355965 /* JSAuthenticatorAssertionResponse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAuthenticatorAssertionResponse.cpp; sourceTree = "<group>"; };
		57303C4320105B3D00355965 /* AuthenticatorCoordinator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AuthenticatorCoordinator.h; sourceTree = "<group>"; };
		57303C4420105B3D00355965 /* AuthenticatorCoordinator.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticatorCoordinator.cpp; sourceTree = "<group>"; };
		573489381DAC6B6D00DC0667 /* CryptoAlgorithmParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmParameters.h; sourceTree = "<group>"; };
		5739E12E1DAC7F7800E14383 /* JSCryptoAlgorithmParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCryptoAlgorithmParameters.h; sourceTree = "<group>"; };
		5739E1301DAC7FD100E14383 /* JSCryptoAlgorithmParameters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCryptoAlgorithmParameters.cpp; sourceTree = "<group>"; };

		5754719A1ECE5D2A00DD63B2 /* JSRsaPssParams.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRsaPssParams.cpp; sourceTree = "<group>"; };
		5760824F20118D8D00116678 /* JSBasicCredentialCustom.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JSBasicCredentialCustom.cpp; sourceTree = "<group>"; };
		576082562011BE0200116678 /* JSAuthenticatorResponseCustom.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JSAuthenticatorResponseCustom.cpp; sourceTree = "<group>"; };
		576082702021513F00116678 /* AuthenticatorCoordinatorClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AuthenticatorCoordinatorClient.h; sourceTree = "<group>"; };
		5760827820244DAB00116678 /* MockAuthenticatorCoordinator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MockAuthenticatorCoordinator.h; sourceTree = "<group>"; };
		5760827920244DAC00116678 /* MockAuthenticatorCoordinator.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = MockAuthenticatorCoordinator.cpp; sourceTree = "<group>"; };
		57608280202556F400116678 /* MockAuthenticatorCoordinator.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = MockAuthenticatorCoordinator.idl; sourceTree = "<group>"; };
		57608293202BA95300116678 /* AuthenticatorCoordinatorClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticatorCoordinatorClient.cpp; sourceTree = "<group>"; };
		576082822025679700116678 /* JSMockCredentialsMessenger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSMockCredentialsMessenger.h; sourceTree = "<group>"; };
		57608293202BA95300116678 /* CredentialsMessenger.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CredentialsMessenger.cpp; sourceTree = "<group>"; };
		576814281E6F98AD00E77754 /* EcdhKeyDeriveParams.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = EcdhKeyDeriveParams.idl; sourceTree = "<group>"; };
		576814291E6F99C100E77754 /* CryptoAlgorithmEcdhKeyDeriveParams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmEcdhKeyDeriveParams.h; sourceTree = "<group>"; };
		576814341E6FE3E800E77754 /* CryptoAlgorithmECDHMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoAlgorithmECDHMac.cpp; sourceTree = "<group>"; };

		57D8462D1FEAF68F00CA3682 /* PublicKeyCredential.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = PublicKeyCredential.idl; sourceTree = "<group>"; };
		57D846301FEAFC2F00CA3682 /* JSPublicKeyCredential.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSPublicKeyCredential.h; sourceTree = "<group>"; };
		57D846311FEAFC2F00CA3682 /* JSPublicKeyCredential.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPublicKeyCredential.cpp; sourceTree = "<group>"; };
		57DCED622140763C0016B847 /* JSMockAuthenticatorCoordinator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSMockAuthenticatorCoordinator.h; sourceTree = "<group>"; };
		57DCED632140763C0016B847 /* JSMockAuthenticatorCoordinator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSMockAuthenticatorCoordinator.cpp; sourceTree = "<group>"; };
		57DCED72214305F00016B847 /* PublicKeyCredentialData.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PublicKeyCredentialData.h; sourceTree = "<group>"; };
		57E1E5A01E8C91B500EE37C9 /* CryptoAlgorithmAES_CTR.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoAlgorithmAES_CTR.cpp; sourceTree = "<group>"; };
		57E1E5A11E8C91B500EE37C9 /* CryptoAlgorithmAES_CTR.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmAES_CTR.h; sourceTree = "<group>"; };
		57E1E5A61E8DBD3E00EE37C9 /* CryptoAlgorithmAesCtrParams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmAesCtrParams.h; sourceTree = "<group>"; };

				A7BE7EDE14C9175A0014489D /* MallocStatistics.idl */,
				CD5393CB175DCCE600C07123 /* MemoryInfo.h */,
				CD5393CC175DCCE600C07123 /* MemoryInfo.idl */,
				5760827920244DAC00116678 /* MockAuthenticatorCoordinator.cpp */,
				5760827820244DAB00116678 /* MockAuthenticatorCoordinator.h */,
				57608280202556F400116678 /* MockAuthenticatorCoordinator.idl */,
				CDF4B7211E03BF8100E235A2 /* MockCDMFactory.cpp */,
				CDF4B7221E03BF8100E235A2 /* MockCDMFactory.h */,
				CDF4B71F1E03BF6F00E235A2 /* MockCDMFactory.idl */,

				A1B5B29C1AAA846E008B6042 /* MockContentFilterSettings.cpp */,
				A1B5B29D1AAA846E008B6042 /* MockContentFilterSettings.h */,
				A19AEA1C1AAA7C4900B52B25 /* MockContentFilterSettings.idl */,
				5760827920244DAC00116678 /* MockCredentialsMessenger.cpp */,
				5760827820244DAB00116678 /* MockCredentialsMessenger.h */,
				57608280202556F400116678 /* MockCredentialsMessenger.idl */,
				51058AD71D679257009A538C /* MockGamepad.cpp */,
				51058AD81D679257009A538C /* MockGamepad.h */,
				51058AD91D679257009A538C /* MockGamepadProvider.cpp */,

				A7B4EA6914C9348400C8F5BF /* JSMallocStatistics.h */,
				CD5393D1175E018600C07123 /* JSMemoryInfo.cpp */,
				CD5393D2175E018600C07123 /* JSMemoryInfo.h */,
				57DCED632140763C0016B847 /* JSMockAuthenticatorCoordinator.cpp */,
				57DCED622140763C0016B847 /* JSMockAuthenticatorCoordinator.h */,
				CDF4B72D1E03CA4A00E235A2 /* JSMockCDMFactory.cpp */,
				CDF4B72E1E03CA4A00E235A2 /* JSMockCDMFactory.h */,
				A19AEA1D1AAA806E00B52B25 /* JSMockContentFilterSettings.cpp */,
				A19AEA1E1AAA806E00B52B25 /* JSMockContentFilterSettings.h */,
				576082812025679600116678 /* JSMockCredentialsMessenger.cpp */,
				576082822025679700116678 /* JSMockCredentialsMessenger.h */,
				2D6F3E921C1F85550061DBD4 /* JSMockPageOverlay.cpp */,
				2D6F3E931C1F85550061DBD4 /* JSMockPageOverlay.h */,
				A146D3201F99CA3E00D29196 /* JSMockPaymentAddress.cpp */,

				77D510181ED7159900DA4C87 /* CredentialsContainer.cpp */,
				77D510161ED6021B00DA4C87 /* CredentialsContainer.h */,
				57D846291FE99F6300CA3682 /* CredentialsContainer.idl */,
				57608293202BA95300116678 /* CredentialsMessenger.cpp */,
				576082702021513F00116678 /* CredentialsMessenger.h */,
				57D846241FE895F500CA3682 /* NavigatorCredentials.cpp */,
				57D846261FE895F800CA3682 /* NavigatorCredentials.h */,
				57D846251FE895F600CA3682 /* NavigatorCredentials.idl */,

			children = (
				57303BB32006C6ED00355965 /* cbor */,
				574F55DD204F3744002948C6 /* cocoa */,
				57303C282009B2FC00355965 /* AuthenticatorAssertionResponse.cpp */,
				57303C272009B2FC00355965 /* AuthenticatorAssertionResponse.h */,
				57303C292009B2FC00355965 /* AuthenticatorAssertionResponse.idl */,
				57303C1C2009A98600355965 /* AuthenticatorAttestationResponse.cpp */,
				57303C1B2009A98600355965 /* AuthenticatorAttestationResponse.h */,
				57303C1D2009A98600355965 /* AuthenticatorAttestationResponse.idl */,
				57303C4420105B3D00355965 /* AuthenticatorCoordinator.cpp */,
				57303C4320105B3D00355965 /* AuthenticatorCoordinator.h */,
				57608293202BA95300116678 /* AuthenticatorCoordinatorClient.cpp */,
				576082702021513F00116678 /* AuthenticatorCoordinatorClient.h */,
				57303BCF20087A8300355965 /* AuthenticatorResponse.h */,
				57303BD120087A8300355965 /* AuthenticatorResponse.idl */,
				574F55DC204F3732002948C6 /* COSEConstants.h */,

				57D8462D1FEAF68F00CA3682 /* PublicKeyCredential.idl */,
				57303BE62009747A00355965 /* PublicKeyCredentialCreationOptions.h */,
				57303BE82009747A00355965 /* PublicKeyCredentialCreationOptions.idl */,
				57DCED72214305F00016B847 /* PublicKeyCredentialData.h */,
				57303BEC200980BF00355965 /* PublicKeyCredentialDescriptor.h */,
				57303BEE200980BF00355965 /* PublicKeyCredentialDescriptor.idl */,
				57303C06200998F800355965 /* PublicKeyCredentialRequestOptions.h */,

				53ED3FDF167A88E7006762E6 /* JSInternalSettingsGenerated.h in Headers */,
				A740B59514C935AB00A77FA4 /* JSMallocStatistics.h in Headers */,
				CD5393D4175E018600C07123 /* JSMemoryInfo.h in Headers */,
				57DCED672140775B0016B847 /* JSMockAuthenticatorCoordinator.h in Headers */,
				538EC9331F99B9F7004D22A8 /* JSMockCDMFactory.h in Headers */,
				A19AEA211AAA808600B52B25 /* JSMockContentFilterSettings.h in Headers */,
				5760828620256AFA00116678 /* JSMockCredentialsMessenger.h in Headers */,
				538EC9341F99B9F7004D22A8 /* JSMockPageOverlay.h in Headers */,
				A146D3231F99D0EF00D29196 /* JSMockPaymentAddress.h in Headers */,
				A146D31B1F99BCFB00D29196 /* JSMockPaymentCoordinator.h in Headers */,
				427DA71E13735DFA007C57FB /* JSServiceWorkerInternals.h in Headers */,
				EBF5121D1696496C0056BD25 /* JSTypeConversions.h in Headers */,
				CDC26B41160A8CCE0026757B /* LegacyMockCDM.h in Headers */,
				5760827A2024EA5C00116678 /* MockAuthenticatorCoordinator.h in Headers */,
				A1BF6B831AA96C7D00AF4A8A /* MockContentFilter.h in Headers */,
				A1B5B29F1AAA846F008B6042 /* MockContentFilterSettings.h in Headers */,
				5760827A2024EA5C00116678 /* MockCredentialsMessenger.h in Headers */,
				51058ADC1D6792C1009A538C /* MockGamepad.h in Headers */,
				51058ADE1D6792C1009A538C /* MockGamepadProvider.h in Headers */,
				4157EBFB1E3AB67F00AC9FE9 /* MockLibWebRTCPeerConnection.h in Headers */,

				514C764C0CE9234E007EF3CD /* AuthenticationMac.h in Headers */,
				57303C2C2009B4A800355965 /* AuthenticatorAssertionResponse.h in Headers */,
				57303C1F2009AB4200355965 /* AuthenticatorAttestationResponse.h in Headers */,
				57303C4620105D2F00355965 /* AuthenticatorCoordinator.h in Headers */,
				5760827220215A5500116678 /* AuthenticatorCoordinatorClient.h in Headers */,
				57303BD220087A8300355965 /* AuthenticatorResponse.h in Headers */,
				A501920E132EBF2E008BFE55 /* Autocapitalize.h in Headers */,
				A5A7AA43132F0ECC00D3A3C2 /* AutocapitalizeTypes.h in Headers */,

				77D5100D1ED5E29500DA4C87 /* CredentialCreationOptions.h in Headers */,
				77D5100B1ED5E28800DA4C87 /* CredentialRequestOptions.h in Headers */,
				77D510171ED6022200DA4C87 /* CredentialsContainer.h in Headers */,
				5760827220215A5500116678 /* CredentialsMessenger.h in Headers */,
				51A052331058774F00CC9E95 /* CredentialStorage.h in Headers */,
				2D481F02146B5C5500AA7834 /* CrossfadeGeneratedImage.h in Headers */,
				E1C416120F6562FD0092D2FB /* CrossOriginAccessControl.h in Headers */,

				FF945ECC161F7F3600971BC8 /* PseudoElement.h in Headers */,
				57D8462E1FEAF69900CA3682 /* PublicKeyCredential.h in Headers */,
				57303BE92009748D00355965 /* PublicKeyCredentialCreationOptions.h in Headers */,
				57DCED74214305F00016B847 /* PublicKeyCredentialData.h in Headers */,
				57303BEF200980C600355965 /* PublicKeyCredentialDescriptor.h in Headers */,
				57303C0A20099BAD00355965 /* PublicKeyCredentialRequestOptions.h in Headers */,
				57303BEB20097F4000355965 /* PublicKeyCredentialType.h in Headers */,

				53ED3FDE167A88E7006762E6 /* JSInternalSettingsGenerated.cpp in Sources */,
				538EC9321F99B9F7004D22A8 /* JSMallocStatistics.cpp in Sources */,
				CD5393D3175E018600C07123 /* JSMemoryInfo.cpp in Sources */,
				57DCED69214077640016B847 /* JSMockAuthenticatorCoordinator.cpp in Sources */,
				CDF4B7321E03D06000E235A2 /* JSMockCDMFactory.cpp in Sources */,
				A19AEA221AAA808A00B52B25 /* JSMockContentFilterSettings.cpp in Sources */,
				5760828820256AFD00116678 /* JSMockCredentialsMessenger.cpp in Sources */,
				2D4150DE1C1F868C000A3BA2 /* JSMockPageOverlay.cpp in Sources */,
				A146D3221F99D0EC00D29196 /* JSMockPaymentAddress.cpp in Sources */,
				A146D31A1F99BCF800D29196 /* JSMockPaymentCoordinator.cpp in Sources */,
				427DA71D13735DFA007C57FB /* JSServiceWorkerInternals.cpp in Sources */,
				EBF5121C1696496C0056BD25 /* JSTypeConversions.cpp in Sources */,
				CDC26B40160A8CC60026757B /* LegacyMockCDM.cpp in Sources */,
				5760827B2024ED2900116678 /* MockAuthenticatorCoordinator.cpp in Sources */,
				CDF4B7311E03D00700E235A2 /* MockCDMFactory.cpp in Sources */,
				A1BF6B821AA96C7D00AF4A8A /* MockContentFilter.cpp in Sources */,
				A1B5B29E1AAA846E008B6042 /* MockContentFilterSettings.cpp in Sources */,
				5760827B2024ED2900116678 /* MockCredentialsMessenger.cpp in Sources */,
				51058ADB1D6792C1009A538C /* MockGamepad.cpp in Sources */,
				51058ADD1D6792C1009A538C /* MockGamepadProvider.cpp in Sources */,
				4157EBFA1E3AB67900AC9FE9 /* MockLibWebRTCPeerConnection.cpp in Sources */,

Lines 24-29 a/Source/WebCore/page/Page.cpp_sec1
- a/Source/WebCore/page/Page.cpp +4 lines
24	#include "AlternativeTextClient.h"	24	#include "AlternativeTextClient.h"
25	#include "ApplicationCacheStorage.h"	25	#include "ApplicationCacheStorage.h"
26	#include "ApplicationStateChangeListener.h"	26	#include "ApplicationStateChangeListener.h"
		27	#include "AuthenticatorCoordinator.h"
27	#include "BackForwardClient.h"	28	#include "BackForwardClient.h"
28	#include "BackForwardController.h"	29	#include "BackForwardController.h"
29	#include "CSSAnimationController.h"	30	#include "CSSAnimationController.h"
Lines 255-260 Page::Page(PageConfiguration&& pageConfiguration) a/Source/WebCore/page/Page.cpp_sec2
255	#if ENABLE(APPLE_PAY)	256	#if ENABLE(APPLE_PAY)
256	, m_paymentCoordinator(std::make_unique<PaymentCoordinator>(*pageConfiguration.paymentCoordinatorClient))	257	, m_paymentCoordinator(std::make_unique<PaymentCoordinator>(*pageConfiguration.paymentCoordinatorClient))
257	#endif	258	#endif
		259	#if ENABLE(WEB_AUTHN)
		260	, m_authenticatorCoordinator(makeUniqueRef<AuthenticatorCoordinator>(WTFMove(pageConfiguration.authenticatorCoordinatorClient)))
		261	#endif
258	#if ENABLE(APPLICATION_MANIFEST)	262	#if ENABLE(APPLICATION_MANIFEST)
259	, m_applicationManifest(pageConfiguration.applicationManifest)	263	, m_applicationManifest(pageConfiguration.applicationManifest)
260	#endif	264	#endif

Lines 76-81 class IDBConnectionToServer; a/Source/WebCore/page/Page.h_sec1
- a/Source/WebCore/page/Page.h +9 lines
76		76
77	class AlternativeTextClient;	77	class AlternativeTextClient;
78	class ApplicationCacheStorage;	78	class ApplicationCacheStorage;
		79	class AuthenticatorCoordinator;
79	class BackForwardController;	80	class BackForwardController;
80	class BackForwardClient;	81	class BackForwardClient;
81	class CacheStorageProvider;	82	class CacheStorageProvider;
Lines 410-415 public: a/Source/WebCore/page/Page.h_sec2
410	WEBCORE_EXPORT void setPaymentCoordinator(std::unique_ptr<PaymentCoordinator>&&);	411	WEBCORE_EXPORT void setPaymentCoordinator(std::unique_ptr<PaymentCoordinator>&&);
411	#endif	412	#endif
412		413
		414	#if ENABLE(WEB_AUTHN)
		415	AuthenticatorCoordinator& authenticatorCoordinator() { return m_authenticatorCoordinator.get(); }
		416	#endif
		417
413	#if ENABLE(APPLICATION_MANIFEST)	418	#if ENABLE(APPLICATION_MANIFEST)
414	const std::optional<ApplicationManifest>& applicationManifest() const { return m_applicationManifest; }	419	const std::optional<ApplicationManifest>& applicationManifest() const { return m_applicationManifest; }
415	#endif	420	#endif
Lines 901-906 private: a/Source/WebCore/page/Page.h_sec3
901	std::unique_ptr<PaymentCoordinator> m_paymentCoordinator;	906	std::unique_ptr<PaymentCoordinator> m_paymentCoordinator;
902	#endif	907	#endif
903		908
		909	#if ENABLE(WEB_AUTHN)
		910	UniqueRef<AuthenticatorCoordinator> m_authenticatorCoordinator;
		911	#endif
		912
904	#if ENABLE(APPLICATION_MANIFEST)	913	#if ENABLE(APPLICATION_MANIFEST)
905	std::optional<ApplicationManifest> m_applicationManifest;	914	std::optional<ApplicationManifest> m_applicationManifest;
906	#endif	915	#endif

Lines 42-47 a/Source/WebCore/page/PageConfiguration.cpp_sec1
- a/Source/WebCore/page/PageConfiguration.cpp +4 lines
42	#include "VisitedLinkStore.h"	42	#include "VisitedLinkStore.h"
43	#include "WebGLStateTracker.h"	43	#include "WebGLStateTracker.h"
44		44
		45	#if ENABLE(WEB_AUTHN)
		46	#include "AuthenticatorCoordinatorClient.h"
		47	#endif
		48
45	namespace WebCore {	49	namespace WebCore {
46		50
47	PageConfiguration::PageConfiguration(UniqueRef<EditorClient>&& editorClient, Ref<SocketProvider>&& socketProvider, UniqueRef<LibWebRTCProvider>&& libWebRTCProvider, Ref<CacheStorageProvider>&& cacheStorageProvider)	51	PageConfiguration::PageConfiguration(UniqueRef<EditorClient>&& editorClient, Ref<SocketProvider>&& socketProvider, UniqueRef<LibWebRTCProvider>&& libWebRTCProvider, Ref<CacheStorageProvider>&& cacheStorageProvider)

Lines 38-43 namespace WebCore { a/Source/WebCore/page/PageConfiguration.h_sec1
- a/Source/WebCore/page/PageConfiguration.h +5 lines
38		38
39	class AlternativeTextClient;	39	class AlternativeTextClient;
40	class ApplicationCacheStorage;	40	class ApplicationCacheStorage;
		41	class AuthenticatorCoordinatorClient;
41	class BackForwardClient;	42	class BackForwardClient;
42	class CacheStorageProvider;	43	class CacheStorageProvider;
43	class ChromeClient;	44	class ChromeClient;
Lines 80-85 public: a/Source/WebCore/page/PageConfiguration.h_sec2
80	PaymentCoordinatorClient* paymentCoordinatorClient { nullptr };	81	PaymentCoordinatorClient* paymentCoordinatorClient { nullptr };
81	#endif	82	#endif
82		83
		84	#if ENABLE(WEB_AUTHN)
		85	std::unique_ptr<AuthenticatorCoordinatorClient> authenticatorCoordinatorClient;
		86	#endif
		87
83	#if ENABLE(APPLICATION_MANIFEST)	88	#if ENABLE(APPLICATION_MANIFEST)
84	std::optional<ApplicationManifest> applicationManifest;	89	std::optional<ApplicationManifest> applicationManifest;
85	#endif	90	#endif



#endif

#if ENABLE(WEB_AUTHN)
#include "AuthenticatorCoordinator.h"
#include "MockAuthenticatorCoordinator.h"
#endif

using JSC::CallData;

#endif

#if ENABLE(WEB_AUTHN)
    if (document.page()) {
        auto mockAuthenticatorCoordinator = std::make_unique<MockAuthenticatorCoordinator>();
        m_mockAuthenticatorCoordinator = makeWeakPtr(mockAuthenticatorCoordinator.get());
        document.page()->authenticatorCoordinator().setClient(WTFMove(mockAuthenticatorCoordinator));
    }
#endif
}


#endif

#if ENABLE(WEB_AUTHN)
MockAuthenticatorCoordinator& Internals::mockAuthenticatorCoordinator() const
{
    return *m_mockAuthenticatorCoordinator;
}
#endif




class MemoryInfo;
class MockCDMFactory;
class MockContentFilterSettings;
class MockAuthenticatorCoordinator;
class MockPageOverlay;
class MockPaymentCoordinator;
class NodeList;

    void testIncomingSyncIPCMessageWhileWaitingForSyncReply();

#if ENABLE(WEB_AUTHN)
    MockAuthenticatorCoordinator& mockAuthenticatorCoordinator() const;
#endif

    bool isSystemPreviewLink(Element&) const;

#endif

#if ENABLE(WEB_AUTHN)
    WeakPtr<MockAuthenticatorCoordinator> m_mockAuthenticatorCoordinator;
#endif
};


Lines 646-652 enum CompositingPolicy { a/Source/WebCore/testing/Internals.idl_sec1
- a/Source/WebCore/testing/Internals.idl -1 / +1 lines
646	[EnabledAtRuntime=WebAnimations] void pauseTimeline(AnimationTimeline timeline);	646	[EnabledAtRuntime=WebAnimations] void pauseTimeline(AnimationTimeline timeline);
647	[EnabledAtRuntime=WebAnimations] void setTimelineCurrentTime(AnimationTimeline timeline, double currentTime);	647	[EnabledAtRuntime=WebAnimations] void setTimelineCurrentTime(AnimationTimeline timeline, double currentTime);
648	[Conditional=APPLE_PAY] readonly attribute MockPaymentCoordinator mockPaymentCoordinator;	648	[Conditional=APPLE_PAY] readonly attribute MockPaymentCoordinator mockPaymentCoordinator;
649	[Conditional=WEB_AUTHN] readonly attribute MockCredentialsMessenger mockCredentialsMessenger;	649	[Conditional=WEB_AUTHN] readonly attribute MockAuthenticatorCoordinator mockAuthenticatorCoordinator;
650		650
651	boolean isSystemPreviewLink(Element element);	651	boolean isSystemPreviewLink(Element element);
652	boolean isSystemPreviewImage(Element element);	652	boolean isSystemPreviewImage(Element element);



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "MockAuthenticatorCoordinator.h"

#if ENABLE(WEB_AUTHN)

#include "Internals.h"
#include <WebCore/PublicKeyCredentialData.h>
#include <wtf/Vector.h>

namespace WebCore {

void MockAuthenticatorCoordinator::setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject)
{
    ASSERT(!m_credentialId && !m_attestationObject);
    m_credentialId = ArrayBuffer::create(credentialId.data(), credentialId.length());
    m_attestationObject = ArrayBuffer::create(attestationObject.data(), attestationObject.length());
}

void MockAuthenticatorCoordinator::setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle)
{
    ASSERT(!m_credentialId && !m_authenticatorData && !m_signature && !m_userHandle);
    m_credentialId = ArrayBuffer::create(credentialId.data(), credentialId.length());
    m_authenticatorData = ArrayBuffer::create(authenticatorData.data(), authenticatorData.length());
    m_signature = ArrayBuffer::create(signature.data(), signature.length());
    m_userHandle = ArrayBuffer::create(userHandle.data(), userHandle.length());
}

void MockAuthenticatorCoordinator::makeCredential(const Vector<uint8_t>&, const PublicKeyCredentialCreationOptions&, RequestCompletionHandler&& handler)
{
    if (!setRequestCompletionHandler(WTFMove(handler)))
        return;

    if (m_didTimeOut) {
        m_didTimeOut = false;
        return;
    }
    if (m_didUserCancel) {
        m_didUserCancel = false;
        requestReply({ }, { NotAllowedError, "User cancelled."_s });
        return;
    }
    if (m_credentialId) {
        ASSERT(m_attestationObject);
        requestReply(PublicKeyCredentialData { WTFMove(m_credentialId), true, nullptr, WTFMove(m_attestationObject), nullptr, nullptr, nullptr }, { });
        m_credentialId = nullptr;
        m_attestationObject = nullptr;
        return;
    }
    ASSERT_NOT_REACHED();
}

void MockAuthenticatorCoordinator::getAssertion(const Vector<uint8_t>&, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&& handler)
{
    if (!setRequestCompletionHandler(WTFMove(handler)))
        return;

    if (m_didTimeOut) {
        m_didTimeOut = false;
        return;
    }
    if (m_didUserCancel) {
        m_didUserCancel = false;
        requestReply({ }, { NotAllowedError, "User cancelled."_s });
        return;
    }
    if (m_credentialId) {
        ASSERT(m_authenticatorData && m_signature && m_userHandle);
        requestReply(PublicKeyCredentialData { WTFMove(m_credentialId), false, nullptr, nullptr, WTFMove(m_authenticatorData), WTFMove(m_signature), WTFMove(m_userHandle) }, { });
        m_credentialId = nullptr;
        m_authenticatorData = nullptr;
        m_signature = nullptr;
        m_userHandle = nullptr;
        return;
    }
    ASSERT_NOT_REACHED();
}

void MockAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&& handler)
{
    auto messageId = addQueryCompletionHandler(WTFMove(handler));
    if (m_didUserVerifyingPlatformAuthenticatorPresent) {
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, true);
        m_didUserVerifyingPlatformAuthenticatorPresent = false;
    } else
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "AuthenticatorCoordinatorClient.h"
#include "BufferSource.h"
#include <wtf/Forward.h>

namespace WebCore {

class Internals;

class MockAuthenticatorCoordinator final : public AuthenticatorCoordinatorClient {
public:
    void setDidTimeOut() { m_didTimeOut = true; }
    void setDidUserCancel() { m_didUserCancel = true; }
    void setDidUserVerifyingPlatformAuthenticatorPresent() { m_didUserVerifyingPlatformAuthenticatorPresent = true; }
    void setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject);
    void setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle);

    // RefCounted is required for JS wrapper. Therefore, fake them to compile.
    void ref() const { }
    void deref() const { }

private:
    void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, RequestCompletionHandler&&) final;
    void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&&) final;
    void isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&&) final;

    // All following fields are disposable.
    bool m_didTimeOut { false };
    bool m_didUserCancel { false };
    bool m_didUserVerifyingPlatformAuthenticatorPresent { false };
    RefPtr<ArrayBuffer> m_credentialId;
    RefPtr<ArrayBuffer> m_attestationObject;
    RefPtr<ArrayBuffer> m_authenticatorData;
    RefPtr<ArrayBuffer> m_signature;
    RefPtr<ArrayBuffer> m_userHandle;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

[
    Conditional=WEB_AUTHN,
    NoInterfaceObject,
] interface MockAuthenticatorCoordinator {
    void setDidTimeOut();
    void setDidUserCancel();
    void setDidUserVerifyingPlatformAuthenticatorPresent();
    void setCreationReturnBundle(BufferSource credentialId, BufferSource attestationObject);
    void setAssertionReturnBundle(BufferSource credentialId, BufferSource authenticatorData, BufferSource signature, BufferSource userHandle);
};



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "MockCredentialsMessenger.h"

#if ENABLE(WEB_AUTHN)

#include "Internals.h"
#include <wtf/Vector.h>

namespace WebCore {

MockCredentialsMessenger::MockCredentialsMessenger(Internals& internals)
    : m_internals(internals)
{
}

MockCredentialsMessenger::~MockCredentialsMessenger()
{
    // Have no effects to original promises. Just to call handlers to avoid any assertion failures.
    for (auto messageId : m_timeOutMessageIds)
        exceptionReply(messageId, ExceptionData { NotAllowedError, "Operation timed out."_s });
}

void MockCredentialsMessenger::setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject)
{
    ASSERT(m_credentialId.isEmpty() && m_attestationObject.isEmpty());
    m_credentialId.append(credentialId.data(), credentialId.length());
    m_attestationObject.append(attestationObject.data(), attestationObject.length());
}

void MockCredentialsMessenger::setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle)
{
    ASSERT(m_credentialId.isEmpty() && m_authenticatorData.isEmpty() && m_signature.isEmpty() && m_userHandle.isEmpty());
    m_credentialId.append(credentialId.data(), credentialId.length());
    m_authenticatorData.append(authenticatorData.data(), authenticatorData.length());
    m_signature.append(signature.data(), signature.length());
    m_userHandle.append(userHandle.data(), userHandle.length());
}

void MockCredentialsMessenger::ref()
{
    m_internals.ref();
}

void MockCredentialsMessenger::deref()
{
    m_internals.deref();
}

void MockCredentialsMessenger::makeCredential(const Vector<uint8_t>&, const PublicKeyCredentialCreationOptions&, CreationCompletionHandler&& handler)
{
    auto messageId = addCreationCompletionHandler(WTFMove(handler));
    if (m_didTimeOut) {
        m_didTimeOut = false;
        m_timeOutMessageIds.append(messageId);
        return;
    }
    if (m_didUserCancel) {
        m_didUserCancel = false;
        exceptionReply(messageId, ExceptionData { NotAllowedError, "User cancelled."_s });
        return;
    }
    if (!m_credentialId.isEmpty()) {
        ASSERT(!m_attestationObject.isEmpty());
        makeCredentialReply(messageId, m_credentialId, m_attestationObject);
        m_credentialId.clear();
        m_attestationObject.clear();
        return;
    }
    ASSERT_NOT_REACHED();
}

void MockCredentialsMessenger::getAssertion(const Vector<uint8_t>&, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&& handler)
{
    auto messageId = addRequestCompletionHandler(WTFMove(handler));
    if (m_didTimeOut) {
        m_didTimeOut = false;
        m_timeOutMessageIds.append(messageId);
        return;
    }
    if (m_didUserCancel) {
        m_didUserCancel = false;
        exceptionReply(messageId, ExceptionData { NotAllowedError, "User cancelled."_s });
        return;
    }
    if (!m_credentialId.isEmpty()) {
        ASSERT(!m_authenticatorData.isEmpty() && !m_signature.isEmpty() && !m_userHandle.isEmpty());
        getAssertionReply(messageId, m_credentialId, m_authenticatorData, m_signature, m_userHandle);
        m_credentialId.clear();
        m_authenticatorData.clear();
        m_signature.clear();
        m_userHandle.clear();
        return;
    }
    ASSERT_NOT_REACHED();
}

void MockCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&& handler)
{
    auto messageId = addQueryCompletionHandler(WTFMove(handler));
    if (m_didUserVerifyingPlatformAuthenticatorPresent) {
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, true);
        m_didUserVerifyingPlatformAuthenticatorPresent = false;
    } else
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
}

void MockCredentialsMessenger::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
{
    auto handler = takeCreationCompletionHandler(messageId);
    handler(CreationReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(attestationObject.data(), attestationObject.size())));
}

void MockCredentialsMessenger::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
{
    auto handler = takeRequestCompletionHandler(messageId);
    handler(AssertionReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(authenticatorData.data(), authenticatorData.size()), ArrayBuffer::create(signature.data(), signature.size()), ArrayBuffer::create(userHandle.data(), userHandle.size())));
}

void MockCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
{
    auto handler = takeQueryCompletionHandler(messageId);
    handler(result);
}

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "BufferSource.h"
#include "CredentialsMessenger.h"
#include <wtf/Forward.h>

namespace WebCore {

class Internals;

class MockCredentialsMessenger final : public CredentialsMessenger {
public:
    explicit MockCredentialsMessenger(Internals&);
    ~MockCredentialsMessenger();

    void setDidTimeOut() { m_didTimeOut = true; }
    void setDidUserCancel() { m_didUserCancel = true; }
    void setDidUserVerifyingPlatformAuthenticatorPresent() { m_didUserVerifyingPlatformAuthenticatorPresent = true; }
    void setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject);
    void setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle);

    void ref();
    void deref();

private:
    void makeCredential(const Vector<uint8_t>&, const PublicKeyCredentialCreationOptions&, CreationCompletionHandler&&) final;
    void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&&) final;
    void isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&&) final;
    void makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject) final;
    void getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle) final;
    void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool) final;

    Internals& m_internals;
    // All following fields are disposable.
    bool m_didTimeOut { false };
    bool m_didUserCancel { false };
    bool m_didUserVerifyingPlatformAuthenticatorPresent { false };
    Vector<uint8_t> m_attestationObject;
    Vector<uint8_t> m_credentialId; // Overlapped between CreationReturnBundle and AssertionReturnBundle.
    Vector<uint8_t> m_authenticatorData;
    Vector<uint8_t> m_signature;
    Vector<uint8_t> m_userHandle;

    // To clean up completion handlers.
    Vector<uint64_t> m_timeOutMessageIds;
};

} // namespace WebCore

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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.
 */

[
    Conditional=WEB_AUTHN,
    NoInterfaceObject,
] interface MockCredentialsMessenger {
    void setDidTimeOut();
    void setDidUserCancel();
    void setDidUserVerifyingPlatformAuthenticatorPresent();
    void setCreationReturnBundle(BufferSource credentialId, BufferSource attestationObject);
    void setAssertionReturnBundle(BufferSource credentialId, BufferSource authenticatorData, BufferSource signature, BufferSource userHandle);
};



    $(WebKit2)/WebProcess/ApplicationCache \
    $(WebKit2)/WebProcess/Automation \
    $(WebKit2)/WebProcess/Cache \
    $(WebKit2)/WebProcess/CredentialManagement \
    $(WebKit2)/WebProcess/Databases/IndexedDB \
    $(WebKit2)/WebProcess/FullScreen \
    $(WebKit2)/WebProcess/Geolocation \

    $(WebKit2)/WebProcess/ResourceCache \
    $(WebKit2)/WebProcess/Storage \
    $(WebKit2)/WebProcess/UserContent \
    $(WebKit2)/WebProcess/WebAuthentication \
    $(WebKit2)/WebProcess/WebCoreSupport \
    $(WebKit2)/WebProcess/WebPage \
    $(WebKit2)/WebProcess/WebPage/RemoteLayerTree \

    $(WebKit2)/UIProcess/ApplePay \
    $(WebKit2)/UIProcess/Automation \
    $(WebKit2)/UIProcess/Cocoa \
    $(WebKit2)/UIProcess/CredentialManagement \
    $(WebKit2)/UIProcess/Databases \
    $(WebKit2)/UIProcess/Downloads \
    $(WebKit2)/UIProcess/MediaStream \

    $(WebKit2)/UIProcess/RemoteLayerTree \
    $(WebKit2)/UIProcess/Storage \
    $(WebKit2)/UIProcess/UserContent \
    $(WebKit2)/UIProcess/WebAuthentication \
    $(WebKit2)/UIProcess/WebStorage \
    $(WebKit2)/UIProcess/mac \
    $(WebKit2)/UIProcess/ios \

    WebConnection \
    WebCookieManager \
    WebCookieManagerProxy \
    WebAuthenticatorCoordinator \
    WebAuthenticatorCoordinatorProxy \
    WebFullScreenManager \
    WebFullScreenManagerProxy \
    WebGeolocationManager \



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "WebCredentialsMessengerProxy.h"

#if ENABLE(WEB_AUTHN)

#include "WebCredentialsMessengerMessages.h"
#include "WebCredentialsMessengerProxyMessages.h"
#include "WebPageProxy.h"
#include "WebProcessProxy.h"
#include <WebCore/ExceptionData.h>
#include <WebCore/LocalAuthenticator.h>

namespace WebKit {

WebCredentialsMessengerProxy::WebCredentialsMessengerProxy(WebPageProxy& webPageProxy)
    : m_webPageProxy(webPageProxy)
{
    m_webPageProxy.process().addMessageReceiver(Messages::WebCredentialsMessengerProxy::messageReceiverName(), m_webPageProxy.pageID(), *this);
    m_authenticator = std::make_unique<WebCore::LocalAuthenticator>();
}

WebCredentialsMessengerProxy::~WebCredentialsMessengerProxy()
{
    m_webPageProxy.process().removeMessageReceiver(Messages::WebCredentialsMessengerProxy::messageReceiverName(), m_webPageProxy.pageID());
}

void WebCredentialsMessengerProxy::makeCredential(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options)
{
    // FIXME(182767)
    if (!m_authenticator) {
        exceptionReply(messageId, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
        return;
    }
    // FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
    // FIXME(183534): Unify callbacks.
    auto weakThis = makeWeakPtr(*this);
    auto callback = [weakThis, messageId] (const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject) {
        if (!weakThis)
            return;
        weakThis->makeCredentialReply(messageId, credentialId, attestationObject);
    };
    auto exceptionCallback = [weakThis, messageId] (const WebCore::ExceptionData& exception) {
        if (!weakThis)
            return;
        weakThis->exceptionReply(messageId, exception);
    };
    m_authenticator->makeCredential(hash, options, WTFMove(callback), WTFMove(exceptionCallback));
}

void WebCredentialsMessengerProxy::getAssertion(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options)
{
    // FIXME(182767)
    if (!m_authenticator)
        exceptionReply(messageId, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
    // FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
    // FIXME(183534): Unify callbacks.
    auto weakThis = makeWeakPtr(*this);
    auto callback = [weakThis, messageId] (const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle) {
        if (weakThis)
            weakThis->getAssertionReply(messageId, credentialId, authenticatorData, signature, userHandle);
    };
    auto exceptionCallback = [weakThis, messageId] (const WebCore::ExceptionData& exception) {
        if (weakThis)
            weakThis->exceptionReply(messageId, exception);
    };
    m_authenticator->getAssertion(hash, options, WTFMove(callback), WTFMove(exceptionCallback));
}

void WebCredentialsMessengerProxy::isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId)
{
    if (!m_authenticator) {
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
        return;
    }
    isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, m_authenticator->isAvailable());
}

void WebCredentialsMessengerProxy::exceptionReply(uint64_t messageId, const WebCore::ExceptionData& exception)
{
    m_webPageProxy.send(Messages::WebCredentialsMessenger::ExceptionReply(messageId, exception));
}

void WebCredentialsMessengerProxy::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
{
    m_webPageProxy.send(Messages::WebCredentialsMessenger::MakeCredentialReply(messageId, credentialId, attestationObject));
}

void WebCredentialsMessengerProxy::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
{
    m_webPageProxy.send(Messages::WebCredentialsMessenger::GetAssertionReply(messageId, credentialId, authenticatorData, signature, userHandle));
}

void WebCredentialsMessengerProxy::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
{
    m_webPageProxy.send(Messages::WebCredentialsMessenger::IsUserVerifyingPlatformAuthenticatorAvailableReply(messageId, result));
}

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "MessageReceiver.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
#include <wtf/WeakPtr.h>

namespace WebCore {
class LocalAuthenticator;

struct ExceptionData;
struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialRequestOptions;
}

namespace WebKit {

class WebPageProxy;

class WebCredentialsMessengerProxy : private IPC::MessageReceiver, public CanMakeWeakPtr<WebCredentialsMessengerProxy> {
    WTF_MAKE_NONCOPYABLE(WebCredentialsMessengerProxy);
public:
    explicit WebCredentialsMessengerProxy(WebPageProxy&);
    ~WebCredentialsMessengerProxy();

private:
    // IPC::MessageReceiver.
    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;

    // Receivers.
    void makeCredential(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions&);
    void getAssertion(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions&);
    void isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId);

    // Senders.
    void exceptionReply(uint64_t messageId, const WebCore::ExceptionData&);
    void makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject);
    void getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle);
    void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool);

    WebPageProxy& m_webPageProxy;
    std::unique_ptr<WebCore::LocalAuthenticator> m_authenticator;
};

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



# Copyright (C) 2018 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.
#/

#if ENABLE(WEB_AUTHN)

messages -> WebCredentialsMessengerProxy {

    MakeCredential(uint64_t messageId, Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialCreationOptions options);
    GetAssertion(uint64_t messageId, Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialRequestOptions options);
    IsUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId);
}

#endif



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "WebAuthenticatorCoordinatorProxy.h"

#if ENABLE(WEB_AUTHN)

#include "WebAuthenticatorCoordinatorMessages.h"
#include "WebAuthenticatorCoordinatorProxyMessages.h"
#include "WebPageProxy.h"
#include "WebProcessProxy.h"
#include <WebCore/ExceptionData.h>
#include <WebCore/LocalAuthenticator.h>
#include <WebCore/PublicKeyCredentialData.h>

namespace WebKit {

WebAuthenticatorCoordinatorProxy::WebAuthenticatorCoordinatorProxy(WebPageProxy& webPageProxy)
    : m_webPageProxy(webPageProxy)
{
    m_webPageProxy.process().addMessageReceiver(Messages::WebAuthenticatorCoordinatorProxy::messageReceiverName(), m_webPageProxy.pageID(), *this);
    m_authenticator = std::make_unique<WebCore::LocalAuthenticator>();
}

WebAuthenticatorCoordinatorProxy::~WebAuthenticatorCoordinatorProxy()
{
    m_webPageProxy.process().removeMessageReceiver(Messages::WebAuthenticatorCoordinatorProxy::messageReceiverName(), m_webPageProxy.pageID());
}

void WebAuthenticatorCoordinatorProxy::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options)
{
    // FIXME(182767)
    if (!m_authenticator) {
        requestReply({ }, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
        return;
    }
    // FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
    auto callback = [weakThis = makeWeakPtr(*this)] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        if (!weakThis)
            return;

        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
            weakThis->requestReply(data, { });
        }, [&](const  WebCore::ExceptionData& exception) {
            weakThis->requestReply({ }, exception);
        });
    };
    m_authenticator->makeCredential(hash, options, WTFMove(callback));
}

void WebAuthenticatorCoordinatorProxy::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options)
{
    // FIXME(182767)
    if (!m_authenticator)
        requestReply({ }, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
    // FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
    auto callback = [weakThis = makeWeakPtr(*this)] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        if (!weakThis)
            return;

        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
            weakThis->requestReply(data, { });
        }, [&](const  WebCore::ExceptionData& exception) {
            weakThis->requestReply({ }, exception);
        });
    };
    m_authenticator->getAssertion(hash, options, WTFMove(callback));
}

void WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId)
{
    if (!m_authenticator) {
        isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
        return;
    }
    isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, m_authenticator->isAvailable());
}

void WebAuthenticatorCoordinatorProxy::requestReply(const WebCore::PublicKeyCredentialData& data, const WebCore::ExceptionData& exception)
{
    m_webPageProxy.send(Messages::WebAuthenticatorCoordinator::RequestReply(data, exception));
}

void WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
{
    m_webPageProxy.send(Messages::WebAuthenticatorCoordinator::IsUserVerifyingPlatformAuthenticatorAvailableReply(messageId, result));
}

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "MessageReceiver.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
#include <wtf/WeakPtr.h>

namespace WebCore {
class LocalAuthenticator;

struct ExceptionData;
struct PublicKeyCredentialCreationOptions;
struct PublicKeyCredentialData;
struct PublicKeyCredentialRequestOptions;
}

namespace WebKit {

class WebPageProxy;

class WebAuthenticatorCoordinatorProxy : private IPC::MessageReceiver, public CanMakeWeakPtr<WebAuthenticatorCoordinatorProxy> {
    WTF_MAKE_NONCOPYABLE(WebAuthenticatorCoordinatorProxy);
public:
    explicit WebAuthenticatorCoordinatorProxy(WebPageProxy&);
    ~WebAuthenticatorCoordinatorProxy();

private:
    // IPC::MessageReceiver.
    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;

    // Receivers.
    void makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions&);
    void getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions&);
    void isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId);

    // Senders.
    void requestReply(const WebCore::PublicKeyCredentialData&, const WebCore::ExceptionData&);
    void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool);

    WebPageProxy& m_webPageProxy;
    std::unique_ptr<WebCore::LocalAuthenticator> m_authenticator;
};

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



# Copyright (C) 2018 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.
#/

#if ENABLE(WEB_AUTHN)

messages -> WebAuthenticatorCoordinatorProxy {

    MakeCredential(Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialCreationOptions options);
    GetAssertion(Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialRequestOptions options);
    IsUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId);
}

#endif



#endif

#if ENABLE(WEB_AUTHN)
#include "WebAuthenticatorCoordinatorProxy.h"
#endif

#if HAVE(CFNETWORK_STORAGE_PARTITIONING)

#endif

#if ENABLE(WEB_AUTHN)
    m_credentialsMessenger = std::make_unique<WebAuthenticatorCoordinatorProxy>(*this);
#endif

    m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID, *this);

#endif

#if ENABLE(WEB_AUTHN)
    m_credentialsMessenger = std::make_unique<WebAuthenticatorCoordinatorProxy>(*this);
#endif

    initializeWebPage();



class PlaybackSessionManagerProxy;
class WebNavigationState;
class VideoFullscreenManagerProxy;
class WebAuthenticatorCoordinatorProxy;
class WebKeyboardEvent;
class WebURLSchemeHandler;
class WebMouseEvent;

#endif

#if ENABLE(WEB_AUTHN)
    std::unique_ptr<WebAuthenticatorCoordinatorProxy> m_credentialsMessenger;
#endif

    CallbackMap m_callbacks;



		53BA47D11DC2EF5E004DF4AD /* NetworkDataTaskBlob.h in Headers */ = {isa = PBXBuildFile; fileRef = 539EB5471DC2EE40009D48CF /* NetworkDataTaskBlob.h */; };
		53DEA3661DDE423100E82648 /* json.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 53DEA3651DDE422E00E82648 /* json.hpp */; };
		570AB8F320AE3BD700B8BE87 /* SecKeyProxyStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 570AB8F220AE3BD700B8BE87 /* SecKeyProxyStore.h */; };
		5760829C202D2C3C00116678 /* WebCredentialsMessengerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5760829020298FBD00116678 /* WebCredentialsMessengerMessageReceiver.cpp */; };
		5760829D202D2C4000116678 /* WebCredentialsMessengerMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 5760828F20298FBD00116678 /* WebCredentialsMessengerMessages.h */; };
		5760829E202D2C4300116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5760829A202BEE5A00116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp */; };
		5760829F202D2C4600116678 /* WebCredentialsMessengerProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 5760829B202BEE5A00116678 /* WebCredentialsMessengerProxyMessages.h */; };
		57B4B46020B504AC00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 57B4B45E20B504AB00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h */; };
		57DCED6E2142EE5E0016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 57DCED6B2142EAE20016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp */; };
		57DCED6F2142EE630016B847 /* WebAuthenticatorCoordinatorMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 57DCED6A2142EAE20016B847 /* WebAuthenticatorCoordinatorMessages.h */; };
		57DCED702142EE680016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 57DCED6C2142EAF90016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */; };
		57DCED712142EE6C0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 57DCED6D2142EAFA0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h */; };
		5C0B17781E7C880E00E9123C /* NetworkSocketStreamMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5C0B17741E7C879C00E9123C /* NetworkSocketStreamMessageReceiver.cpp */; };
		5C0B17791E7C882100E9123C /* WebSocketStreamMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5C0B17761E7C879C00E9123C /* WebSocketStreamMessageReceiver.cpp */; };
		5C1426ED1C23F80900D41183 /* NetworkProcessCreationParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C1426E31C23F80500D41183 /* NetworkProcessCreationParameters.h */; };

		570AB90320B2541C00B8BE87 /* SecKeyProxyStore.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SecKeyProxyStore.mm; sourceTree = "<group>"; };
		575075A720AB763600693EA9 /* WebCredentialMac.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCredentialMac.mm; sourceTree = "<group>"; };
		5750F32A2032D4E500389347 /* LocalAuthentication.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = LocalAuthentication.framework; path = System/Library/Frameworks/LocalAuthentication.framework; sourceTree = SDKROOT; };
		5760828B2029854200116678 /* WebAuthenticatorCoordinator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinator.h; sourceTree = "<group>"; };
		5760828C2029854200116678 /* WebAuthenticatorCoordinator.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinator.cpp; sourceTree = "<group>"; };
		5760828D202987E600116678 /* WebAuthenticatorCoordinator.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebAuthenticatorCoordinator.messages.in; sourceTree = "<group>"; };
		57608295202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorProxy.h; sourceTree = "<group>"; };
		57608296202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorProxy.cpp; sourceTree = "<group>"; };
		57608299202BDAE200116678 /* WebAuthenticatorCoordinatorProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebAuthenticatorCoordinatorProxy.messages.in; sourceTree = "<group>"; };
		57608296202BD8BA00116678 /* WebCredentialsMessengerProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessengerProxy.cpp; sourceTree = "<group>"; };
		57608299202BDAE200116678 /* WebCredentialsMessengerProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebCredentialsMessengerProxy.messages.in; sourceTree = "<group>"; };
		5760829A202BEE5A00116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessengerProxyMessageReceiver.cpp; sourceTree = "<group>"; };
		5760829B202BEE5A00116678 /* WebCredentialsMessengerProxyMessages.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCredentialsMessengerProxyMessages.h; sourceTree = "<group>"; };
		57B4B45D20B504AB00D4AD79 /* AuthenticationManagerCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AuthenticationManagerCocoa.mm; path = Authentication/cocoa/AuthenticationManagerCocoa.mm; sourceTree = "<group>"; };
		57B4B45E20B504AB00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ClientCertificateAuthenticationXPCConstants.h; path = Authentication/cocoa/ClientCertificateAuthenticationXPCConstants.h; sourceTree = "<group>"; };
		57DCED6A2142EAE20016B847 /* WebAuthenticatorCoordinatorMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorMessages.h; sourceTree = "<group>"; };
		57DCED6B2142EAE20016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorMessageReceiver.cpp; sourceTree = "<group>"; };
		57DCED6C2142EAF90016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorProxyMessageReceiver.cpp; sourceTree = "<group>"; };
		57DCED6D2142EAFA0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorProxyMessages.h; sourceTree = "<group>"; };
		5C0B17741E7C879C00E9123C /* NetworkSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };
		5C0B17751E7C879C00E9123C /* NetworkSocketStreamMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkSocketStreamMessages.h; sourceTree = "<group>"; };
		5C0B17761E7C879C00E9123C /* WebSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };

			name = Frameworks;
			sourceTree = "<group>";
		};
		5760828A202984C900116678 /* WebAuthentication */ = {
			isa = PBXGroup;
			children = (
				5760828C2029854200116678 /* WebAuthenticatorCoordinator.cpp */,
				5760828B2029854200116678 /* WebAuthenticatorCoordinator.h */,
				5760828D202987E600116678 /* WebAuthenticatorCoordinator.messages.in */,
			);
			path = WebAuthentication;
			sourceTree = "<group>";
		};
		57608294202BD84900116678 /* WebAuthentication */ = {
			isa = PBXGroup;
			children = (
				57608296202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.cpp */,
				57608295202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.h */,
				57608299202BDAE200116678 /* WebAuthenticatorCoordinatorProxy.messages.in */,
			);
			path = WebAuthentication;
			sourceTree = "<group>";
		};
		57B4B45C20B5048B00D4AD79 /* cocoa */ = {

				1C0A19431C8FF1A800FE0EBB /* Automation */,
				41D129D81F3D101400D15E47 /* Cache */,
				7C6E70F818B2D47E00F24E2E /* cocoa */,
				5760828A202984C900116678 /* CredentialManagement */,
				512A9754180DF9270039A149 /* Databases */,
				BCACC43B16B24C5D00B6E092 /* EntryPoint */,
				E170876D16D6CA7200F99226 /* FileAPI */,

				1A6FB7AA11E64B4900DB1371 /* Plugins */,
				5118E9981F295259003EF9F5 /* Storage */,
				1AAF08AA1926930B00B6390C /* UserContent */,
				5760828A202984C900116678 /* WebAuthentication */,
				BC032D5D10F437220058C15A /* WebCoreSupport */,
				BC032D5E10F4372B0058C15A /* WebPage */,
				1AAC4DDE16B1CBF6009425E3 /* WebStorage */,

				512F588D12A8836F00629530 /* Authentication */,
				9955A6E81C79809000EB6A93 /* Automation */,
				1ABC3DF21899E415004F0626 /* Cocoa */,
				57608294202BD84900116678 /* CredentialManagement */,
				1AB7D4C71288AA9A00CFD08C /* Downloads */,
				515BE17B1D54EF5A00DD7C68 /* Gamepad */,
				2DA944A81884E9AB00ED86DB /* ios */,

				2D1551A91F5A9B420006E3FE /* RemoteLayerTree */,
				517DD5BB180DA7C40081660B /* Storage */,
				1AAF089E192681AC00B6390C /* UserContent */,
				57608294202BD84900116678 /* WebAuthentication */,
				1A53C2A31A325691004E8C70 /* WebsiteData */,
				1A44B95816B73F8C00B7BBD8 /* WebStorage */,
				7CD102D91866770600ED429D /* AutoCorrectionCallback.h */,

				1A60224B18C16B9F00C3E8C9 /* VisitedLinkStoreMessages.h */,
				1A8E7D3A18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp */,
				1A8E7D3B18C15149005A702A /* VisitedLinkTableControllerMessages.h */,
				57DCED6B2142EAE20016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp */,
				57DCED6A2142EAE20016B847 /* WebAuthenticatorCoordinatorMessages.h */,
				57DCED6C2142EAF90016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */,
				57DCED6D2142EAFA0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h */,
				1C0A19551C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp */,
				1C0A19561C90068F00FE0EBB /* WebAutomationSessionMessages.h */,
				1C0A19511C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp */,

				330934441315B9220097A7BC /* WebCookieManagerMessages.h */,
				330934451315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp */,
				330934461315B9220097A7BC /* WebCookieManagerProxyMessages.h */,
				5760829020298FBD00116678 /* WebCredentialsMessengerMessageReceiver.cpp */,
				5760828F20298FBD00116678 /* WebCredentialsMessengerMessages.h */,
				5760829A202BEE5A00116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp */,
				5760829B202BEE5A00116678 /* WebCredentialsMessengerProxyMessages.h */,
				CD73BA48131ACD8E00EEDED2 /* WebFullScreenManagerMessageReceiver.cpp */,
				CD73BA49131ACD8E00EEDED2 /* WebFullScreenManagerMessages.h */,
				CD73BA45131ACC8800EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp */,

				1AF4CEF018BC481800BC2D34 /* VisitedLinkTableController.h in Headers */,
				1A8E7D3D18C15149005A702A /* VisitedLinkTableControllerMessages.h in Headers */,
				CEDA12E3152CD1B300D9E08D /* WebAlternativeTextClient.h in Headers */,
				57DCED6F2142EE630016B847 /* WebAuthenticatorCoordinatorMessages.h in Headers */,
				57DCED712142EE6C0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h in Headers */,
				9955A6EC1C7980C200EB6A93 /* WebAutomationSession.h in Headers */,
				99C3AE2D1DADA6AD00AF5C16 /* WebAutomationSessionMacros.h in Headers */,
				1C0A19581C90068F00FE0EBB /* WebAutomationSessionMessages.h in Headers */,

				3309344A1315B9220097A7BC /* WebCookieManagerProxyMessages.h in Headers */,
				BC1DD7B2114DC396005ADAF3 /* WebCoreArgumentCoders.h in Headers */,
				512F589B12A8838800629530 /* WebCredential.h in Headers */,
				5760829D202D2C4000116678 /* WebCredentialsMessengerMessages.h in Headers */,
				5760829F202D2C4600116678 /* WebCredentialsMessengerProxyMessages.h in Headers */,
				1AA83F6D1A5B63FF00026EC6 /* WebDatabaseProvider.h in Headers */,
				E52CF55220A35C3A00DADA27 /* WebDataListSuggestionPicker.h in Headers */,
				E568B91F20A3AB2F00E3C856 /* WebDataListSuggestionsDropdown.h in Headers */,

				2684055218B86ED60022C38B /* ViewUpdateDispatcherMessageReceiver.cpp in Sources */,
				1A60224C18C16B9F00C3E8C9 /* VisitedLinkStoreMessageReceiver.cpp in Sources */,
				1A8E7D3C18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp in Sources */,
				57DCED6E2142EE5E0016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp in Sources */,
				57DCED702142EE680016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp in Sources */,
				1C0A19571C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp in Sources */,
				1C0A19531C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp in Sources */,
				517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */,

				330934471315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp in Sources */,
				330934491315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp in Sources */,
				2D92A788212B6AB100F493FD /* WebCoreArgumentCoders.cpp in Sources */,
				5760829C202D2C3C00116678 /* WebCredentialsMessengerMessageReceiver.cpp in Sources */,
				5760829E202D2C4300116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp in Sources */,
				2D92A789212B6AB100F493FD /* WebEvent.cpp in Sources */,
				CD73BA4E131ACDB700EEDED2 /* WebFullScreenManagerMessageReceiver.cpp in Sources */,
				CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "WebCredentialsMessenger.h"

#if ENABLE(WEB_AUTHN)

#include "WebCredentialsMessengerMessages.h"
#include "WebCredentialsMessengerProxyMessages.h"
#include "WebPage.h"
#include "WebProcess.h"
#include <WebCore/PublicKeyCredentialCreationOptions.h>
#include <WebCore/PublicKeyCredentialRequestOptions.h>

namespace WebKit {

WebCredentialsMessenger::WebCredentialsMessenger(WebPage& webPage)
    : m_webPage(webPage)
{
    WebProcess::singleton().addMessageReceiver(Messages::WebCredentialsMessenger::messageReceiverName(), m_webPage.pageID(), *this);
}

WebCredentialsMessenger::~WebCredentialsMessenger()
{
    WebProcess::singleton().removeMessageReceiver(*this);
}

void WebCredentialsMessenger::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options, WebCore::CreationCompletionHandler&& handler)
{
    auto messageId = addCreationCompletionHandler(WTFMove(handler));
    m_webPage.send(Messages::WebCredentialsMessengerProxy::MakeCredential(messageId, hash, options));
}

void WebCredentialsMessenger::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options, WebCore::RequestCompletionHandler&& handler)
{
    auto messageId = addRequestCompletionHandler(WTFMove(handler));
    m_webPage.send(Messages::WebCredentialsMessengerProxy::GetAssertion(messageId, hash, options));
}

void WebCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&& handler)
{
    auto messageId = addQueryCompletionHandler(WTFMove(handler));
    m_webPage.send(Messages::WebCredentialsMessengerProxy::IsUserVerifyingPlatformAuthenticatorAvailable(messageId));
}

void WebCredentialsMessenger::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
{
    auto handler = takeCreationCompletionHandler(messageId);
    handler(WebCore::CreationReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(attestationObject.data(), attestationObject.size())));
}

void WebCredentialsMessenger::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
{
    auto handler = takeRequestCompletionHandler(messageId);
    handler(WebCore::AssertionReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(authenticatorData.data(), authenticatorData.size()), ArrayBuffer::create(signature.data(), signature.size()), ArrayBuffer::create(userHandle.data(), userHandle.size())));
}

void WebCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
{
    auto handler = takeQueryCompletionHandler(messageId);
    handler(result);
}


} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "MessageReceiver.h"
#include <WebCore/CredentialsMessenger.h>

namespace WebKit {

class WebPage;

class WebCredentialsMessenger final : public WebCore::CredentialsMessenger, private IPC::MessageReceiver {
public:
    explicit WebCredentialsMessenger(WebPage&);
    ~WebCredentialsMessenger();

private:
    // WebCore::CredentialsMessenger
    // Senders.
    void makeCredential(const Vector<uint8_t>&, const WebCore::PublicKeyCredentialCreationOptions&, WebCore::CreationCompletionHandler&&) final;
    void getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions&, WebCore::RequestCompletionHandler&&) final;
    void isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&&) final;

    // Receivers.
    void makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject) final;
    void getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle) final;
    void isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool) final;

    // IPC::MessageReceiver.
    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;

    WebPage& m_webPage;
};

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



# Copyright (C) 2018 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.
#/

#if ENABLE(WEB_AUTHN)

messages -> WebCredentialsMessenger {

    ExceptionReply(uint64_t messageId, struct WebCore::ExceptionData exception);
    MakeCredentialReply(uint64_t messageId, Vector<uint8_t> credentialId, Vector<uint8_t> attestationObject);
    GetAssertionReply(uint64_t messageId, Vector<uint8_t> credentialId, Vector<uint8_t> authenticatorData, Vector<uint8_t> signature, Vector<uint8_t> userHandle);
    IsUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result);
}

#endif



/*
 * Copyright (C) 2018 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.
 */

#include "config.h"
#include "WebAuthenticatorCoordinator.h"

#if ENABLE(WEB_AUTHN)

#include "WebAuthenticatorCoordinatorMessages.h"
#include "WebAuthenticatorCoordinatorProxyMessages.h"
#include "WebPage.h"
#include "WebProcess.h"
#include <WebCore/PublicKeyCredentialCreationOptions.h>
#include <WebCore/PublicKeyCredentialRequestOptions.h>

namespace WebKit {

WebAuthenticatorCoordinator::WebAuthenticatorCoordinator(WebPage& webPage)
    : m_webPage(webPage)
{
    WebProcess::singleton().addMessageReceiver(Messages::WebAuthenticatorCoordinator::messageReceiverName(), m_webPage.pageID(), *this);
}

WebAuthenticatorCoordinator::~WebAuthenticatorCoordinator()
{
    WebProcess::singleton().removeMessageReceiver(*this);
}

void WebAuthenticatorCoordinator::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options, WebCore::RequestCompletionHandler&& handler)
{
    if (!setRequestCompletionHandler(WTFMove(handler)))
        return;

    m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::MakeCredential(hash, options));
}

void WebAuthenticatorCoordinator::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options, WebCore::RequestCompletionHandler&& handler)
{
    if (!setRequestCompletionHandler(WTFMove(handler)))
        return;

    m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::GetAssertion(hash, options));
}

void WebAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&& handler)
{
    auto messageId = addQueryCompletionHandler(WTFMove(handler));
    m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::IsUserVerifyingPlatformAuthenticatorAvailable(messageId));
}

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



/*
 * Copyright (C) 2018 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

#if ENABLE(WEB_AUTHN)

#include "MessageReceiver.h"
#include <WebCore/AuthenticatorCoordinatorClient.h>

namespace WebKit {

class WebPage;

class WebAuthenticatorCoordinator final : public WebCore::AuthenticatorCoordinatorClient, private IPC::MessageReceiver {
public:
    explicit WebAuthenticatorCoordinator(WebPage&);
    ~WebAuthenticatorCoordinator();

private:
    // WebCore::AuthenticatorCoordinatorClient
    // Senders.
    void makeCredential(const Vector<uint8_t>&, const WebCore::PublicKeyCredentialCreationOptions&, WebCore::RequestCompletionHandler&&) final;
    void getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions&, WebCore::RequestCompletionHandler&&) final;
    void isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&&) final;

    // IPC::MessageReceiver.
    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;

    WebPage& m_webPage;
};

} // namespace WebKit

#endif // ENABLE(WEB_AUTHN)



# Copyright (C) 2018 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.
#/

#if ENABLE(WEB_AUTHN)

messages -> WebAuthenticatorCoordinator {

    RequestReply(struct WebCore::PublicKeyCredentialData data, struct WebCore::ExceptionData exception);
    IsUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result);
}

#endif



#endif

#if ENABLE(WEB_AUTHN)
#include "WebAuthenticatorCoordinator.h"
#include <WebCore/AuthenticatorCoordinator.h>
#endif

namespace WebKit {

    , m_userInterfaceLayoutDirection(parameters.userInterfaceLayoutDirection)
    , m_overrideContentSecurityPolicy { parameters.overrideContentSecurityPolicy }
    , m_cpuLimit(parameters.cpuLimit)
#if ENABLE(WEB_AUTHN)
    , m_credentialsMessenger(std::make_unique<WebCredentialsMessenger>(*this))
#endif
{
    ASSERT(m_pageID);


    pageConfiguration.paymentCoordinatorClient = new WebPaymentCoordinator(*this);
#endif

#if ENABLE(WEB_AUTHN)
    pageConfiguration.authenticatorCoordinatorClient = std::make_unique<WebAuthenticatorCoordinator>(*this);
#endif

#if ENABLE(APPLICATION_MANIFEST)
    pageConfiguration.applicationManifest = parameters.applicationManifest;
#endif

#endif
#endif

#if ENABLE(WEB_AUTHN)
    WebCore::AuthenticatorManager::singleton().setMessenger(*m_credentialsMessenger);
#endif

    for (auto iterator : parameters.urlSchemeHandlers)
        registerURLSchemeHandler(iterator.value, iterator.key);




class VideoFullscreenManager;
class WebWheelEvent;
class WebTouchEvent;
class WebCredentialsMessenger;
class RemoteLayerTreeTransaction;

enum class DeviceAccessState;

    HashMap<uint64_t, uint64_t> m_applicationManifestFetchCallbackMap;
#endif

#if ENABLE(WEB_AUTHN)
    std::unique_ptr<WebCredentialsMessenger> m_credentialsMessenger;
#endif

    bool m_isSuspended { false };
};




2018-09-08  Jiewen Tan  <jiewen_tan@apple.com>

        [WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=189277
        <rdar://problem/44115936>

        Reviewed by Chris Dumez.

        * TestWebKitAPI/Tests/ios/LocalAuthenticator.mm:
        (TestWebKitAPI::TEST):

2018-09-02  Darin Adler  <darin@apple.com>

        [Cocoa] Turn on ARC for WebKitTestRunner



#import <WebCore/ExceptionData.h>
#import <WebCore/LocalAuthenticator.h>
#import <WebCore/PublicKeyCredentialCreationOptions.h>
#import <WebCore/PublicKeyCredentialData.h>
#import <WebCore/PublicKeyCredentialRequestOptions.h>
#import <wtf/BlockPtr.h>
#import <wtf/text/Base64.h>


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotSupportedError, exception.code);
            EXPECT_STREQ("The platform attached authenticator doesn't support any provided PublicKeyCredentialParameters.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("At least one credential matches an entry of the excludeCredentials list in the platform attached authenticator.", exception.message.ascii().data());
            cleanUpKeychain();
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("No avaliable authenticators.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("Couldn't get user consent.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}

    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    authenticator->setFailureFlag();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::UnknownError, exception.code);
            EXPECT_STREQ("Unknown internal error.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}

    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    authenticator->setFailureFlag();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            NSDictionary *query = @{
                (id)kSecClass: (id)kSecClassKey,
                (id)kSecAttrKeyClass: (id)kSecAttrKeyClassPrivate,
                (id)kSecAttrLabel: testRpId,
                (id)kSecAttrApplicationTag: [NSData dataWithBytes:testUserhandle length:sizeof(testUserhandle)],
            };
            OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, NULL);
            EXPECT_EQ(errSecItemNotFound, status);
            done = true;
        });
    };
    authenticator->makeCredential({ }, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
            Vector<uint8_t> credentialId;
            credentialId.append(reinterpret_cast<uint8_t*>(data.rawId->data()), data.rawId->byteLength());
            Vector<uint8_t> attestationObject;
            attestationObject.append(reinterpret_cast<uint8_t*>(data.attestationObject->data()), data.attestationObject->byteLength());

            // Check Keychain
            NSDictionary *query = @{
                (id)kSecClass: (id)kSecClassKey,
                (id)kSecAttrKeyClass: (id)kSecAttrKeyClassPrivate,
                (id)kSecAttrLabel: testRpId,
                (id)kSecAttrApplicationLabel: adoptNS([[NSData alloc] initWithBase64EncodedString:testCredentialIdBase64 options:NSDataBase64DecodingIgnoreUnknownCharacters]).get(),
                (id)kSecAttrApplicationTag: [NSData dataWithBytes:testUserhandle length:sizeof(testUserhandle)],
            };
            OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, NULL);
            EXPECT_FALSE(status);

            // Check Credential ID
            EXPECT_TRUE(WTF::base64Encode(credentialId.data(), credentialId.size()) == testCredentialIdBase64);

            // Check Attestation Object
            auto attestationObjectMap = cbor::CBORReader::read(attestationObject);
            ASSERT_TRUE(!!attestationObjectMap);

            // Check Authenticator Data.
            auto& authData = attestationObjectMap->getMap().find(cbor::CBORValue("authData"))->second.getByteString();
            size_t pos = 0;
            uint8_t expectedRpIdHash[] = {
                0x49, 0x96, 0x0d, 0xe5, 0x88, 0x0e, 0x8c, 0x68,
                0x74, 0x34, 0x17, 0x0f, 0x64, 0x76, 0x60, 0x5b,
                0x8f, 0xe4, 0xae, 0xb9, 0xa2, 0x86, 0x32, 0xc7,
                0x99, 0x5c, 0xf3, 0xba, 0x83, 0x1d, 0x97, 0x63
            };
            EXPECT_FALSE(memcmp(authData.data() + pos, expectedRpIdHash, sizeof(expectedRpIdHash)));
            pos += sizeof(expectedRpIdHash);

            // FLAGS
            EXPECT_EQ(69, authData[pos]);
            pos++;

            uint32_t counter = -1;
            memcpy(&counter, authData.data() + pos, sizeof(uint32_t));
            EXPECT_EQ(0u, counter);
            pos += sizeof(uint32_t);

            uint8_t expectedAAGUID[] = {
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
            };
            EXPECT_FALSE(memcmp(authData.data() + pos, expectedAAGUID, sizeof(expectedAAGUID)));
            pos += sizeof(expectedAAGUID);

            uint16_t l = -1;
            memcpy(&l, authData.data() + pos, sizeof(uint16_t));
            EXPECT_EQ(20u, l);
            pos += sizeof(uint16_t);

            EXPECT_FALSE(memcmp(authData.data() + pos, credentialId.data(), l));
            pos += l;

            // Credential Public Key
            // FIXME(183536): The CBOR reader doesn't support negative integer as map key. Thus we couldn't utilzie it.
            EXPECT_STREQ("pQECAyYgASFYIDj/zxSkzKgaBuS3cdWDF558of8AaIpgFpsjF/Qm1749IlggVBJPgqUIwfhWHJ91nb7UPH76c0+WFOzZKslPyyFse4g=", WTF::base64Encode(authData.data() + pos, authData.size() - pos).ascii().data());

            // Check Self Attestation
            EXPECT_STREQ("Apple", attestationObjectMap->getMap().find(cbor::CBORValue("fmt"))->second.getString().ascii().data());

            auto& attStmt = attestationObjectMap->getMap().find(cbor::CBORValue("attStmt"))->second.getMap();
            EXPECT_EQ(COSE::ES256, attStmt.find(cbor::CBORValue("alg"))->second.getNegative());

            auto& sig = attStmt.find(cbor::CBORValue("sig"))->second.getByteString();
            auto privateKey = getTestKey();
            EXPECT_TRUE(SecKeyVerifySignature(SecKeyCopyPublicKey(privateKey.get()), kSecKeyAlgorithmECDSASignatureMessageX962SHA256, (__bridge CFDataRef)[NSData dataWithBytes:authData.data() length:authData.size()], (__bridge CFDataRef)[NSData dataWithBytes:sig.data() length:sig.size()], NULL));

            // Check certificates
            auto& x5c = attStmt.find(cbor::CBORValue("x5c"))->second.getArray();
            auto& attestationCertificateData = x5c[0].getByteString();
            auto attestationCertificate = adoptCF(SecCertificateCreateWithData(NULL, (__bridge CFDataRef)[NSData dataWithBytes:attestationCertificateData.data() length:attestationCertificateData.size()]));
            CFStringRef commonName = nullptr;
            status = SecCertificateCopyCommonName(attestationCertificate.get(), &commonName);
            auto retainCommonName = adoptCF(commonName);
            ASSERT(!status);
            EXPECT_STREQ("00008010-000A49A230A0213A", [(NSString *)commonName cStringUsingEncoding: NSASCIIStringEncoding]);

            auto& attestationIssuingCACertificateData = x5c[1].getByteString();
            auto attestationIssuingCACertificate = adoptCF(SecCertificateCreateWithData(NULL, (__bridge CFDataRef)[NSData dataWithBytes:attestationIssuingCACertificateData.data() length:attestationIssuingCACertificateData.size()]));
            commonName = nullptr;
            status = SecCertificateCopyCommonName(attestationIssuingCACertificate.get(), &commonName);
            retainCommonName = adoptCF(commonName);
            ASSERT(!status);
            EXPECT_STREQ("Basic Attestation User Sub CA1", [(NSString *)commonName cStringUsingEncoding: NSASCIIStringEncoding]);

            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        });
    };
    Vector<uint8_t> hash(32);
    authenticator->makeCredential(hash, creationOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("No matched credentials are found in the platform attached authenticator.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->getAssertion({ }, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("No matched credentials are found in the platform attached authenticator.", exception.message.ascii().data());
            done = true;
        });
    };
    authenticator->getAssertion({ }, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("No matched credentials are found in the platform attached authenticator.", exception.message.ascii().data());
            cleanUpKeychain();
            done = true;
        });
    };
    authenticator->getAssertion({ }, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("No avaliable authenticators.", exception.message.ascii().data());
            cleanUpKeychain();
            done = true;
        });
    };
    authenticator->getAssertion({ }, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData&) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_EQ(WebCore::NotAllowedError, exception.code);
            EXPECT_STREQ("Couldn't get user consent.", exception.message.ascii().data());
            cleanUpKeychain();
            done = true;
        });
    };
    authenticator->getAssertion({ }, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}


    bool done = false;
    std::unique_ptr<TestLocalAuthenticator> authenticator = std::make_unique<TestLocalAuthenticator>();
    auto callback = [&done, hash] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
        WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
            Vector<uint8_t> credentialId;
            credentialId.append(reinterpret_cast<uint8_t*>(data.rawId->data()), data.rawId->byteLength());
            Vector<uint8_t> authData;
            authData.append(reinterpret_cast<uint8_t*>(data.authenticatorData->data()), data.authenticatorData->byteLength());
            Vector<uint8_t> signature;
            signature.append(reinterpret_cast<uint8_t*>(data.signature->data()), data.signature->byteLength());
            Vector<uint8_t> userhandle;
            userhandle.append(reinterpret_cast<uint8_t*>(data.userHandle->data()), data.userHandle->byteLength());

            // Check Credential ID
            EXPECT_TRUE(WTF::base64Encode(credentialId.data(), credentialId.size()) == testCredentialIdBase64);

            // Check Authenticator Data.
            size_t pos = 0;
            uint8_t expectedRpIdHash[] = {
                0x49, 0x96, 0x0d, 0xe5, 0x88, 0x0e, 0x8c, 0x68,
                0x74, 0x34, 0x17, 0x0f, 0x64, 0x76, 0x60, 0x5b,
                0x8f, 0xe4, 0xae, 0xb9, 0xa2, 0x86, 0x32, 0xc7,
                0x99, 0x5c, 0xf3, 0xba, 0x83, 0x1d, 0x97, 0x63
            };
            EXPECT_FALSE(memcmp(authData.data() + pos, expectedRpIdHash, sizeof(expectedRpIdHash)));
            pos += sizeof(expectedRpIdHash);

            // FLAGS
            EXPECT_EQ(5, authData[pos]);
            pos++;

            uint32_t counter = -1;
            memcpy(&counter, authData.data() + pos, sizeof(uint32_t));
            EXPECT_EQ(0u, counter);

            // Check signature
            auto privateKey = getTestKey();
            Vector<uint8_t> dataToSign(authData);
            dataToSign.appendVector(hash);
            EXPECT_TRUE(SecKeyVerifySignature(SecKeyCopyPublicKey(privateKey.get()), kSecKeyAlgorithmECDSASignatureMessageX962SHA256, (__bridge CFDataRef)[NSData dataWithBytes:dataToSign.data() length:dataToSign.size()], (__bridge CFDataRef)[NSData dataWithBytes:signature.data() length:signature.size()], NULL));

            // Check User Handle
            EXPECT_EQ(userhandle.size(), sizeof(testUserhandle));
            EXPECT_FALSE(memcmp(userhandle.data(), testUserhandle, sizeof(testUserhandle)));

            cleanUpKeychain();
            done = true;
        }, [&](const  WebCore::ExceptionData& exception) {
            EXPECT_FALSE(true);
            cleanUpKeychain();
            done = true;
        });
    };
    authenticator->getAssertion(hash, requestOptions, WTFMove(callback));

    TestWebKitAPI::Util::run(&done);
}



2018-09-08  Jiewen Tan  <jiewen_tan@apple.com>

        [WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=189277
        <rdar://problem/44115936>

        Reviewed by Chris Dumez.

        * http/wpt/credential-management/credentialscontainer-store-basics.https.html:
        * http/wpt/webauthn/idl.https.html:
        * http/wpt/webauthn/public-key-credential-create-failure.https.html:
        * http/wpt/webauthn/public-key-credential-create-success.https.html:
        * http/wpt/webauthn/public-key-credential-get-failure.https.html:
        * http/wpt/webauthn/public-key-credential-get-success.https.html:
        * http/wpt/webauthn/public-key-is-user-verifying-platform-authenticator-available.html:

2018-09-08  Andy Estes  <aestes@apple.com>

        [Apple Pay] Dispatch a paymentmethodchange event when the payment method changes

Lines 42-48 a/LayoutTests/http/wpt/credential-management/credentialscontainer-store-basics.https.html_sec1
- a/LayoutTests/http/wpt/credential-management/credentialscontainer-store-basics.https.html -1 / +1 lines
42	}	42	}
43	};	43	};
44	// A mock attestation object	44	// A mock attestation object
45	internals.mockCredentialsMessenger.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));	45	internals.mockAuthenticatorCoordinator.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));
46	const credential = await navigator.credentials.create(options);	46	const credential = await navigator.credentials.create(options);
47		47
48	return promise_rejects(t, "NotSupportedError",	48	return promise_rejects(t, "NotSupportedError",



        }
    };
    // A mock attestation object
    internals.mockAuthenticatorCoordinator.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));
    createdCredential = await navigator.credentials.create(creationOptions);



        }
    };
    // A mock assertion return bundle.
    internals.mockAuthenticatorCoordinator.setAssertionReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'), hexStringToUint8Array('02'), hexStringToUint8Array('03'));
    requestedCredential = await navigator.credentials.get(requestOptions);

    idlArray.add_objects({"PublicKeyCredential": ["createdCredential"], "AuthenticatorAttestationResponse": ["createdCredential.response"], "AuthenticatorAssertionResponse": ["requestedCredential.response"]});



                timeout: 0,
            }
        };
        internals.mockAuthenticatorCoordinator.setDidTimeOut();

        return promise_rejects(t, "NotAllowedError",
            navigator.credentials.create(options));

                pubKeyCredParams: [{ type: "public-key", alg: -7 }],
            }
        };
        internals.mockAuthenticatorCoordinator.setDidUserCancel();

        return promise_rejects(t, "NotAllowedError",
            navigator.credentials.create(options));

Lines 20-26 a/LayoutTests/http/wpt/webauthn/public-key-credential-create-success.https.html_sec1
- a/LayoutTests/http/wpt/webauthn/public-key-credential-create-success.https.html -1 / +1 lines
20	}	20	}
21	};	21	};
22	// A mock attestation object	22	// A mock attestation object
23	internals.mockCredentialsMessenger.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));	23	internals.mockAuthenticatorCoordinator.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));
24		24
25	return navigator.credentials.create(options).then(function(credential) {	25	return navigator.credentials.create(options).then(function(credential) {
26	assert_equals(credential.id, 'AA');	26	assert_equals(credential.id, 'AA');



                timeout: 0,
            }
        };
        internals.mockAuthenticatorCoordinator.setDidTimeOut();

        return promise_rejects(t, "NotAllowedError",
            navigator.credentials.get(options));

                allowCredentials: [{ type: "public-key", id: asciiToUint8Array("123456") }],
            }
        };
        internals.mockAuthenticatorCoordinator.setDidUserCancel();

        return promise_rejects(t, "NotAllowedError",
            navigator.credentials.get(options));

Lines 12-18 a/LayoutTests/http/wpt/webauthn/public-key-credential-get-success.https.html_sec1
- a/LayoutTests/http/wpt/webauthn/public-key-credential-get-success.https.html -1 / +1 lines
12	}	12	}
13	};	13	};
14	// A mock assertion return bundle.	14	// A mock assertion return bundle.
15	internals.mockCredentialsMessenger.setAssertionReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'), hexStringToUint8Array('02'), hexStringToUint8Array('03'));	15	internals.mockAuthenticatorCoordinator.setAssertionReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'), hexStringToUint8Array('02'), hexStringToUint8Array('03'));
16		16
17	return navigator.credentials.get(options).then(function(credential) {	17	return navigator.credentials.get(options).then(function(credential) {
18	assert_equals(credential.id, 'AA');	18	assert_equals(credential.id, 'AA');



<script src="/resources/testharnessreport.js"></script>
<script>
    promise_test(function(t) {
        internals.mockAuthenticatorCoordinator;

        return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {
            assert_equals(result, false);

    }, "PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() without any available authenticators.");

    promise_test(function(t) {
        internals.mockAuthenticatorCoordinator.setDidUserVerifyingPlatformAuthenticatorPresent();

        return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {
            assert_equals(result, true);

Return to Bug 189277

Lines 236-242 class WebFullScreenManagerProxy; a/Source/WebKit/UIProcess/WebPageProxy.h_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.h -2 / +2 lines
236	class PlaybackSessionManagerProxy;	236	class PlaybackSessionManagerProxy;
237	class WebNavigationState;	237	class WebNavigationState;
238	class VideoFullscreenManagerProxy;	238	class VideoFullscreenManagerProxy;
239	class WebCredentialsMessengerProxy;	239	class WebAuthenticatorCoordinatorProxy;
240	class WebKeyboardEvent;	240	class WebKeyboardEvent;
241	class WebURLSchemeHandler;	241	class WebURLSchemeHandler;
242	class WebMouseEvent;	242	class WebMouseEvent;
Lines 1917-1923 private: a/Source/WebKit/UIProcess/WebPageProxy.h_sec2
1917	#endif	1917	#endif
1918		1918
1919	#if ENABLE(WEB_AUTHN)	1919	#if ENABLE(WEB_AUTHN)
1920	std::unique_ptr<WebCredentialsMessengerProxy> m_credentialsMessenger;	1920	std::unique_ptr<WebAuthenticatorCoordinatorProxy> m_credentialsMessenger;
1921	#endif	1921	#endif
1922		1922
1923	CallbackMap m_callbacks;	1923	CallbackMap m_callbacks;

Lines 1028-1038 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec1
- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj -34 / +34 lines
1028	53BA47D11DC2EF5E004DF4AD /* NetworkDataTaskBlob.h in Headers / = {isa = PBXBuildFile; fileRef = 539EB5471DC2EE40009D48CF / NetworkDataTaskBlob.h */; };	1028	53BA47D11DC2EF5E004DF4AD /* NetworkDataTaskBlob.h in Headers / = {isa = PBXBuildFile; fileRef = 539EB5471DC2EE40009D48CF / NetworkDataTaskBlob.h */; };
1029	53DEA3661DDE423100E82648 /* json.hpp in Headers / = {isa = PBXBuildFile; fileRef = 53DEA3651DDE422E00E82648 / json.hpp */; };	1029	53DEA3661DDE423100E82648 /* json.hpp in Headers / = {isa = PBXBuildFile; fileRef = 53DEA3651DDE422E00E82648 / json.hpp */; };
1030	570AB8F320AE3BD700B8BE87 /* SecKeyProxyStore.h in Headers / = {isa = PBXBuildFile; fileRef = 570AB8F220AE3BD700B8BE87 / SecKeyProxyStore.h */; };	1030	570AB8F320AE3BD700B8BE87 /* SecKeyProxyStore.h in Headers / = {isa = PBXBuildFile; fileRef = 570AB8F220AE3BD700B8BE87 / SecKeyProxyStore.h */; };
1031	5760829C202D2C3C00116678 /* WebCredentialsMessengerMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5760829020298FBD00116678 / WebCredentialsMessengerMessageReceiver.cpp */; };
1032	5760829D202D2C4000116678 /* WebCredentialsMessengerMessages.h in Headers / = {isa = PBXBuildFile; fileRef = 5760828F20298FBD00116678 / WebCredentialsMessengerMessages.h */; };
1033	5760829E202D2C4300116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5760829A202BEE5A00116678 / WebCredentialsMessengerProxyMessageReceiver.cpp */; };
1034	5760829F202D2C4600116678 /* WebCredentialsMessengerProxyMessages.h in Headers / = {isa = PBXBuildFile; fileRef = 5760829B202BEE5A00116678 / WebCredentialsMessengerProxyMessages.h */; };
1035	57B4B46020B504AC00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h in Headers / = {isa = PBXBuildFile; fileRef = 57B4B45E20B504AB00D4AD79 / ClientCertificateAuthenticationXPCConstants.h */; };	1031	57B4B46020B504AC00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h in Headers / = {isa = PBXBuildFile; fileRef = 57B4B45E20B504AB00D4AD79 / ClientCertificateAuthenticationXPCConstants.h */; };
		1032	57DCED6E2142EE5E0016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 57DCED6B2142EAE20016B847 / WebAuthenticatorCoordinatorMessageReceiver.cpp */; };
		1033	57DCED6F2142EE630016B847 /* WebAuthenticatorCoordinatorMessages.h in Headers / = {isa = PBXBuildFile; fileRef = 57DCED6A2142EAE20016B847 / WebAuthenticatorCoordinatorMessages.h */; };
		1034	57DCED702142EE680016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 57DCED6C2142EAF90016B847 / WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */; };
		1035	57DCED712142EE6C0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h in Headers / = {isa = PBXBuildFile; fileRef = 57DCED6D2142EAFA0016B847 / WebAuthenticatorCoordinatorProxyMessages.h */; };
1036	5C0B17781E7C880E00E9123C /* NetworkSocketStreamMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5C0B17741E7C879C00E9123C / NetworkSocketStreamMessageReceiver.cpp */; };	1036	5C0B17781E7C880E00E9123C /* NetworkSocketStreamMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5C0B17741E7C879C00E9123C / NetworkSocketStreamMessageReceiver.cpp */; };
1037	5C0B17791E7C882100E9123C /* WebSocketStreamMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5C0B17761E7C879C00E9123C / WebSocketStreamMessageReceiver.cpp */; };	1037	5C0B17791E7C882100E9123C /* WebSocketStreamMessageReceiver.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5C0B17761E7C879C00E9123C / WebSocketStreamMessageReceiver.cpp */; };
1038	5C1426ED1C23F80900D41183 /* NetworkProcessCreationParameters.h in Headers / = {isa = PBXBuildFile; fileRef = 5C1426E31C23F80500D41183 / NetworkProcessCreationParameters.h */; };	1038	5C1426ED1C23F80900D41183 /* NetworkProcessCreationParameters.h in Headers / = {isa = PBXBuildFile; fileRef = 5C1426E31C23F80500D41183 / NetworkProcessCreationParameters.h */; };
Lines 3368-3385 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec2
3368	570AB90320B2541C00B8BE87 /* SecKeyProxyStore.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SecKeyProxyStore.mm; sourceTree = "<group>"; };	3368	570AB90320B2541C00B8BE87 /* SecKeyProxyStore.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SecKeyProxyStore.mm; sourceTree = "<group>"; };
3369	575075A720AB763600693EA9 /* WebCredentialMac.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCredentialMac.mm; sourceTree = "<group>"; };	3369	575075A720AB763600693EA9 /* WebCredentialMac.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCredentialMac.mm; sourceTree = "<group>"; };
3370	5750F32A2032D4E500389347 /* LocalAuthentication.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = LocalAuthentication.framework; path = System/Library/Frameworks/LocalAuthentication.framework; sourceTree = SDKROOT; };	3370	5750F32A2032D4E500389347 /* LocalAuthentication.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = LocalAuthentication.framework; path = System/Library/Frameworks/LocalAuthentication.framework; sourceTree = SDKROOT; };
3371	5760828B2029854200116678 /* WebCredentialsMessenger.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCredentialsMessenger.h; sourceTree = "<group>"; };	3371	5760828B2029854200116678 /* WebAuthenticatorCoordinator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinator.h; sourceTree = "<group>"; };
3372	5760828C2029854200116678 /* WebCredentialsMessenger.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessenger.cpp; sourceTree = "<group>"; };	3372	5760828C2029854200116678 /* WebAuthenticatorCoordinator.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinator.cpp; sourceTree = "<group>"; };
3373	5760828D202987E600116678 /* WebCredentialsMessenger.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebCredentialsMessenger.messages.in; sourceTree = "<group>"; };	3373	5760828D202987E600116678 /* WebAuthenticatorCoordinator.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebAuthenticatorCoordinator.messages.in; sourceTree = "<group>"; };
3374	5760828F20298FBD00116678 /* WebCredentialsMessengerMessages.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCredentialsMessengerMessages.h; sourceTree = "<group>"; };	3374	57608295202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorProxy.h; sourceTree = "<group>"; };
3375	5760829020298FBD00116678 /* WebCredentialsMessengerMessageReceiver.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessengerMessageReceiver.cpp; sourceTree = "<group>"; };	3375	57608296202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorProxy.cpp; sourceTree = "<group>"; };
3376	57608295202BD8BA00116678 /* WebCredentialsMessengerProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCredentialsMessengerProxy.h; sourceTree = "<group>"; };	3376	57608299202BDAE200116678 /* WebAuthenticatorCoordinatorProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebAuthenticatorCoordinatorProxy.messages.in; sourceTree = "<group>"; };
3377	57608296202BD8BA00116678 /* WebCredentialsMessengerProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessengerProxy.cpp; sourceTree = "<group>"; };
3378	57608299202BDAE200116678 /* WebCredentialsMessengerProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebCredentialsMessengerProxy.messages.in; sourceTree = "<group>"; };
3379	5760829A202BEE5A00116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCredentialsMessengerProxyMessageReceiver.cpp; sourceTree = "<group>"; };
3380	5760829B202BEE5A00116678 /* WebCredentialsMessengerProxyMessages.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCredentialsMessengerProxyMessages.h; sourceTree = "<group>"; };
3381	57B4B45D20B504AB00D4AD79 /* AuthenticationManagerCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AuthenticationManagerCocoa.mm; path = Authentication/cocoa/AuthenticationManagerCocoa.mm; sourceTree = "<group>"; };	3377	57B4B45D20B504AB00D4AD79 /* AuthenticationManagerCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AuthenticationManagerCocoa.mm; path = Authentication/cocoa/AuthenticationManagerCocoa.mm; sourceTree = "<group>"; };
3382	57B4B45E20B504AB00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ClientCertificateAuthenticationXPCConstants.h; path = Authentication/cocoa/ClientCertificateAuthenticationXPCConstants.h; sourceTree = "<group>"; };	3378	57B4B45E20B504AB00D4AD79 /* ClientCertificateAuthenticationXPCConstants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ClientCertificateAuthenticationXPCConstants.h; path = Authentication/cocoa/ClientCertificateAuthenticationXPCConstants.h; sourceTree = "<group>"; };
		3379	57DCED6A2142EAE20016B847 /* WebAuthenticatorCoordinatorMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorMessages.h; sourceTree = "<group>"; };
		3380	57DCED6B2142EAE20016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorMessageReceiver.cpp; sourceTree = "<group>"; };
		3381	57DCED6C2142EAF90016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebAuthenticatorCoordinatorProxyMessageReceiver.cpp; sourceTree = "<group>"; };
		3382	57DCED6D2142EAFA0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebAuthenticatorCoordinatorProxyMessages.h; sourceTree = "<group>"; };
3383	5C0B17741E7C879C00E9123C /* NetworkSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };	3383	5C0B17741E7C879C00E9123C /* NetworkSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };
3384	5C0B17751E7C879C00E9123C /* NetworkSocketStreamMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkSocketStreamMessages.h; sourceTree = "<group>"; };	3384	5C0B17751E7C879C00E9123C /* NetworkSocketStreamMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkSocketStreamMessages.h; sourceTree = "<group>"; };
3385	5C0B17761E7C879C00E9123C /* WebSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };	3385	5C0B17761E7C879C00E9123C /* WebSocketStreamMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebSocketStreamMessageReceiver.cpp; sourceTree = "<group>"; };
Lines 6721-6744 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec3
6721	name = Frameworks;	6721	name = Frameworks;
6722	sourceTree = "<group>";	6722	sourceTree = "<group>";
6723	};	6723	};
6724	5760828A202984C900116678 /* CredentialManagement */ = {	6724	5760828A202984C900116678 /* WebAuthentication */ = {
6725	isa = PBXGroup;	6725	isa = PBXGroup;
6726	children = (	6726	children = (
6727	5760828C2029854200116678 /* WebCredentialsMessenger.cpp */,	6727	5760828C2029854200116678 /* WebAuthenticatorCoordinator.cpp */,
6728	5760828B2029854200116678 /* WebCredentialsMessenger.h */,	6728	5760828B2029854200116678 /* WebAuthenticatorCoordinator.h */,
6729	5760828D202987E600116678 /* WebCredentialsMessenger.messages.in */,	6729	5760828D202987E600116678 /* WebAuthenticatorCoordinator.messages.in */,
6730	);	6730	);
6731	path = CredentialManagement;	6731	path = WebAuthentication;
6732	sourceTree = "<group>";	6732	sourceTree = "<group>";
6733	};	6733	};
6734	57608294202BD84900116678 /* CredentialManagement */ = {	6734	57608294202BD84900116678 /* WebAuthentication */ = {
6735	isa = PBXGroup;	6735	isa = PBXGroup;
6736	children = (	6736	children = (
6737	57608296202BD8BA00116678 /* WebCredentialsMessengerProxy.cpp */,	6737	57608296202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.cpp */,
6738	57608295202BD8BA00116678 /* WebCredentialsMessengerProxy.h */,	6738	57608295202BD8BA00116678 /* WebAuthenticatorCoordinatorProxy.h */,
6739	57608299202BDAE200116678 /* WebCredentialsMessengerProxy.messages.in */,	6739	57608299202BDAE200116678 /* WebAuthenticatorCoordinatorProxy.messages.in */,
6740	);	6740	);
6741	path = CredentialManagement;	6741	path = WebAuthentication;
6742	sourceTree = "<group>";	6742	sourceTree = "<group>";
6743	};	6743	};
6744	57B4B45C20B5048B00D4AD79 /* cocoa */ = {	6744	57B4B45C20B5048B00D4AD79 /* cocoa */ = {
Lines 7033-7039 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec4
7033	1C0A19431C8FF1A800FE0EBB /* Automation */,	7033	1C0A19431C8FF1A800FE0EBB /* Automation */,
7034	41D129D81F3D101400D15E47 /* Cache */,	7034	41D129D81F3D101400D15E47 /* Cache */,
7035	7C6E70F818B2D47E00F24E2E /* cocoa */,	7035	7C6E70F818B2D47E00F24E2E /* cocoa */,
7036	5760828A202984C900116678 /* CredentialManagement */,
7037	512A9754180DF9270039A149 /* Databases */,	7036	512A9754180DF9270039A149 /* Databases */,
7038	BCACC43B16B24C5D00B6E092 /* EntryPoint */,	7037	BCACC43B16B24C5D00B6E092 /* EntryPoint */,
7039	E170876D16D6CA7200F99226 /* FileAPI */,	7038	E170876D16D6CA7200F99226 /* FileAPI */,
Lines 7048-7053 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec5
7048	1A6FB7AA11E64B4900DB1371 /* Plugins */,	7047	1A6FB7AA11E64B4900DB1371 /* Plugins */,
7049	5118E9981F295259003EF9F5 /* Storage */,	7048	5118E9981F295259003EF9F5 /* Storage */,
7050	1AAF08AA1926930B00B6390C /* UserContent */,	7049	1AAF08AA1926930B00B6390C /* UserContent */,
		7050	5760828A202984C900116678 /* WebAuthentication */,
7051	BC032D5D10F437220058C15A /* WebCoreSupport */,	7051	BC032D5D10F437220058C15A /* WebCoreSupport */,
7052	BC032D5E10F4372B0058C15A /* WebPage */,	7052	BC032D5E10F4372B0058C15A /* WebPage */,
7053	1AAC4DDE16B1CBF6009425E3 /* WebStorage */,	7053	1AAC4DDE16B1CBF6009425E3 /* WebStorage */,
Lines 7193-7199 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec6
7193	512F588D12A8836F00629530 /* Authentication */,	7193	512F588D12A8836F00629530 /* Authentication */,
7194	9955A6E81C79809000EB6A93 /* Automation */,	7194	9955A6E81C79809000EB6A93 /* Automation */,
7195	1ABC3DF21899E415004F0626 /* Cocoa */,	7195	1ABC3DF21899E415004F0626 /* Cocoa */,
7196	57608294202BD84900116678 /* CredentialManagement */,
7197	1AB7D4C71288AA9A00CFD08C /* Downloads */,	7196	1AB7D4C71288AA9A00CFD08C /* Downloads */,
7198	515BE17B1D54EF5A00DD7C68 /* Gamepad */,	7197	515BE17B1D54EF5A00DD7C68 /* Gamepad */,
7199	2DA944A81884E9AB00ED86DB /* ios */,	7198	2DA944A81884E9AB00ED86DB /* ios */,
Lines 7205-7210 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec7
7205	2D1551A91F5A9B420006E3FE /* RemoteLayerTree */,	7204	2D1551A91F5A9B420006E3FE /* RemoteLayerTree */,
7206	517DD5BB180DA7C40081660B /* Storage */,	7205	517DD5BB180DA7C40081660B /* Storage */,
7207	1AAF089E192681AC00B6390C /* UserContent */,	7206	1AAF089E192681AC00B6390C /* UserContent */,
		7207	57608294202BD84900116678 /* WebAuthentication */,
7208	1A53C2A31A325691004E8C70 /* WebsiteData */,	7208	1A53C2A31A325691004E8C70 /* WebsiteData */,
7209	1A44B95816B73F8C00B7BBD8 /* WebStorage */,	7209	1A44B95816B73F8C00B7BBD8 /* WebStorage */,
7210	7CD102D91866770600ED429D /* AutoCorrectionCallback.h */,	7210	7CD102D91866770600ED429D /* AutoCorrectionCallback.h */,
Lines 8344-8349 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec8
8344	1A60224B18C16B9F00C3E8C9 /* VisitedLinkStoreMessages.h */,	8344	1A60224B18C16B9F00C3E8C9 /* VisitedLinkStoreMessages.h */,
8345	1A8E7D3A18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp */,	8345	1A8E7D3A18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp */,
8346	1A8E7D3B18C15149005A702A /* VisitedLinkTableControllerMessages.h */,	8346	1A8E7D3B18C15149005A702A /* VisitedLinkTableControllerMessages.h */,
		8347	57DCED6B2142EAE20016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp */,
		8348	57DCED6A2142EAE20016B847 /* WebAuthenticatorCoordinatorMessages.h */,
		8349	57DCED6C2142EAF90016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp */,
		8350	57DCED6D2142EAFA0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h */,
8347	1C0A19551C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp */,	8351	1C0A19551C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp */,
8348	1C0A19561C90068F00FE0EBB /* WebAutomationSessionMessages.h */,	8352	1C0A19561C90068F00FE0EBB /* WebAutomationSessionMessages.h */,
8349	1C0A19511C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp */,	8353	1C0A19511C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp */,
Lines 8356-8365 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec9
8356	330934441315B9220097A7BC /* WebCookieManagerMessages.h */,	8360	330934441315B9220097A7BC /* WebCookieManagerMessages.h */,
8357	330934451315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp */,	8361	330934451315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp */,
8358	330934461315B9220097A7BC /* WebCookieManagerProxyMessages.h */,	8362	330934461315B9220097A7BC /* WebCookieManagerProxyMessages.h */,
8359	5760829020298FBD00116678 /* WebCredentialsMessengerMessageReceiver.cpp */,
8360	5760828F20298FBD00116678 /* WebCredentialsMessengerMessages.h */,
8361	5760829A202BEE5A00116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp */,
8362	5760829B202BEE5A00116678 /* WebCredentialsMessengerProxyMessages.h */,
8363	CD73BA48131ACD8E00EEDED2 /* WebFullScreenManagerMessageReceiver.cpp */,	8363	CD73BA48131ACD8E00EEDED2 /* WebFullScreenManagerMessageReceiver.cpp */,
8364	CD73BA49131ACD8E00EEDED2 /* WebFullScreenManagerMessages.h */,	8364	CD73BA49131ACD8E00EEDED2 /* WebFullScreenManagerMessages.h */,
8365	CD73BA45131ACC8800EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp */,	8365	CD73BA45131ACC8800EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp */,
Lines 9223-9228 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec10
9223	1AF4CEF018BC481800BC2D34 /* VisitedLinkTableController.h in Headers */,	9223	1AF4CEF018BC481800BC2D34 /* VisitedLinkTableController.h in Headers */,
9224	1A8E7D3D18C15149005A702A /* VisitedLinkTableControllerMessages.h in Headers */,	9224	1A8E7D3D18C15149005A702A /* VisitedLinkTableControllerMessages.h in Headers */,
9225	CEDA12E3152CD1B300D9E08D /* WebAlternativeTextClient.h in Headers */,	9225	CEDA12E3152CD1B300D9E08D /* WebAlternativeTextClient.h in Headers */,
		9226	57DCED6F2142EE630016B847 /* WebAuthenticatorCoordinatorMessages.h in Headers */,
		9227	57DCED712142EE6C0016B847 /* WebAuthenticatorCoordinatorProxyMessages.h in Headers */,
9226	9955A6EC1C7980C200EB6A93 /* WebAutomationSession.h in Headers */,	9228	9955A6EC1C7980C200EB6A93 /* WebAutomationSession.h in Headers */,
9227	99C3AE2D1DADA6AD00AF5C16 /* WebAutomationSessionMacros.h in Headers */,	9229	99C3AE2D1DADA6AD00AF5C16 /* WebAutomationSessionMacros.h in Headers */,
9228	1C0A19581C90068F00FE0EBB /* WebAutomationSessionMessages.h in Headers */,	9230	1C0A19581C90068F00FE0EBB /* WebAutomationSessionMessages.h in Headers */,
Lines 9263-9270 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec11
9263	3309344A1315B9220097A7BC /* WebCookieManagerProxyMessages.h in Headers */,	9265	3309344A1315B9220097A7BC /* WebCookieManagerProxyMessages.h in Headers */,
9264	BC1DD7B2114DC396005ADAF3 /* WebCoreArgumentCoders.h in Headers */,	9266	BC1DD7B2114DC396005ADAF3 /* WebCoreArgumentCoders.h in Headers */,
9265	512F589B12A8838800629530 /* WebCredential.h in Headers */,	9267	512F589B12A8838800629530 /* WebCredential.h in Headers */,
9266	5760829D202D2C4000116678 /* WebCredentialsMessengerMessages.h in Headers */,
9267	5760829F202D2C4600116678 /* WebCredentialsMessengerProxyMessages.h in Headers */,
9268	1AA83F6D1A5B63FF00026EC6 /* WebDatabaseProvider.h in Headers */,	9268	1AA83F6D1A5B63FF00026EC6 /* WebDatabaseProvider.h in Headers */,
9269	E52CF55220A35C3A00DADA27 /* WebDataListSuggestionPicker.h in Headers */,	9269	E52CF55220A35C3A00DADA27 /* WebDataListSuggestionPicker.h in Headers */,
9270	E568B91F20A3AB2F00E3C856 /* WebDataListSuggestionsDropdown.h in Headers */,	9270	E568B91F20A3AB2F00E3C856 /* WebDataListSuggestionsDropdown.h in Headers */,
Lines 10900-10905 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec12
10900	2684055218B86ED60022C38B /* ViewUpdateDispatcherMessageReceiver.cpp in Sources */,	10900	2684055218B86ED60022C38B /* ViewUpdateDispatcherMessageReceiver.cpp in Sources */,
10901	1A60224C18C16B9F00C3E8C9 /* VisitedLinkStoreMessageReceiver.cpp in Sources */,	10901	1A60224C18C16B9F00C3E8C9 /* VisitedLinkStoreMessageReceiver.cpp in Sources */,
10902	1A8E7D3C18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp in Sources */,	10902	1A8E7D3C18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp in Sources */,
		10903	57DCED6E2142EE5E0016B847 /* WebAuthenticatorCoordinatorMessageReceiver.cpp in Sources */,
		10904	57DCED702142EE680016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp in Sources */,
10903	1C0A19571C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp in Sources */,	10905	1C0A19571C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp in Sources */,
10904	1C0A19531C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp in Sources */,	10906	1C0A19531C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp in Sources */,
10905	517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */,	10907	517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */,
Lines 10907-10914 a/Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec13
10907	330934471315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp in Sources */,	10909	330934471315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp in Sources */,
10908	330934491315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp in Sources */,	10910	330934491315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp in Sources */,
10909	2D92A788212B6AB100F493FD /* WebCoreArgumentCoders.cpp in Sources */,	10911	2D92A788212B6AB100F493FD /* WebCoreArgumentCoders.cpp in Sources */,
10910	5760829C202D2C3C00116678 /* WebCredentialsMessengerMessageReceiver.cpp in Sources */,
10911	5760829E202D2C4300116678 /* WebCredentialsMessengerProxyMessageReceiver.cpp in Sources */,
10912	2D92A789212B6AB100F493FD /* WebEvent.cpp in Sources */,	10912	2D92A789212B6AB100F493FD /* WebEvent.cpp in Sources */,
10913	CD73BA4E131ACDB700EEDED2 /* WebFullScreenManagerMessageReceiver.cpp in Sources */,	10913	CD73BA4E131ACDB700EEDED2 /* WebFullScreenManagerMessageReceiver.cpp in Sources */,
10914	CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,	10914	CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +107 lines
		1	2018-09-08 Jiewen Tan <jiewen_tan@apple.com>
		2
		3	[WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=189277
		5	<rdar://problem/44115936>
		6
		7	Reviewed by Chris Dumez.
		8
		9	This patch aims to polish AuthenticatorManager such that:
		10	1) It is no longer a singleton. Instead, it will live with Page. It was a singleton simply because static
		11	PublicKeyCredential::isUserVerifyingPlatformAuthenticatorAvailable() have to access it. However, this request
		12	can be fulfilled by adding an attribute [CallWith=Document] to the IDL defination. Therefore, there is no
		13	such need. Also, the singleton is illy implemented as it owns a single IPC proxy to UI Process which means
		14	different web pages will talk to the same web page proxy. Anyway, making it live with Page should fix everything.
		15	2) Since we are now planning to support external authenticators, the manager of all authenticators will then
		16	have to live in UI Process which makes this AuthenticatorManager obsolete. Instead, rename it to AuthenticatorCoordinator.
		17	3) Rename CredentialsMessenger to AuthenticatorCoordinatorClient to tight it to WebAuthN. Also, simplify the
		18	message reply model as PublicKeyCredentialCreationOptions/PublicKeyCredentialRequestOptions =>
		19	ExceptionData/PublicKeyCredentialData for makeCredential/getAssertion operations.
		20	4) Restrict one request per time, i.e. makeCredential/getAssertion for a single page.
		21	5) Unifying makeCredentialReply/getAssertionReply/exceptionReply into requestReply for IPC. Correspondingly,
		22	unify callback and exceptionCallback into callback as well for LocalAuthenticator.
		23	6) Enhance PublicKeyCredentialCreationOptions encoding/decoding with encoder.encodeFixedLengthData/decoder.decodeFixedLengthData.
		24
		25	Covered by existing tests.
		26
		27	* DerivedSources.make:
		28	* Modules/credentialmanagement/CredentialsContainer.cpp:
		29	(WebCore::CredentialsContainer::get):
		30	(WebCore::CredentialsContainer::isCreate):
		31	* Modules/credentialmanagement/CredentialsContainer.h:
		32	* Modules/credentialmanagement/CredentialsMessenger.cpp: Removed.
		33	* Modules/credentialmanagement/CredentialsMessenger.h: Removed.
		34	* Modules/webauthn/AuthenticatorAssertionResponse.cpp: Removed.
		35	* Modules/webauthn/AuthenticatorAssertionResponse.h:
		36	(WebCore::AuthenticatorAssertionResponse::create):
		37	(WebCore::AuthenticatorAssertionResponse::authenticatorData const):
		38	(WebCore::AuthenticatorAssertionResponse::signature const):
		39	(WebCore::AuthenticatorAssertionResponse::userHandle const):
		40	(WebCore::AuthenticatorAssertionResponse::AuthenticatorAssertionResponse):
		41	* Modules/webauthn/AuthenticatorAttestationResponse.cpp: Removed.
		42	* Modules/webauthn/AuthenticatorAttestationResponse.h:
		43	(WebCore::AuthenticatorAttestationResponse::create):
		44	(WebCore::AuthenticatorAttestationResponse::attestationObject const):
		45	(WebCore::AuthenticatorAttestationResponse::AuthenticatorAttestationResponse):
		46	* Modules/webauthn/AuthenticatorCoordinator.cpp: Renamed from Source/WebCore/Modules/webauthn/AuthenticatorManager.cpp.
		47	(WebCore::AuthenticatorCoordinatorInternal::produceClientDataJson):
		48	(WebCore::AuthenticatorCoordinatorInternal::produceClientDataJsonHash):
		49	(WebCore::AuthenticatorCoordinatorInternal::initTimeoutTimer):
		50	(WebCore::AuthenticatorCoordinatorInternal::didTimeoutTimerFire):
		51	(WebCore::AuthenticatorCoordinator::AuthenticatorCoordinator):
		52	(WebCore::AuthenticatorCoordinator::setClient):
		53	(WebCore::AuthenticatorCoordinator::create const):
		54	(WebCore::AuthenticatorCoordinator::discoverFromExternalSource const):
		55	(WebCore::AuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable const):
		56	* Modules/webauthn/AuthenticatorCoordinator.h: Renamed from Source/WebCore/Modules/webauthn/AuthenticatorManager.h.
		57	* Modules/webauthn/AuthenticatorCoordinatorClient.cpp: Added.
		58	(WebCore::AuthenticatorCoordinatorClient::~AuthenticatorCoordinatorClient):
		59	(WebCore::AuthenticatorCoordinatorClient::requestReply):
		60	(WebCore::AuthenticatorCoordinatorClient::isUserVerifyingPlatformAuthenticatorAvailableReply):
		61	(WebCore::AuthenticatorCoordinatorClient::setRequestCompletionHandler):
		62	(WebCore::AuthenticatorCoordinatorClient::addQueryCompletionHandler):
		63	* Modules/webauthn/AuthenticatorCoordinatorClient.h: Copied from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.h.
		64	* Modules/webauthn/AuthenticatorResponse.cpp: Removed.
65	* Modules/webauthn/AuthenticatorResponse.h:
66	(WebCore::AuthenticatorResponse::AuthenticatorResponse):
67	(WebCore::AuthenticatorResponse::clientDataJSON const):
68	* Modules/webauthn/PublicKeyCredential.cpp:
69	(WebCore::PublicKeyCredential::create):
70	(WebCore::PublicKeyCredential::tryCreate):
71	(WebCore::PublicKeyCredential::PublicKeyCredential):
72	(WebCore::PublicKeyCredential::isUserVerifyingPlatformAuthenticatorAvailable):
73	* Modules/webauthn/PublicKeyCredential.h:
74	* Modules/webauthn/PublicKeyCredential.idl:
75	* Modules/webauthn/PublicKeyCredentialCreationOptions.h:
76	(WebCore::PublicKeyCredentialCreationOptions::encode const):
77	(WebCore::PublicKeyCredentialCreationOptions::decode):
78	* Modules/webauthn/PublicKeyCredentialData.h: Added.
79	(WebCore::PublicKeyCredentialData::encode const):
80	(WebCore::PublicKeyCredentialData::decode):
81	* Modules/webauthn/cocoa/LocalAuthenticator.h:
82	* Modules/webauthn/cocoa/LocalAuthenticator.mm:
83	(WebCore::LocalAuthenticator::makeCredential):
84	(WebCore::LocalAuthenticator::getAssertion):
85	* Sources.txt:
86	* WebCore.xcodeproj/project.pbxproj:
87	* page/Page.cpp:
88	* page/Page.h:
89	(WebCore::Page::authenticatorCoordinator const):
90	* page/PageConfiguration.cpp:
91	* page/PageConfiguration.h:
92	* testing/Internals.cpp:
93	(WebCore::Internals::Internals):
94	(WebCore::Internals::mockAuthenticatorCoordinator const):
95	(WebCore::Internals::mockCredentialsMessenger const): Deleted.
96	* testing/Internals.h:
97	* testing/Internals.idl:
98	* testing/MockAuthenticatorCoordinator.cpp: Added.
99	(WebCore::MockAuthenticatorCoordinator::setCreationReturnBundle):
100	(WebCore::MockAuthenticatorCoordinator::setAssertionReturnBundle):
101	(WebCore::MockAuthenticatorCoordinator::makeCredential):
102	(WebCore::MockAuthenticatorCoordinator::getAssertion):
103	(WebCore::MockAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable):
104	* testing/MockAuthenticatorCoordinator.h: Renamed from Source/WebCore/testing/MockCredentialsMessenger.h.
105	* testing/MockAuthenticatorCoordinator.idl: Renamed from Source/WebCore/testing/MockCredentialsMessenger.idl.
106	* testing/MockCredentialsMessenger.cpp: Removed.
107
1	2018-09-08 Andy Estes <aestes@apple.com>	108	2018-09-08 Andy Estes <aestes@apple.com>
2		109
3	[Apple Pay] Dispatch a paymentmethodchange event when the payment method changes	110	[Apple Pay] Dispatch a paymentmethodchange event when the payment method changes

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +40 lines
		1	2018-09-08 Jiewen Tan <jiewen_tan@apple.com>
		2
		3	[WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=189277
		5	<rdar://problem/44115936>
		6
		7	Reviewed by Chris Dumez.
		8
		9	* DerivedSources.make:
		10	* SourcesCocoa.txt:
		11	* UIProcess/CredentialManagement/WebCredentialsMessengerProxy.cpp: Removed.
		12	* UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp: Added.
		13	(WebKit::WebAuthenticatorCoordinatorProxy::WebAuthenticatorCoordinatorProxy):
		14	(WebKit::WebAuthenticatorCoordinatorProxy::~WebAuthenticatorCoordinatorProxy):
		15	(WebKit::WebAuthenticatorCoordinatorProxy::makeCredential):
		16	(WebKit::WebAuthenticatorCoordinatorProxy::getAssertion):
		17	(WebKit::WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailable):
		18	(WebKit::WebAuthenticatorCoordinatorProxy::requestReply):
		19	(WebKit::WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailableReply):
		20	* UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.h: Renamed from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.h.
		21	* UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.messages.in: Renamed from Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.messages.in.
		22	* UIProcess/WebPageProxy.cpp:
		23	(WebKit::m_resetRecentCrashCountTimer):
		24	(WebKit::WebPageProxy::reattachToWebProcess):
		25	* UIProcess/WebPageProxy.h:
		26	* WebKit.xcodeproj/project.pbxproj:
		27	* WebProcess/CredentialManagement/WebCredentialsMessenger.cpp: Removed.
		28	* WebProcess/WebAuthentication/WebAuthenticatorCoordinator.cpp: Added.
		29	(WebKit::WebAuthenticatorCoordinator::WebAuthenticatorCoordinator):
		30	(WebKit::WebAuthenticatorCoordinator::~WebAuthenticatorCoordinator):
		31	(WebKit::WebAuthenticatorCoordinator::makeCredential):
		32	(WebKit::WebAuthenticatorCoordinator::getAssertion):
		33	(WebKit::WebAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable):
		34	* WebProcess/WebAuthentication/WebAuthenticatorCoordinator.h: Renamed from Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.h.
		35	* WebProcess/WebAuthentication/WebAuthenticatorCoordinator.messages.in: Renamed from Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.messages.in.
		36	* WebProcess/WebPage/WebPage.cpp:
		37	(WebKit::m_cpuLimit):
		38	(WebKit::m_credentialsMessenger): Deleted.
		39	* WebProcess/WebPage/WebPage.h:
		40
1	2018-09-08 Tim Horton <timothy_horton@apple.com>	41	2018-09-08 Tim Horton <timothy_horton@apple.com>
2		42
3	Unify most of the WebKit Objective-C API sources	43	Unify most of the WebKit Objective-C API sources

Lines 962-970 JS_BINDING_IDLS = \ a/Source/WebCore/DerivedSources.make_sec1
- a/Source/WebCore/DerivedSources.make -1 / +1 lines
962	$(WebCore)/testing/Internals.idl \	962	$(WebCore)/testing/Internals.idl \
963	$(WebCore)/testing/MallocStatistics.idl \	963	$(WebCore)/testing/MallocStatistics.idl \
964	$(WebCore)/testing/MemoryInfo.idl \	964	$(WebCore)/testing/MemoryInfo.idl \
		965	$(WebCore)/testing/MockAuthenticatorCoordinator.idl \
965	$(WebCore)/testing/MockCDMFactory.idl \	966	$(WebCore)/testing/MockCDMFactory.idl \
966	$(WebCore)/testing/MockContentFilterSettings.idl \	967	$(WebCore)/testing/MockContentFilterSettings.idl \
967	$(WebCore)/testing/MockCredentialsMessenger.idl \
968	$(WebCore)/testing/MockPageOverlay.idl \	968	$(WebCore)/testing/MockPageOverlay.idl \
969	$(WebCore)/testing/MockPaymentAddress.idl \	969	$(WebCore)/testing/MockPaymentAddress.idl \
970	$(WebCore)/testing/MockPaymentCoordinator.idl \	970	$(WebCore)/testing/MockPaymentCoordinator.idl \

Lines 35-40 a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp_sec1
- a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp -6 / +5 lines
35	#include "Document.h"	35	#include "Document.h"
36	#include "ExceptionOr.h"	36	#include "ExceptionOr.h"
37	#include "JSDOMPromiseDeferred.h"	37	#include "JSDOMPromiseDeferred.h"
		38	#include "Page.h"
38	#include "SecurityOrigin.h"	39	#include "SecurityOrigin.h"
39		40
40	namespace WebCore {	41	namespace WebCore {
Lines 63-69 void CredentialsContainer::get(CredentialRequestOptions&& options, CredentialPro a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp_sec2
63	{	64	{
64	// The following implements https://www.w3.org/TR/credential-management-1/#algorithm-request as of 4 August 2017	65	// The following implements https://www.w3.org/TR/credential-management-1/#algorithm-request as of 4 August 2017
65	// with enhancement from 14 November 2017 Editor's Draft.	66	// with enhancement from 14 November 2017 Editor's Draft.
66	if (!m_document) {	67	if (!m_document \|\| !m_document->page()) {
67	promise.reject(Exception { NotSupportedError });	68	promise.reject(Exception { NotSupportedError });
68	return;	69	return;
69	}	70	}
Lines 82-89 void CredentialsContainer::get(CredentialRequestOptions&& options, CredentialPro a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp_sec3
82	return;	83	return;
83	}	84	}
84		85
85	// Async operations are dispatched/handled in (Web)CredentialMessenger, which exchanges messages between WebProcess and UIProcess.	86	m_document->page()->authenticatorCoordinator().discoverFromExternalSource(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
86	AuthenticatorManager::singleton().discoverFromExternalSource(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
87	}	87	}
88		88
89	void CredentialsContainer::store(const BasicCredential&, CredentialPromise&& promise)	89	void CredentialsContainer::store(const BasicCredential&, CredentialPromise&& promise)
Lines 95-101 void CredentialsContainer::isCreate(CredentialCreationOptions&& options, Credent a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp_sec4
95	{	95	{
96	// The following implements https://www.w3.org/TR/credential-management-1/#algorithm-create as of 4 August 2017	96	// The following implements https://www.w3.org/TR/credential-management-1/#algorithm-create as of 4 August 2017
97	// with enhancement from 14 November 2017 Editor's Draft.	97	// with enhancement from 14 November 2017 Editor's Draft.
98	if (!m_document) {	98	if (!m_document \|\| !m_document->page()) {
99	promise.reject(Exception { NotSupportedError });	99	promise.reject(Exception { NotSupportedError });
100	return;	100	return;
101	}	101	}
Lines 112-119 void CredentialsContainer::isCreate(CredentialCreationOptions&& options, Credent a/Source/WebCore/Modules/credentialmanagement/CredentialsContainer.cpp_sec5
112	return;	112	return;
113	}	113	}
114		114
115	// Async operations are dispatched/handled in (Web)CredentialMessenger, which exchanges messages between WebProcess and UIProcess.	115	m_document->page()->authenticatorCoordinator().create(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
116	AuthenticatorManager::singleton().create(m_document->securityOrigin(), options.publicKey.value(), doesHaveSameOriginAsItsAncestors(), WTFMove(options.signal), WTFMove(promise));
117	}	116	}
118		117
119	void CredentialsContainer::preventSilentAccess(DOMPromiseDeferred<void>&& promise) const	118	void CredentialsContainer::preventSilentAccess(DOMPromiseDeferred<void>&& promise) const

Lines 1-109 a/Source/WebCore/Modules/credentialmanagement/CredentialsMessenger.cpp_sec1
- a/Source/WebCore/Modules/credentialmanagement/CredentialsMessenger.cpp -109 lines
1	/*
2	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#include "config.h"
27	#include "CredentialsMessenger.h"
28
29	#if ENABLE(WEB_AUTHN)
30
31	namespace WebCore {
32
33	namespace CredentialsMessengerInternal {
34
35	const uint64_t maxMessageId = 0xFFFFFFFFFFFFFF; // 56 bits
36	const size_t callBackClassifierOffset = 56;
37
38	}
39
40	void CredentialsMessenger::exceptionReply(uint64_t messageId, const ExceptionData& exception)
41	{
42	using namespace CredentialsMessengerInternal;
43
44	if (!(messageId >> callBackClassifierOffset ^ CallBackClassifier::Creation)) {
45	auto handler = takeCreationCompletionHandler(messageId);
46	handler(exception.toException());
47	return;
48	}
49	if (!(messageId >> callBackClassifierOffset ^ CallBackClassifier::Request)) {
50	auto handler = takeRequestCompletionHandler(messageId);
51	handler(exception.toException());
52	return;
53	}
54	}
55
56	uint64_t CredentialsMessenger::addCreationCompletionHandler(CreationCompletionHandler&& handler)
57	{
58	using namespace CredentialsMessengerInternal;
59
60	uint64_t messageId = m_accumulatedMessageId++;
61	ASSERT(messageId <= maxMessageId);
62	messageId = messageId \| CallBackClassifier::Creation << callBackClassifierOffset;
63	auto addResult = m_pendingCreationCompletionHandlers.add(messageId, WTFMove(handler));
64	ASSERT_UNUSED(addResult, addResult.isNewEntry);
65	return messageId;
66	}
67
68	CreationCompletionHandler CredentialsMessenger::takeCreationCompletionHandler(uint64_t messageId)
69	{
70	return m_pendingCreationCompletionHandlers.take(messageId);
71	}
72
73	uint64_t CredentialsMessenger::addRequestCompletionHandler(RequestCompletionHandler&& handler)
74	{
75	using namespace CredentialsMessengerInternal;
76
77	uint64_t messageId = m_accumulatedMessageId++;
78	ASSERT(messageId <= maxMessageId);
79	messageId = messageId \| CallBackClassifier::Request << callBackClassifierOffset;
80	auto addResult = m_pendingRequestCompletionHandlers.add(messageId, WTFMove(handler));
81	ASSERT_UNUSED(addResult, addResult.isNewEntry);
82	return messageId;
83	}
84
85	RequestCompletionHandler CredentialsMessenger::takeRequestCompletionHandler(uint64_t messageId)
86	{
87	return m_pendingRequestCompletionHandlers.take(messageId);
88	}
89
90	uint64_t CredentialsMessenger::addQueryCompletionHandler(QueryCompletionHandler&& handler)
91	{
92	using namespace CredentialsMessengerInternal;
93
94	uint64_t messageId = m_accumulatedMessageId++;
95	ASSERT(messageId < maxMessageId);
96	messageId = messageId \| CallBackClassifier::Query << callBackClassifierOffset;
97	auto addResult = m_pendingQueryCompletionHandlers.add(messageId, WTFMove(handler));
98	ASSERT_UNUSED(addResult, addResult.isNewEntry);
99	return messageId;
100	}
101
102	QueryCompletionHandler CredentialsMessenger::takeQueryCompletionHandler(uint64_t messageId)
103	{
104	return m_pendingQueryCompletionHandlers.take(messageId);
105	}
106
107	} // namespace WebCore
108
109	#endif // ENABLE(WEB_AUTHN)

Lines 1-58 a/Source/WebCore/Modules/webauthn/AuthenticatorAssertionResponse.cpp_sec1
- a/Source/WebCore/Modules/webauthn/AuthenticatorAssertionResponse.cpp -58 lines
1	/*
2	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#include "config.h"
27	#include "AuthenticatorAssertionResponse.h"
28
29	#if ENABLE(WEB_AUTHN)
30
31	namespace WebCore {
32
33	AuthenticatorAssertionResponse::AuthenticatorAssertionResponse(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& authenticatorData, RefPtr<ArrayBuffer>&& signature, RefPtr<ArrayBuffer>&& userHandle)
34	: AuthenticatorResponse(WTFMove(clientDataJSON))
35	, m_authenticatorData(WTFMove(authenticatorData))
36	, m_signature(WTFMove(signature))
37	, m_userHandle(WTFMove(userHandle))
38	{
39	}
40
41	ArrayBuffer* AuthenticatorAssertionResponse::authenticatorData() const
42	{
43	return m_authenticatorData.get();
44	}
45
46	ArrayBuffer* AuthenticatorAssertionResponse::signature() const
47	{
48	return m_signature.get();
49	}
50
51	ArrayBuffer* AuthenticatorAssertionResponse::userHandle() const
52	{
53	return m_userHandle.get();
54	}
55
56	} // namespace WebCore
57
58	#endif // ENABLE(WEB_AUTHN)

Lines 33-57 namespace WebCore { a/Source/WebCore/Modules/webauthn/AuthenticatorAssertionResponse.h_sec1
- a/Source/WebCore/Modules/webauthn/AuthenticatorAssertionResponse.h -8 / +14 lines
33		33
34	class AuthenticatorAssertionResponse : public AuthenticatorResponse {	34	class AuthenticatorAssertionResponse : public AuthenticatorResponse {
35	public:	35	public:
36	static Ref<AuthenticatorAssertionResponse> create(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& authenticatorData, RefPtr<ArrayBuffer>&& signature, RefPtr<ArrayBuffer>&& userHandle)	36	static Ref<AuthenticatorAssertionResponse> create(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& authenticatorData, Ref<ArrayBuffer>&& signature, Ref<ArrayBuffer>&& userHandle)
37	{	37	{
38	return adoptRef(*new AuthenticatorAssertionResponse(WTFMove(clientDataJSON), WTFMove(authenticatorData), WTFMove(signature), WTFMove(userHandle)));	38	return adoptRef(*new AuthenticatorAssertionResponse(WTFMove(clientDataJSON), WTFMove(authenticatorData), WTFMove(signature), WTFMove(userHandle)));
39	}	39	}
40		40
41	virtual ~AuthenticatorAssertionResponse() = default;	41	virtual ~AuthenticatorAssertionResponse() = default;
42		42
43	ArrayBuffer* authenticatorData() const;	43	ArrayBuffer* authenticatorData() const { return m_authenticatorData.ptr(); }
44	ArrayBuffer* signature() const;	44	ArrayBuffer* signature() const { return m_signature.ptr(); }
45	ArrayBuffer* userHandle() const;	45	ArrayBuffer* userHandle() const { return m_userHandle.ptr(); }
46		46
47	private:	47	private:
48	AuthenticatorAssertionResponse(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& authenticatorData, RefPtr<ArrayBuffer>&& signature, RefPtr<ArrayBuffer>&& userHandle);	48	AuthenticatorAssertionResponse(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& authenticatorData, Ref<ArrayBuffer>&& signature, Ref<ArrayBuffer>&& userHandle)
		49	: AuthenticatorResponse(WTFMove(clientDataJSON))
		50	, m_authenticatorData(WTFMove(authenticatorData))
		51	, m_signature(WTFMove(signature))
		52	, m_userHandle(WTFMove(userHandle))
		53	{
		54	}
49		55
50	Type type() const final { return Type::Assertion; }	56	Type type() const final { return Type::Assertion; }
51		57
52	RefPtr<ArrayBuffer> m_authenticatorData;	58	Ref<ArrayBuffer> m_authenticatorData;
53	RefPtr<ArrayBuffer> m_signature;	59	Ref<ArrayBuffer> m_signature;
54	RefPtr<ArrayBuffer> m_userHandle;	60	Ref<ArrayBuffer> m_userHandle;
55	};	61	};
56		62
57	} // namespace WebCore	63	} // namespace WebCore

Lines 33-53 namespace WebCore { a/Source/WebCore/Modules/webauthn/AuthenticatorAttestationResponse.h_sec1
- a/Source/WebCore/Modules/webauthn/AuthenticatorAttestationResponse.h -4 / +8 lines
33		33
34	class AuthenticatorAttestationResponse : public AuthenticatorResponse {	34	class AuthenticatorAttestationResponse : public AuthenticatorResponse {
35	public:	35	public:
36	static Ref<AuthenticatorAttestationResponse> create(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& attestationObject)	36	static Ref<AuthenticatorAttestationResponse> create(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& attestationObject)
37	{	37	{
38	return adoptRef(*new AuthenticatorAttestationResponse(WTFMove(clientDataJSON), WTFMove(attestationObject)));	38	return adoptRef(*new AuthenticatorAttestationResponse(WTFMove(clientDataJSON), WTFMove(attestationObject)));
39	}	39	}
40		40
41	virtual ~AuthenticatorAttestationResponse() = default;	41	virtual ~AuthenticatorAttestationResponse() = default;
42		42
43	ArrayBuffer* attestationObject() const;	43	ArrayBuffer* attestationObject() const { return m_attestationObject.ptr(); }
44		44
45	private:	45	private:
46	AuthenticatorAttestationResponse(RefPtr<ArrayBuffer>&& clientDataJSON, RefPtr<ArrayBuffer>&& attestationObject);	46	AuthenticatorAttestationResponse(Ref<ArrayBuffer>&& clientDataJSON, Ref<ArrayBuffer>&& attestationObject)
		47	: AuthenticatorResponse(WTFMove(clientDataJSON))
		48	, m_attestationObject(WTFMove(attestationObject))
		49	{
		50	}
47		51
48	Type type() const final { return Type::Attestation; }	52	Type type() const final { return Type::Attestation; }
49		53
50	RefPtr<ArrayBuffer> m_attestationObject;	54	Ref<ArrayBuffer> m_attestationObject;
51	};	55	};
52		56
53	} // namespace WebCore	57	} // namespace WebCore

Lines 40-54 public: a/Source/WebCore/Modules/webauthn/AuthenticatorResponse.h_sec1
- a/Source/WebCore/Modules/webauthn/AuthenticatorResponse.h -3 / +6 lines
40	Attestation	40	Attestation
41	};	41	};
42		42
43	explicit AuthenticatorResponse(RefPtr<ArrayBuffer>&&);	43	explicit AuthenticatorResponse(Ref<ArrayBuffer>&& clientDataJSON)
		44	: m_clientDataJSON(WTFMove(clientDataJSON))
		45	{
		46	}
44	virtual ~AuthenticatorResponse() = default;	47	virtual ~AuthenticatorResponse() = default;
45		48
46	virtual Type type() const = 0;	49	virtual Type type() const = 0;
47		50
48	ArrayBuffer* clientDataJSON() const;	51	ArrayBuffer* clientDataJSON() const { return m_clientDataJSON.ptr(); }
49		52
50	private:	53	private:
51	RefPtr<ArrayBuffer> m_clientDataJSON;	54	Ref<ArrayBuffer> m_clientDataJSON;
52	};	55	};
53		56
54	} // namespace WebCore	57	} // namespace WebCore

Lines 94-102 template<class Encoder> a/Source/WebCore/Modules/webauthn/PublicKeyCredentialCreationOptions.h_sec1
- a/Source/WebCore/Modules/webauthn/PublicKeyCredentialCreationOptions.h -4 / +11 lines
94	void PublicKeyCredentialCreationOptions::encode(Encoder& encoder) const	94	void PublicKeyCredentialCreationOptions::encode(Encoder& encoder) const
95	{	95	{
96	encoder << rp.id << rp.name << rp.icon;	96	encoder << rp.id << rp.name << rp.icon;
97	Vector<uint8_t> idVector;	97	encoder << static_cast<uint64_t>(user.id.length());
98	idVector.append(user.id.data(), user.id.length());	98	encoder.encodeFixedLengthData(user.id.data(), user.id.length(), 1);
99	encoder << idVector << user.displayName << user.name << user.icon << pubKeyCredParams << excludeCredentials;	99	encoder << user.displayName << user.name << user.icon << pubKeyCredParams << excludeCredentials;
100	}	100	}
101		101
102	template<class Decoder>	102	template<class Decoder>
Lines 109-116 std::optional<PublicKeyCredentialCreationOptions> PublicKeyCredentialCreationOpt a/Source/WebCore/Modules/webauthn/PublicKeyCredentialCreationOptions.h_sec2
109	return std::nullopt;	109	return std::nullopt;
110	if (!decoder.decode(result.rp.icon))	110	if (!decoder.decode(result.rp.icon))
111	return std::nullopt;	111	return std::nullopt;
112	if (!decoder.decode(result.user.idVector))	112
		113	std::optional<uint64_t> userIdLength;
		114	decoder >> userIdLength;
		115	if (!userIdLength)
		116	return std::nullopt;
		117	result.user.idVector.reserveCapacity(userIdLength.value());
		118	if (!decoder.decodeFixedLengthData(result.user.idVector.data(), userIdLength.value(), 1))
113	return std::nullopt;	119	return std::nullopt;
		120
114	if (!decoder.decode(result.user.displayName))	121	if (!decoder.decode(result.user.displayName))
115	return std::nullopt;	122	return std::nullopt;
116	if (!decoder.decode(result.user.name))	123	if (!decoder.decode(result.user.name))

Lines 267-274 a/Source/WebCore/testing/Internals.cpp_sec1
- a/Source/WebCore/testing/Internals.cpp -6 / +9 lines
267	#endif	267	#endif
268		268
269	#if ENABLE(WEB_AUTHN)	269	#if ENABLE(WEB_AUTHN)
270	#include "AuthenticatorManager.h"	270	#include "AuthenticatorCoordinator.h"
271	#include "MockCredentialsMessenger.h"	271	#include "MockAuthenticatorCoordinator.h"
272	#endif	272	#endif
273		273
274	using JSC::CallData;	274	using JSC::CallData;
Lines 549-556 Internals::Internals(Document& document) a/Source/WebCore/testing/Internals.cpp_sec2
549	#endif	549	#endif
550		550
551	#if ENABLE(WEB_AUTHN)	551	#if ENABLE(WEB_AUTHN)
552	m_mockCredentialsMessenger = std::make_unique<MockCredentialsMessenger>(*this);	552	if (document.page()) {
553	AuthenticatorManager::singleton().setMessenger(*m_mockCredentialsMessenger);	553	auto mockAuthenticatorCoordinator = std::make_unique<MockAuthenticatorCoordinator>();
		554	m_mockAuthenticatorCoordinator = makeWeakPtr(mockAuthenticatorCoordinator.get());
		555	document.page()->authenticatorCoordinator().setClient(WTFMove(mockAuthenticatorCoordinator));
		556	}
554	#endif	557	#endif
555	}	558	}
556		559
Lines 4620-4628 MockPaymentCoordinator& Internals::mockPaymentCoordinator() const a/Source/WebCore/testing/Internals.cpp_sec3
4620	#endif	4623	#endif
4621		4624
4622	#if ENABLE(WEB_AUTHN)	4625	#if ENABLE(WEB_AUTHN)
4623	MockCredentialsMessenger& Internals::mockCredentialsMessenger() const	4626	MockAuthenticatorCoordinator& Internals::mockAuthenticatorCoordinator() const
4624	{	4627	{
4625	return *m_mockCredentialsMessenger;	4628	return *m_mockAuthenticatorCoordinator;
4626	}	4629	}
4627	#endif	4630	#endif
4628		4631

Lines 35-45 namespace WebCore { a/Source/WebCore/Modules/webauthn/cocoa/LocalAuthenticator.h_sec1
- a/Source/WebCore/Modules/webauthn/cocoa/LocalAuthenticator.h -5 / +4 lines
35		35
36	struct ExceptionData;	36	struct ExceptionData;
37	struct PublicKeyCredentialCreationOptions;	37	struct PublicKeyCredentialCreationOptions;
		38	struct PublicKeyCredentialData;
38	struct PublicKeyCredentialRequestOptions;	39	struct PublicKeyCredentialRequestOptions;
39		40
40	using CreationCallback = Function<void(const Vector<uint8_t>&, const Vector<uint8_t>&)>;	41	using Callback = Function<void(Variant<PublicKeyCredentialData, ExceptionData>&&)>;
41	using RequestCallback = Function<void(const Vector<uint8_t>&, const Vector<uint8_t>&, const Vector<uint8_t>&, const Vector<uint8_t>&)>;
42	using ExceptionCallback = Function<void(const WebCore::ExceptionData&)>;
43		42
44	typedef void (^CompletionBlock)(SecKeyRef _Nullable referenceKey, NSArray * _Nullable certificates, NSError * _Nullable error);	43	typedef void (^CompletionBlock)(SecKeyRef _Nullable referenceKey, NSArray * _Nullable certificates, NSError * _Nullable error);
45		44
Lines 50-57 public: a/Source/WebCore/Modules/webauthn/cocoa/LocalAuthenticator.h_sec2
50	LocalAuthenticator();	49	LocalAuthenticator();
51	virtual ~LocalAuthenticator() = default;	50	virtual ~LocalAuthenticator() = default;
52		51
53	void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, CreationCallback&&, ExceptionCallback&&);	52	void makeCredential(const Vector<uint8_t>& hash, const PublicKeyCredentialCreationOptions&, Callback&&);
54	void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, RequestCallback&&, ExceptionCallback&&);	53	void getAssertion(const Vector<uint8_t>& hash, const PublicKeyCredentialRequestOptions&, Callback&&);
55	bool isAvailable() const;	54	bool isAvailable() const;
56		55
57	protected:	56	protected:

Lines 45-51 Modules/cache/WorkerGlobalScopeCaches.cpp a/Source/WebCore/Sources.txt_sec1
- a/Source/WebCore/Sources.txt -5 / +2 lines
45		45
46	Modules/credentialmanagement/BasicCredential.cpp	46	Modules/credentialmanagement/BasicCredential.cpp
47	Modules/credentialmanagement/CredentialsContainer.cpp	47	Modules/credentialmanagement/CredentialsContainer.cpp
48	Modules/credentialmanagement/CredentialsMessenger.cpp
49	Modules/credentialmanagement/NavigatorCredentials.cpp	48	Modules/credentialmanagement/NavigatorCredentials.cpp
50		49
51	Modules/entriesapi/ErrorCallback.cpp	50	Modules/entriesapi/ErrorCallback.cpp
Lines 247-256 Modules/webaudio/WaveShaperDSPKernel.cpp a/Source/WebCore/Sources.txt_sec2
247	Modules/webaudio/WaveShaperNode.cpp	246	Modules/webaudio/WaveShaperNode.cpp
248	Modules/webaudio/WaveShaperProcessor.cpp	247	Modules/webaudio/WaveShaperProcessor.cpp
249		248
250	Modules/webauthn/AuthenticatorAssertionResponse.cpp	249	Modules/webauthn/AuthenticatorCoordinator.cpp
251	Modules/webauthn/AuthenticatorAttestationResponse.cpp	250	Modules/webauthn/AuthenticatorCoordinatorClient.cpp
252	Modules/webauthn/AuthenticatorManager.cpp
253	Modules/webauthn/AuthenticatorResponse.cpp
254	Modules/webauthn/PublicKeyCredential.cpp	251	Modules/webauthn/PublicKeyCredential.cpp
255	Modules/webauthn/cbor/CBORReader.cpp	252	Modules/webauthn/cbor/CBORReader.cpp
256	Modules/webauthn/cbor/CBORValue.cpp	253	Modules/webauthn/cbor/CBORValue.cpp

Lines 77-83 class MediaStreamTrack; a/Source/WebCore/testing/Internals.h_sec1
- a/Source/WebCore/testing/Internals.h -3 / +3 lines
77	class MemoryInfo;	77	class MemoryInfo;
78	class MockCDMFactory;	78	class MockCDMFactory;
79	class MockContentFilterSettings;	79	class MockContentFilterSettings;
80	class MockCredentialsMessenger;	80	class MockAuthenticatorCoordinator;
81	class MockPageOverlay;	81	class MockPageOverlay;
82	class MockPaymentCoordinator;	82	class MockPaymentCoordinator;
83	class NodeList;	83	class NodeList;
Lines 697-703 public: a/Source/WebCore/testing/Internals.h_sec2
697	void testIncomingSyncIPCMessageWhileWaitingForSyncReply();	697	void testIncomingSyncIPCMessageWhileWaitingForSyncReply();
698		698
699	#if ENABLE(WEB_AUTHN)	699	#if ENABLE(WEB_AUTHN)
700	MockCredentialsMessenger& mockCredentialsMessenger() const;	700	MockAuthenticatorCoordinator& mockAuthenticatorCoordinator() const;
701	#endif	701	#endif
702		702
703	bool isSystemPreviewLink(Element&) const;	703	bool isSystemPreviewLink(Element&) const;
Lines 763-769 private: a/Source/WebCore/testing/Internals.h_sec3
763	#endif	763	#endif
764		764
765	#if ENABLE(WEB_AUTHN)	765	#if ENABLE(WEB_AUTHN)
766	std::unique_ptr<MockCredentialsMessenger> m_mockCredentialsMessenger;	766	WeakPtr<MockAuthenticatorCoordinator> m_mockAuthenticatorCoordinator;
767	#endif	767	#endif
768	};	768	};
769		769

Line 0 a/Source/WebCore/testing/MockAuthenticatorCoordinator.cpp_sec1
- a/Source/WebCore/testing/MockAuthenticatorCoordinator.cpp +115 lines
		1	/*
		2	* Copyright (C) 2018 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "MockAuthenticatorCoordinator.h"
		28
		29	#if ENABLE(WEB_AUTHN)
		30
		31	#include "Internals.h"
		32	#include <WebCore/PublicKeyCredentialData.h>
		33	#include <wtf/Vector.h>
		34
		35	namespace WebCore {
		36
		37	void MockAuthenticatorCoordinator::setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject)
		38	{
		39	ASSERT(!m_credentialId && !m_attestationObject);
		40	m_credentialId = ArrayBuffer::create(credentialId.data(), credentialId.length());
		41	m_attestationObject = ArrayBuffer::create(attestationObject.data(), attestationObject.length());
		42	}
		43
		44	void MockAuthenticatorCoordinator::setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle)
		45	{
		46	ASSERT(!m_credentialId && !m_authenticatorData && !m_signature && !m_userHandle);
		47	m_credentialId = ArrayBuffer::create(credentialId.data(), credentialId.length());
		48	m_authenticatorData = ArrayBuffer::create(authenticatorData.data(), authenticatorData.length());
		49	m_signature = ArrayBuffer::create(signature.data(), signature.length());
		50	m_userHandle = ArrayBuffer::create(userHandle.data(), userHandle.length());
		51	}
		52
		53	void MockAuthenticatorCoordinator::makeCredential(const Vector<uint8_t>&, const PublicKeyCredentialCreationOptions&, RequestCompletionHandler&& handler)
		54	{
		55	if (!setRequestCompletionHandler(WTFMove(handler)))
		56	return;
		57
		58	if (m_didTimeOut) {
		59	m_didTimeOut = false;
		60	return;
		61	}
		62	if (m_didUserCancel) {
		63	m_didUserCancel = false;
		64	requestReply({ }, { NotAllowedError, "User cancelled."_s });
65	return;
66	}
67	if (m_credentialId) {
68	ASSERT(m_attestationObject);
69	requestReply(PublicKeyCredentialData { WTFMove(m_credentialId), true, nullptr, WTFMove(m_attestationObject), nullptr, nullptr, nullptr }, { });
70	m_credentialId = nullptr;
71	m_attestationObject = nullptr;
72	return;
73	}
74	ASSERT_NOT_REACHED();
75	}
76
77	void MockAuthenticatorCoordinator::getAssertion(const Vector<uint8_t>&, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&& handler)
78	{
79	if (!setRequestCompletionHandler(WTFMove(handler)))
80	return;
81
82	if (m_didTimeOut) {
83	m_didTimeOut = false;
84	return;
85	}
86	if (m_didUserCancel) {
87	m_didUserCancel = false;
88	requestReply({ }, { NotAllowedError, "User cancelled."_s });
89	return;
90	}
91	if (m_credentialId) {
92	ASSERT(m_authenticatorData && m_signature && m_userHandle);
93	requestReply(PublicKeyCredentialData { WTFMove(m_credentialId), false, nullptr, nullptr, WTFMove(m_authenticatorData), WTFMove(m_signature), WTFMove(m_userHandle) }, { });
94	m_credentialId = nullptr;
95	m_authenticatorData = nullptr;
96	m_signature = nullptr;
97	m_userHandle = nullptr;
98	return;
99	}
100	ASSERT_NOT_REACHED();
101	}
102
103	void MockAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&& handler)
104	{
105	auto messageId = addQueryCompletionHandler(WTFMove(handler));
106	if (m_didUserVerifyingPlatformAuthenticatorPresent) {
107	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, true);
108	m_didUserVerifyingPlatformAuthenticatorPresent = false;
109	} else
110	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
111	}
112
113	} // namespace WebCore
114
115	#endif // ENABLE(WEB_AUTHN)

Lines 1-152 a/Source/WebCore/testing/MockCredentialsMessenger.cpp_sec1
- a/Source/WebCore/testing/MockCredentialsMessenger.cpp -152 lines
1	/*
2	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#include "config.h"
27	#include "MockCredentialsMessenger.h"
28
29	#if ENABLE(WEB_AUTHN)
30
31	#include "Internals.h"
32	#include <wtf/Vector.h>
33
34	namespace WebCore {
35
36	MockCredentialsMessenger::MockCredentialsMessenger(Internals& internals)
37	: m_internals(internals)
38	{
39	}
40
41	MockCredentialsMessenger::~MockCredentialsMessenger()
42	{
43	// Have no effects to original promises. Just to call handlers to avoid any assertion failures.
44	for (auto messageId : m_timeOutMessageIds)
45	exceptionReply(messageId, ExceptionData { NotAllowedError, "Operation timed out."_s });
46	}
47
48	void MockCredentialsMessenger::setCreationReturnBundle(const BufferSource& credentialId, const BufferSource& attestationObject)
49	{
50	ASSERT(m_credentialId.isEmpty() && m_attestationObject.isEmpty());
51	m_credentialId.append(credentialId.data(), credentialId.length());
52	m_attestationObject.append(attestationObject.data(), attestationObject.length());
53	}
54
55	void MockCredentialsMessenger::setAssertionReturnBundle(const BufferSource& credentialId, const BufferSource& authenticatorData, const BufferSource& signature, const BufferSource& userHandle)
56	{
57	ASSERT(m_credentialId.isEmpty() && m_authenticatorData.isEmpty() && m_signature.isEmpty() && m_userHandle.isEmpty());
58	m_credentialId.append(credentialId.data(), credentialId.length());
59	m_authenticatorData.append(authenticatorData.data(), authenticatorData.length());
60	m_signature.append(signature.data(), signature.length());
61	m_userHandle.append(userHandle.data(), userHandle.length());
62	}
63
64	void MockCredentialsMessenger::ref()
65	{
66	m_internals.ref();
67	}
68
69	void MockCredentialsMessenger::deref()
70	{
71	m_internals.deref();
72	}
73
74	void MockCredentialsMessenger::makeCredential(const Vector<uint8_t>&, const PublicKeyCredentialCreationOptions&, CreationCompletionHandler&& handler)
75	{
76	auto messageId = addCreationCompletionHandler(WTFMove(handler));
77	if (m_didTimeOut) {
78	m_didTimeOut = false;
79	m_timeOutMessageIds.append(messageId);
80	return;
81	}
82	if (m_didUserCancel) {
83	m_didUserCancel = false;
84	exceptionReply(messageId, ExceptionData { NotAllowedError, "User cancelled."_s });
85	return;
86	}
87	if (!m_credentialId.isEmpty()) {
88	ASSERT(!m_attestationObject.isEmpty());
89	makeCredentialReply(messageId, m_credentialId, m_attestationObject);
90	m_credentialId.clear();
91	m_attestationObject.clear();
92	return;
93	}
94	ASSERT_NOT_REACHED();
95	}
96
97	void MockCredentialsMessenger::getAssertion(const Vector<uint8_t>&, const PublicKeyCredentialRequestOptions&, RequestCompletionHandler&& handler)
98	{
99	auto messageId = addRequestCompletionHandler(WTFMove(handler));
100	if (m_didTimeOut) {
101	m_didTimeOut = false;
102	m_timeOutMessageIds.append(messageId);
103	return;
104	}
105	if (m_didUserCancel) {
106	m_didUserCancel = false;
107	exceptionReply(messageId, ExceptionData { NotAllowedError, "User cancelled."_s });
108	return;
109	}
110	if (!m_credentialId.isEmpty()) {
111	ASSERT(!m_authenticatorData.isEmpty() && !m_signature.isEmpty() && !m_userHandle.isEmpty());
112	getAssertionReply(messageId, m_credentialId, m_authenticatorData, m_signature, m_userHandle);
113	m_credentialId.clear();
114	m_authenticatorData.clear();
115	m_signature.clear();
116	m_userHandle.clear();
117	return;
118	}
119	ASSERT_NOT_REACHED();
120	}
121
122	void MockCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailable(QueryCompletionHandler&& handler)
123	{
124	auto messageId = addQueryCompletionHandler(WTFMove(handler));
125	if (m_didUserVerifyingPlatformAuthenticatorPresent) {
126	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, true);
127	m_didUserVerifyingPlatformAuthenticatorPresent = false;
128	} else
129	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
130	}
131
132	void MockCredentialsMessenger::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
133	{
134	auto handler = takeCreationCompletionHandler(messageId);
135	handler(CreationReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(attestationObject.data(), attestationObject.size())));
136	}
137
138	void MockCredentialsMessenger::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
139	{
140	auto handler = takeRequestCompletionHandler(messageId);
141	handler(AssertionReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(authenticatorData.data(), authenticatorData.size()), ArrayBuffer::create(signature.data(), signature.size()), ArrayBuffer::create(userHandle.data(), userHandle.size())));
142	}
143
144	void MockCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
145	{
146	auto handler = takeQueryCompletionHandler(messageId);
147	handler(result);
148	}
149
150	} // namespace WebCore
151
152	#endif // ENABLE(WEB_AUTHN)

Lines 43-49 VPATH = \ a/Source/WebKit/DerivedSources.make_sec1
- a/Source/WebKit/DerivedSources.make -4 / +4 lines
43	$(WebKit2)/WebProcess/ApplicationCache \	43	$(WebKit2)/WebProcess/ApplicationCache \
44	$(WebKit2)/WebProcess/Automation \	44	$(WebKit2)/WebProcess/Automation \
45	$(WebKit2)/WebProcess/Cache \	45	$(WebKit2)/WebProcess/Cache \
46	$(WebKit2)/WebProcess/CredentialManagement \
47	$(WebKit2)/WebProcess/Databases/IndexedDB \	46	$(WebKit2)/WebProcess/Databases/IndexedDB \
48	$(WebKit2)/WebProcess/FullScreen \	47	$(WebKit2)/WebProcess/FullScreen \
49	$(WebKit2)/WebProcess/Geolocation \	48	$(WebKit2)/WebProcess/Geolocation \
Lines 58-63 VPATH = \ a/Source/WebKit/DerivedSources.make_sec2
58	$(WebKit2)/WebProcess/ResourceCache \	57	$(WebKit2)/WebProcess/ResourceCache \
59	$(WebKit2)/WebProcess/Storage \	58	$(WebKit2)/WebProcess/Storage \
60	$(WebKit2)/WebProcess/UserContent \	59	$(WebKit2)/WebProcess/UserContent \
		60	$(WebKit2)/WebProcess/WebAuthentication \
61	$(WebKit2)/WebProcess/WebCoreSupport \	61	$(WebKit2)/WebProcess/WebCoreSupport \
62	$(WebKit2)/WebProcess/WebPage \	62	$(WebKit2)/WebProcess/WebPage \
63	$(WebKit2)/WebProcess/WebPage/RemoteLayerTree \	63	$(WebKit2)/WebProcess/WebPage/RemoteLayerTree \
Lines 69-75 VPATH = \ a/Source/WebKit/DerivedSources.make_sec3
69	$(WebKit2)/UIProcess/ApplePay \	69	$(WebKit2)/UIProcess/ApplePay \
70	$(WebKit2)/UIProcess/Automation \	70	$(WebKit2)/UIProcess/Automation \
71	$(WebKit2)/UIProcess/Cocoa \	71	$(WebKit2)/UIProcess/Cocoa \
72	$(WebKit2)/UIProcess/CredentialManagement \
73	$(WebKit2)/UIProcess/Databases \	72	$(WebKit2)/UIProcess/Databases \
74	$(WebKit2)/UIProcess/Downloads \	73	$(WebKit2)/UIProcess/Downloads \
75	$(WebKit2)/UIProcess/MediaStream \	74	$(WebKit2)/UIProcess/MediaStream \
Lines 80-85 VPATH = \ a/Source/WebKit/DerivedSources.make_sec4
80	$(WebKit2)/UIProcess/RemoteLayerTree \	79	$(WebKit2)/UIProcess/RemoteLayerTree \
81	$(WebKit2)/UIProcess/Storage \	80	$(WebKit2)/UIProcess/Storage \
82	$(WebKit2)/UIProcess/UserContent \	81	$(WebKit2)/UIProcess/UserContent \
		82	$(WebKit2)/UIProcess/WebAuthentication \
83	$(WebKit2)/UIProcess/WebStorage \	83	$(WebKit2)/UIProcess/WebStorage \
84	$(WebKit2)/UIProcess/mac \	84	$(WebKit2)/UIProcess/mac \
85	$(WebKit2)/UIProcess/ios \	85	$(WebKit2)/UIProcess/ios \
Lines 149-156 MESSAGE_RECEIVERS = \ a/Source/WebKit/DerivedSources.make_sec5
149	WebConnection \	149	WebConnection \
150	WebCookieManager \	150	WebCookieManager \
151	WebCookieManagerProxy \	151	WebCookieManagerProxy \
152	WebCredentialsMessenger \	152	WebAuthenticatorCoordinator \
153	WebCredentialsMessengerProxy \	153	WebAuthenticatorCoordinatorProxy \
154	WebFullScreenManager \	154	WebFullScreenManager \
155	WebFullScreenManagerProxy \	155	WebFullScreenManagerProxy \
156	WebGeolocationManager \	156	WebGeolocationManager \

Lines 344-351 UIProcess/Cocoa/WebViewImpl.mm a/Source/WebKit/SourcesCocoa.txt_sec1
- a/Source/WebKit/SourcesCocoa.txt -4 / +4 lines
344	UIProcess/Cocoa/WKReloadFrameErrorRecoveryAttempter.mm	344	UIProcess/Cocoa/WKReloadFrameErrorRecoveryAttempter.mm
345	UIProcess/Cocoa/WKWebViewContentProviderRegistry.mm	345	UIProcess/Cocoa/WKWebViewContentProviderRegistry.mm
346		346
347	UIProcess/CredentialManagement/WebCredentialsMessengerProxy.cpp
348
349	UIProcess/Gamepad/cocoa/UIGamepadProviderCocoa.mm	347	UIProcess/Gamepad/cocoa/UIGamepadProviderCocoa.mm
350	UIProcess/Gamepad/ios/UIGamepadProviderIOS.mm	348	UIProcess/Gamepad/ios/UIGamepadProviderIOS.mm
351	UIProcess/Gamepad/mac/UIGamepadProviderMac.mm	349	UIProcess/Gamepad/mac/UIGamepadProviderMac.mm
Lines 456-461 UIProcess/RemoteLayerTree/RemoteLayerTreeScrollingPerformanceData.mm a/Source/WebKit/SourcesCocoa.txt_sec2
456	UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp	454	UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp
457	UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp	455	UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp
458		456
		457	UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp
		458
459	UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm	459	UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
460		460
461	UIProcess/WebStorage/StorageManager.cpp	461	UIProcess/WebStorage/StorageManager.cpp
Lines 464-471 UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm a/Source/WebKit/SourcesCocoa.txt_sec3
464		464
465	WebProcess/ApplePay/WebPaymentCoordinator.cpp	465	WebProcess/ApplePay/WebPaymentCoordinator.cpp
466		466
467	WebProcess/CredentialManagement/WebCredentialsMessenger.cpp
468
469	WebProcess/cocoa/PlaybackSessionManager.mm	467	WebProcess/cocoa/PlaybackSessionManager.mm
470	WebProcess/cocoa/UserMediaCaptureManager.cpp	468	WebProcess/cocoa/UserMediaCaptureManager.cpp
471	WebProcess/cocoa/VideoFullscreenManager.mm	469	WebProcess/cocoa/VideoFullscreenManager.mm
Lines 510-515 WebProcess/Plugins/PDF/PDFPluginChoiceAnnotation.mm a/Source/WebKit/SourcesCocoa.txt_sec4
510	WebProcess/Plugins/PDF/PDFPluginPasswordField.mm	508	WebProcess/Plugins/PDF/PDFPluginPasswordField.mm
511	WebProcess/Plugins/PDF/PDFPluginTextAnnotation.mm	509	WebProcess/Plugins/PDF/PDFPluginTextAnnotation.mm
512		510
		511	WebProcess/WebAuthentication/WebAuthenticatorCoordinator.cpp
		512
513	WebProcess/WebCoreSupport/WebDataListSuggestionPicker.cpp	513	WebProcess/WebCoreSupport/WebDataListSuggestionPicker.cpp
514	WebProcess/WebCoreSupport/WebPasteboardOverrides.cpp	514	WebProcess/WebCoreSupport/WebPasteboardOverrides.cpp
515	WebProcess/WebCoreSupport/WebValidationMessageClient.cpp	515	WebProcess/WebCoreSupport/WebValidationMessageClient.cpp

Lines 1-125 a/Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.cpp_sec1
- a/Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.cpp -125 lines
1	/*
2	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#include "config.h"
27	#include "WebCredentialsMessengerProxy.h"
28
29	#if ENABLE(WEB_AUTHN)
30
31	#include "WebCredentialsMessengerMessages.h"
32	#include "WebCredentialsMessengerProxyMessages.h"
33	#include "WebPageProxy.h"
34	#include "WebProcessProxy.h"
35	#include <WebCore/ExceptionData.h>
36	#include <WebCore/LocalAuthenticator.h>
37
38	namespace WebKit {
39
40	WebCredentialsMessengerProxy::WebCredentialsMessengerProxy(WebPageProxy& webPageProxy)
41	: m_webPageProxy(webPageProxy)
42	{
43	m_webPageProxy.process().addMessageReceiver(Messages::WebCredentialsMessengerProxy::messageReceiverName(), m_webPageProxy.pageID(), *this);
44	m_authenticator = std::make_unique<WebCore::LocalAuthenticator>();
45	}
46
47	WebCredentialsMessengerProxy::~WebCredentialsMessengerProxy()
48	{
49	m_webPageProxy.process().removeMessageReceiver(Messages::WebCredentialsMessengerProxy::messageReceiverName(), m_webPageProxy.pageID());
50	}
51
52	void WebCredentialsMessengerProxy::makeCredential(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options)
53	{
54	// FIXME(182767)
55	if (!m_authenticator) {
56	exceptionReply(messageId, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
57	return;
58	}
59	// FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
60	// FIXME(183534): Unify callbacks.
61	auto weakThis = makeWeakPtr(*this);
62	auto callback = [weakThis, messageId] (const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject) {
63	if (!weakThis)
64	return;
65	weakThis->makeCredentialReply(messageId, credentialId, attestationObject);
66	};
67	auto exceptionCallback = [weakThis, messageId] (const WebCore::ExceptionData& exception) {
68	if (!weakThis)
69	return;
70	weakThis->exceptionReply(messageId, exception);
71	};
72	m_authenticator->makeCredential(hash, options, WTFMove(callback), WTFMove(exceptionCallback));
73	}
74
75	void WebCredentialsMessengerProxy::getAssertion(uint64_t messageId, const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options)
76	{
77	// FIXME(182767)
78	if (!m_authenticator)
79	exceptionReply(messageId, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
80	// FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
81	// FIXME(183534): Unify callbacks.
82	auto weakThis = makeWeakPtr(*this);
83	auto callback = [weakThis, messageId] (const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle) {
84	if (weakThis)
85	weakThis->getAssertionReply(messageId, credentialId, authenticatorData, signature, userHandle);
86	};
87	auto exceptionCallback = [weakThis, messageId] (const WebCore::ExceptionData& exception) {
88	if (weakThis)
89	weakThis->exceptionReply(messageId, exception);
90	};
91	m_authenticator->getAssertion(hash, options, WTFMove(callback), WTFMove(exceptionCallback));
92	}
93
94	void WebCredentialsMessengerProxy::isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId)
95	{
96	if (!m_authenticator) {
97	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
98	return;
99	}
100	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, m_authenticator->isAvailable());
101	}
102
103	void WebCredentialsMessengerProxy::exceptionReply(uint64_t messageId, const WebCore::ExceptionData& exception)
104	{
105	m_webPageProxy.send(Messages::WebCredentialsMessenger::ExceptionReply(messageId, exception));
106	}
107
108	void WebCredentialsMessengerProxy::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
109	{
110	m_webPageProxy.send(Messages::WebCredentialsMessenger::MakeCredentialReply(messageId, credentialId, attestationObject));
111	}
112
113	void WebCredentialsMessengerProxy::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
114	{
115	m_webPageProxy.send(Messages::WebCredentialsMessenger::GetAssertionReply(messageId, credentialId, authenticatorData, signature, userHandle));
116	}
117
118	void WebCredentialsMessengerProxy::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
119	{
120	m_webPageProxy.send(Messages::WebCredentialsMessenger::IsUserVerifyingPlatformAuthenticatorAvailableReply(messageId, result));
121	}
122
123	} // namespace WebKit
124
125	#endif // ENABLE(WEB_AUTHN)

Lines 1-34 a/Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.messages.in_sec1
- a/Source/WebKit/UIProcess/CredentialManagement/WebCredentialsMessengerProxy.messages.in -34 lines
1	# Copyright (C) 2018 Apple Inc. All rights reserved.
2	#
3	# Redistribution and use in source and binary forms, with or without
4	# modification, are permitted provided that the following conditions
5	# are met:
6	# 1. Redistributions of source code must retain the above copyright
7	# notice, this list of conditions and the following disclaimer.
8	# 2. Redistributions in binary form must reproduce the above copyright
9	# notice, this list of conditions and the following disclaimer in the
10	# documentation and/or other materials provided with the distribution.
11	#
12	# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
13	# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
14	# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
15	# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
16	# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
17	# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
18	# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
19	# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
20	# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
21	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
22	# THE POSSIBILITY OF SUCH DAMAGE.
23	#/
24
25	#if ENABLE(WEB_AUTHN)
26
27	messages -> WebCredentialsMessengerProxy {
28
29	MakeCredential(uint64_t messageId, Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialCreationOptions options);
30	GetAssertion(uint64_t messageId, Vector<uint8_t> hash, struct WebCore::PublicKeyCredentialRequestOptions options);
31	IsUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId);
32	}
33
34	#endif

Line 0 a/Source/WebKit/UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp_sec1
- a/Source/WebKit/UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp +114 lines
		1	/*
		2	* Copyright (C) 2018 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "WebAuthenticatorCoordinatorProxy.h"
		28
		29	#if ENABLE(WEB_AUTHN)
		30
		31	#include "WebAuthenticatorCoordinatorMessages.h"
		32	#include "WebAuthenticatorCoordinatorProxyMessages.h"
		33	#include "WebPageProxy.h"
		34	#include "WebProcessProxy.h"
		35	#include <WebCore/ExceptionData.h>
		36	#include <WebCore/LocalAuthenticator.h>
		37	#include <WebCore/PublicKeyCredentialData.h>
		38
		39	namespace WebKit {
		40
		41	WebAuthenticatorCoordinatorProxy::WebAuthenticatorCoordinatorProxy(WebPageProxy& webPageProxy)
		42	: m_webPageProxy(webPageProxy)
		43	{
		44	m_webPageProxy.process().addMessageReceiver(Messages::WebAuthenticatorCoordinatorProxy::messageReceiverName(), m_webPageProxy.pageID(), *this);
		45	m_authenticator = std::make_unique<WebCore::LocalAuthenticator>();
		46	}
		47
		48	WebAuthenticatorCoordinatorProxy::~WebAuthenticatorCoordinatorProxy()
		49	{
		50	m_webPageProxy.process().removeMessageReceiver(Messages::WebAuthenticatorCoordinatorProxy::messageReceiverName(), m_webPageProxy.pageID());
		51	}
		52
		53	void WebAuthenticatorCoordinatorProxy::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options)
		54	{
		55	// FIXME(182767)
		56	if (!m_authenticator) {
		57	requestReply({ }, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
		58	return;
		59	}
		60	// FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
		61	auto callback = [weakThis = makeWeakPtr(*this)] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
		62	if (!weakThis)
		63	return;
		64
65	WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
66	weakThis->requestReply(data, { });
67	}, [&](const WebCore::ExceptionData& exception) {
68	weakThis->requestReply({ }, exception);
69	});
70	};
71	m_authenticator->makeCredential(hash, options, WTFMove(callback));
72	}
73
74	void WebAuthenticatorCoordinatorProxy::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options)
75	{
76	// FIXME(182767)
77	if (!m_authenticator)
78	requestReply({ }, { WebCore::NotAllowedError, "No avaliable authenticators."_s });
79	// FIXME(183534): Weak pointers doesn't work in another thread because of race condition.
80	auto callback = [weakThis = makeWeakPtr(*this)] (Variant<WebCore::PublicKeyCredentialData, WebCore::ExceptionData>&& result) {
81	if (!weakThis)
82	return;
83
84	WTF::switchOn(result, [&](const WebCore::PublicKeyCredentialData& data) {
85	weakThis->requestReply(data, { });
86	}, [&](const WebCore::ExceptionData& exception) {
87	weakThis->requestReply({ }, exception);
88	});
89	};
90	m_authenticator->getAssertion(hash, options, WTFMove(callback));
91	}
92
93	void WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailable(uint64_t messageId)
94	{
95	if (!m_authenticator) {
96	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, false);
97	return;
98	}
99	isUserVerifyingPlatformAuthenticatorAvailableReply(messageId, m_authenticator->isAvailable());
100	}
101
102	void WebAuthenticatorCoordinatorProxy::requestReply(const WebCore::PublicKeyCredentialData& data, const WebCore::ExceptionData& exception)
103	{
104	m_webPageProxy.send(Messages::WebAuthenticatorCoordinator::RequestReply(data, exception));
105	}
106
107	void WebAuthenticatorCoordinatorProxy::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
108	{
109	m_webPageProxy.send(Messages::WebAuthenticatorCoordinator::IsUserVerifyingPlatformAuthenticatorAvailableReply(messageId, result));
110	}
111
112	} // namespace WebKit
113
114	#endif // ENABLE(WEB_AUTHN)

Lines 1-90 a/Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.cpp_sec1
- a/Source/WebKit/WebProcess/CredentialManagement/WebCredentialsMessenger.cpp -90 lines
1	/*
2	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#include "config.h"
27	#include "WebCredentialsMessenger.h"
28
29	#if ENABLE(WEB_AUTHN)
30
31	#include "WebCredentialsMessengerMessages.h"
32	#include "WebCredentialsMessengerProxyMessages.h"
33	#include "WebPage.h"
34	#include "WebProcess.h"
35	#include <WebCore/PublicKeyCredentialCreationOptions.h>
36	#include <WebCore/PublicKeyCredentialRequestOptions.h>
37
38	namespace WebKit {
39
40	WebCredentialsMessenger::WebCredentialsMessenger(WebPage& webPage)
41	: m_webPage(webPage)
42	{
43	WebProcess::singleton().addMessageReceiver(Messages::WebCredentialsMessenger::messageReceiverName(), m_webPage.pageID(), *this);
44	}
45
46	WebCredentialsMessenger::~WebCredentialsMessenger()
47	{
48	WebProcess::singleton().removeMessageReceiver(*this);
49	}
50
51	void WebCredentialsMessenger::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options, WebCore::CreationCompletionHandler&& handler)
52	{
53	auto messageId = addCreationCompletionHandler(WTFMove(handler));
54	m_webPage.send(Messages::WebCredentialsMessengerProxy::MakeCredential(messageId, hash, options));
55	}
56
57	void WebCredentialsMessenger::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options, WebCore::RequestCompletionHandler&& handler)
58	{
59	auto messageId = addRequestCompletionHandler(WTFMove(handler));
60	m_webPage.send(Messages::WebCredentialsMessengerProxy::GetAssertion(messageId, hash, options));
61	}
62
63	void WebCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&& handler)
64	{
65	auto messageId = addQueryCompletionHandler(WTFMove(handler));
66	m_webPage.send(Messages::WebCredentialsMessengerProxy::IsUserVerifyingPlatformAuthenticatorAvailable(messageId));
67	}
68
69	void WebCredentialsMessenger::makeCredentialReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& attestationObject)
70	{
71	auto handler = takeCreationCompletionHandler(messageId);
72	handler(WebCore::CreationReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(attestationObject.data(), attestationObject.size())));
73	}
74
75	void WebCredentialsMessenger::getAssertionReply(uint64_t messageId, const Vector<uint8_t>& credentialId, const Vector<uint8_t>& authenticatorData, const Vector<uint8_t>& signature, const Vector<uint8_t>& userHandle)
76	{
77	auto handler = takeRequestCompletionHandler(messageId);
78	handler(WebCore::AssertionReturnBundle(ArrayBuffer::create(credentialId.data(), credentialId.size()), ArrayBuffer::create(authenticatorData.data(), authenticatorData.size()), ArrayBuffer::create(signature.data(), signature.size()), ArrayBuffer::create(userHandle.data(), userHandle.size())));
79	}
80
81	void WebCredentialsMessenger::isUserVerifyingPlatformAuthenticatorAvailableReply(uint64_t messageId, bool result)
82	{
83	auto handler = takeQueryCompletionHandler(messageId);
84	handler(result);
85	}
86
87
88	} // namespace WebKit
89
90	#endif // ENABLE(WEB_AUTHN)

Line 0 a/Source/WebKit/WebProcess/WebAuthentication/WebAuthenticatorCoordinator.cpp_sec1
- a/Source/WebKit/WebProcess/WebAuthentication/WebAuthenticatorCoordinator.cpp +75 lines
		1	/*
		2	* Copyright (C) 2018 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "WebAuthenticatorCoordinator.h"
		28
		29	#if ENABLE(WEB_AUTHN)
		30
		31	#include "WebAuthenticatorCoordinatorMessages.h"
		32	#include "WebAuthenticatorCoordinatorProxyMessages.h"
		33	#include "WebPage.h"
		34	#include "WebProcess.h"
		35	#include <WebCore/PublicKeyCredentialCreationOptions.h>
		36	#include <WebCore/PublicKeyCredentialRequestOptions.h>
		37
		38	namespace WebKit {
		39
		40	WebAuthenticatorCoordinator::WebAuthenticatorCoordinator(WebPage& webPage)
		41	: m_webPage(webPage)
		42	{
		43	WebProcess::singleton().addMessageReceiver(Messages::WebAuthenticatorCoordinator::messageReceiverName(), m_webPage.pageID(), *this);
		44	}
		45
		46	WebAuthenticatorCoordinator::~WebAuthenticatorCoordinator()
		47	{
		48	WebProcess::singleton().removeMessageReceiver(*this);
		49	}
		50
		51	void WebAuthenticatorCoordinator::makeCredential(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialCreationOptions& options, WebCore::RequestCompletionHandler&& handler)
		52	{
		53	if (!setRequestCompletionHandler(WTFMove(handler)))
		54	return;
		55
		56	m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::MakeCredential(hash, options));
		57	}
		58
		59	void WebAuthenticatorCoordinator::getAssertion(const Vector<uint8_t>& hash, const WebCore::PublicKeyCredentialRequestOptions& options, WebCore::RequestCompletionHandler&& handler)
		60	{
		61	if (!setRequestCompletionHandler(WTFMove(handler)))
		62	return;
		63
		64	m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::GetAssertion(hash, options));
65	}
66
67	void WebAuthenticatorCoordinator::isUserVerifyingPlatformAuthenticatorAvailable(WebCore::QueryCompletionHandler&& handler)
68	{
69	auto messageId = addQueryCompletionHandler(WTFMove(handler));
70	m_webPage.send(Messages::WebAuthenticatorCoordinatorProxy::IsUserVerifyingPlatformAuthenticatorAvailable(messageId));
71	}
72
73	} // namespace WebKit
74
75	#endif // ENABLE(WEB_AUTHN)

Lines 278-285 a/Source/WebKit/WebProcess/WebPage/WebPage.cpp_sec1
- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp -9 / +6 lines
278	#endif	278	#endif
279		279
280	#if ENABLE(WEB_AUTHN)	280	#if ENABLE(WEB_AUTHN)
281	#include "WebCredentialsMessenger.h"	281	#include "WebAuthenticatorCoordinator.h"
282	#include <WebCore/AuthenticatorManager.h>	282	#include <WebCore/AuthenticatorCoordinator.h>
283	#endif	283	#endif
284		284
285	namespace WebKit {	285	namespace WebKit {
Lines 392-400 WebPage::WebPage(uint64_t pageID, WebPageCreationParameters&& parameters) a/Source/WebKit/WebProcess/WebPage/WebPage.cpp_sec2
392	, m_userInterfaceLayoutDirection(parameters.userInterfaceLayoutDirection)	392	, m_userInterfaceLayoutDirection(parameters.userInterfaceLayoutDirection)
393	, m_overrideContentSecurityPolicy { parameters.overrideContentSecurityPolicy }	393	, m_overrideContentSecurityPolicy { parameters.overrideContentSecurityPolicy }
394	, m_cpuLimit(parameters.cpuLimit)	394	, m_cpuLimit(parameters.cpuLimit)
395	#if ENABLE(WEB_AUTHN)
396	, m_credentialsMessenger(std::make_unique<WebCredentialsMessenger>(*this))
397	#endif
398	{	395	{
399	ASSERT(m_pageID);	396	ASSERT(m_pageID);
400		397
Lines 448-453 WebPage::WebPage(uint64_t pageID, WebPageCreationParameters&& parameters) a/Source/WebKit/WebProcess/WebPage/WebPage.cpp_sec3
448	pageConfiguration.paymentCoordinatorClient = new WebPaymentCoordinator(*this);	445	pageConfiguration.paymentCoordinatorClient = new WebPaymentCoordinator(*this);
449	#endif	446	#endif
450		447
		448	#if ENABLE(WEB_AUTHN)
		449	pageConfiguration.authenticatorCoordinatorClient = std::make_unique<WebAuthenticatorCoordinator>(*this);
		450	#endif
		451
451	#if ENABLE(APPLICATION_MANIFEST)	452	#if ENABLE(APPLICATION_MANIFEST)
452	pageConfiguration.applicationManifest = parameters.applicationManifest;	453	pageConfiguration.applicationManifest = parameters.applicationManifest;
453	#endif	454	#endif
Lines 605-614 WebPage::WebPage(uint64_t pageID, WebPageCreationParameters&& parameters) a/Source/WebKit/WebProcess/WebPage/WebPage.cpp_sec4
605	#endif	606	#endif
606	#endif	607	#endif
607		608
608	#if ENABLE(WEB_AUTHN)
609	WebCore::AuthenticatorManager::singleton().setMessenger(*m_credentialsMessenger);
610	#endif
611
612	for (auto iterator : parameters.urlSchemeHandlers)	609	for (auto iterator : parameters.urlSchemeHandlers)
613	registerURLSchemeHandler(iterator.value, iterator.key);	610	registerURLSchemeHandler(iterator.value, iterator.key);
614		611

Lines 226-232 class WebUserContentController; a/Source/WebKit/WebProcess/WebPage/WebPage.h_sec1
- a/Source/WebKit/WebProcess/WebPage/WebPage.h -5 lines
226	class VideoFullscreenManager;	226	class VideoFullscreenManager;
227	class WebWheelEvent;	227	class WebWheelEvent;
228	class WebTouchEvent;	228	class WebTouchEvent;
229	class WebCredentialsMessenger;
230	class RemoteLayerTreeTransaction;	229	class RemoteLayerTreeTransaction;
231		230
232	enum class DeviceAccessState;	231	enum class DeviceAccessState;
Lines 1735-1744 private: a/Source/WebKit/WebProcess/WebPage/WebPage.h_sec2
1735	HashMap<uint64_t, uint64_t> m_applicationManifestFetchCallbackMap;	1734	HashMap<uint64_t, uint64_t> m_applicationManifestFetchCallbackMap;
1736	#endif	1735	#endif
1737		1736
1738	#if ENABLE(WEB_AUTHN)
1739	std::unique_ptr<WebCredentialsMessenger> m_credentialsMessenger;
1740	#endif
1741
1742	bool m_isSuspended { false };	1737	bool m_isSuspended { false };
1743	};	1738	};
1744		1739

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +11 lines
		1	2018-09-08 Jiewen Tan <jiewen_tan@apple.com>
		2
		3	[WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=189277
		5	<rdar://problem/44115936>
		6
		7	Reviewed by Chris Dumez.
		8
		9	* TestWebKitAPI/Tests/ios/LocalAuthenticator.mm:
		10	(TestWebKitAPI::TEST):
		11
1	2018-09-02 Darin Adler <darin@apple.com>	12	2018-09-02 Darin Adler <darin@apple.com>
2		13
3	[Cocoa] Turn on ARC for WebKitTestRunner	14	[Cocoa] Turn on ARC for WebKitTestRunner

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +16 lines
		1	2018-09-08 Jiewen Tan <jiewen_tan@apple.com>
		2
		3	[WebAuthN] Polish AuthenticatorManager and rename it to AuthenticatorCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=189277
		5	<rdar://problem/44115936>
		6
		7	Reviewed by Chris Dumez.
		8
		9	* http/wpt/credential-management/credentialscontainer-store-basics.https.html:
		10	* http/wpt/webauthn/idl.https.html:
		11	* http/wpt/webauthn/public-key-credential-create-failure.https.html:
		12	* http/wpt/webauthn/public-key-credential-create-success.https.html:
		13	* http/wpt/webauthn/public-key-credential-get-failure.https.html:
		14	* http/wpt/webauthn/public-key-credential-get-success.https.html:
		15	* http/wpt/webauthn/public-key-is-user-verifying-platform-authenticator-available.html:
		16
1	2018-09-08 Andy Estes <aestes@apple.com>	17	2018-09-08 Andy Estes <aestes@apple.com>
2		18
3	[Apple Pay] Dispatch a paymentmethodchange event when the payment method changes	19	[Apple Pay] Dispatch a paymentmethodchange event when the payment method changes

Lines 52-58 promise_test(async () => { a/LayoutTests/http/wpt/webauthn/idl.https.html_sec1
- a/LayoutTests/http/wpt/webauthn/idl.https.html -2 / +2 lines
52	}	52	}
53	};	53	};
54	// A mock attestation object	54	// A mock attestation object
55	internals.mockCredentialsMessenger.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));	55	internals.mockAuthenticatorCoordinator.setCreationReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'));
56	createdCredential = await navigator.credentials.create(creationOptions);	56	createdCredential = await navigator.credentials.create(creationOptions);
57		57
58		58
Lines 62-68 promise_test(async () => { a/LayoutTests/http/wpt/webauthn/idl.https.html_sec2
62	}	62	}
63	};	63	};
64	// A mock assertion return bundle.	64	// A mock assertion return bundle.
65	internals.mockCredentialsMessenger.setAssertionReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'), hexStringToUint8Array('02'), hexStringToUint8Array('03'));	65	internals.mockAuthenticatorCoordinator.setAssertionReturnBundle(hexStringToUint8Array('00'), hexStringToUint8Array('01'), hexStringToUint8Array('02'), hexStringToUint8Array('03'));
66	requestedCredential = await navigator.credentials.get(requestOptions);	66	requestedCredential = await navigator.credentials.get(requestOptions);
67		67
68	idlArray.add_objects({"PublicKeyCredential": ["createdCredential"], "AuthenticatorAttestationResponse": ["createdCredential.response"], "AuthenticatorAssertionResponse": ["requestedCredential.response"]});	68	idlArray.add_objects({"PublicKeyCredential": ["createdCredential"], "AuthenticatorAttestationResponse": ["createdCredential.response"], "AuthenticatorAssertionResponse": ["requestedCredential.response"]});

Lines 20-26 a/LayoutTests/http/wpt/webauthn/public-key-credential-create-failure.https.html_sec1
- a/LayoutTests/http/wpt/webauthn/public-key-credential-create-failure.https.html -2 / +2 lines
20	timeout: 0,	20	timeout: 0,
21	}	21	}
22	};	22	};
23	internals.mockCredentialsMessenger.setDidTimeOut();	23	internals.mockAuthenticatorCoordinator.setDidTimeOut();
24		24
25	return promise_rejects(t, "NotAllowedError",	25	return promise_rejects(t, "NotAllowedError",
26	navigator.credentials.create(options));	26	navigator.credentials.create(options));
Lines 82-88 a/LayoutTests/http/wpt/webauthn/public-key-credential-create-failure.https.html_sec2
82	pubKeyCredParams: [{ type: "public-key", alg: -7 }],	82	pubKeyCredParams: [{ type: "public-key", alg: -7 }],
83	}	83	}
84	};	84	};
85	internals.mockCredentialsMessenger.setDidUserCancel();	85	internals.mockAuthenticatorCoordinator.setDidUserCancel();
86		86
87	return promise_rejects(t, "NotAllowedError",	87	return promise_rejects(t, "NotAllowedError",
88	navigator.credentials.create(options));	88	navigator.credentials.create(options));

Lines 4-10 a/LayoutTests/http/wpt/webauthn/public-key-is-user-verifying-platform-authenticator-available.html_sec1
- a/LayoutTests/http/wpt/webauthn/public-key-is-user-verifying-platform-authenticator-available.html -2 / +2 lines
4	<script src="/resources/testharnessreport.js"></script>	4	<script src="/resources/testharnessreport.js"></script>
5	<script>	5	<script>
6	promise_test(function(t) {	6	promise_test(function(t) {
7	internals.mockCredentialsMessenger;	7	internals.mockAuthenticatorCoordinator;
8		8
9	return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {	9	return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {
10	assert_equals(result, false);	10	assert_equals(result, false);
Lines 12-18 a/LayoutTests/http/wpt/webauthn/public-key-is-user-verifying-platform-authenticator-available.html_sec2
12	}, "PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() without any available authenticators.");	12	}, "PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() without any available authenticators.");
13		13
14	promise_test(function(t) {	14	promise_test(function(t) {
15	internals.mockCredentialsMessenger.setDidUserVerifyingPlatformAuthenticatorPresent();	15	internals.mockAuthenticatorCoordinator.setDidUserVerifyingPlatformAuthenticatorPresent();
16		16
17	return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {	17	return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable().then(function(result) {
18	assert_equals(result, true);	18	assert_equals(result, true);