Remove PassRefPtr use from "inspector", "platform/sql", and "platform/text"
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 7 Jan 2017 22:08:28 +0000 (22:08 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 7 Jan 2017 22:08:28 +0000 (22:08 +0000)
https://bugs.webkit.org/show_bug.cgi?id=166797

Reviewed by Alex Christensen.

Source/WebCore:

* Modules/webdatabase/Database.cpp:
(WebCore::Database::performOpenAndVerify): Pass a reference instead of a pointer.

* dom/Document.cpp:
(WebCore::canonicalizedTitle): Map backslashes to currency symbols inside the
existing loop through the characters instead of calling a function confusingly
named "displayBuffer" to do it. More straightforward, possibly more efficient,
one less function.
(WebCore::Document::displayStringModifiedByEncoding): Call replace to map
backslashes to currency symbols instead of calling a special displayString
function. There was no real benefit to using that function; the String::replace
function has all the same optimizations, and this was also the only call site.

* editing/SpellChecker.cpp:
(WebCore::SpellChecker::invokeRequest): Pass a reference instead of a pointer.

* inspector/InspectorOverlay.cpp:
(WebCore::InspectorOverlay::overlayPage): Call createEmptyEditorClient instead
of using the class EmptyEditorClient directly.

* loader/EmptyClients.cpp: Moved most of the empty clients here from the header.
Also made lots more things private.
(WebCore::createEmptyEditorClient): Added.
(WebCore::emptyDiagnosticLoggingClient): Added.
* loader/EmptyClients.h: Updated for above changes. Made more things private.

* page/DatabaseProvider.h: Removed unneeded include.
* page/MainFrame.cpp: Ditto.

* page/Page.cpp:
(WebCore::Page::diagnosticLoggingClient): Call emptyDiagnosticLoggingClient
instead of using the class EmptyDiagnosticLoggingClient directly.

* platform/sql/SQLiteDatabase.cpp:
(WebCore::SQLiteDatabase::setAuthorizer): Take a reference instead of a
PassRefPtr.
* platform/sql/SQLiteDatabase.h: Updated for above.

* platform/text/BidiContext.cpp:
(WebCore::BidiContext::BidiContext): Moved this function here from the header.
(WebCore::copyContextAndRebaselineLevel): Return a Ref instead of a PassRefPtr,
and take a reference rather than a raw pointer.
(WebCore::BidiContext::copyStackRemovingUnicodeEmbeddingContexts): Return a
Ref instead of a PassRefPtr.
* platform/text/BidiContext.h: Updated for the above changes.

* platform/text/BidiResolver.h: Simplify initialization, use more references,
auto, modern for loops, refer to derived class as that rather than the non-C++
term subclass.

* platform/text/TextCheckerClient.h: Changd argument from PassRefPtr to a
reference.

* platform/text/TextEncoding.h:
(WebCore::TextEncoding::displayString): Deleted.
(WebCore::TextEncoding::displayBuffer): Deleted.

* rendering/RootInlineBox.cpp: Style tweaks and use a modern for loop.

* svg/graphics/SVGImage.cpp:
(WebCore::SVGImage::dataChanged): Call createEmptyEditorClient instead
of using the class EmptyEditorClient directly.

Source/WebKit/mac:

* WebCoreSupport/WebEditorClient.h: Updated to take a reference.
* WebCoreSupport/WebEditorClient.mm:
(WebEditorClient::requestCheckingOfString): Take a reference
instead of a PassRefPtr.

Source/WebKit/win:

* WebCoreSupport/WebEditorClient.h: Update argument to take a reference
instead of a PassRefPtr.

Source/WebKit2:

* WebProcess/WebCoreSupport/WebEditorClient.cpp:
(WebKit::WebEditorClient::requestCheckingOfString): Take a reference
instead of a PassRefPtr.
* WebProcess/WebCoreSupport/WebEditorClient.h: Updated for above change.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@210492 268f45cc-cd09-0410-ab3c-d52691b4dbfc

27 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Modules/webdatabase/Database.cpp
Source/WebCore/dom/Document.cpp
Source/WebCore/editing/SpellChecker.cpp
Source/WebCore/inspector/InspectorOverlay.cpp
Source/WebCore/loader/EmptyClients.cpp
Source/WebCore/loader/EmptyClients.h
Source/WebCore/page/DatabaseProvider.h
Source/WebCore/page/MainFrame.cpp
Source/WebCore/page/Page.cpp
Source/WebCore/platform/sql/SQLiteDatabase.cpp
Source/WebCore/platform/sql/SQLiteDatabase.h
Source/WebCore/platform/text/BidiContext.cpp
Source/WebCore/platform/text/BidiContext.h
Source/WebCore/platform/text/BidiResolver.h
Source/WebCore/platform/text/TextCheckerClient.h
Source/WebCore/platform/text/TextEncoding.h
Source/WebCore/rendering/RootInlineBox.cpp
Source/WebCore/svg/graphics/SVGImage.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/WebCoreSupport/WebEditorClient.h
Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm
Source/WebKit/win/ChangeLog
Source/WebKit/win/WebCoreSupport/WebEditorClient.h
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/WebCoreSupport/WebEditorClient.cpp
Source/WebKit2/WebProcess/WebCoreSupport/WebEditorClient.h

index 383f55d..7ebca33 100644 (file)
@@ -1,3 +1,73 @@
+2017-01-06  Darin Adler  <darin@apple.com>
+
+        Remove PassRefPtr use from "inspector", "platform/sql", and "platform/text"
+        https://bugs.webkit.org/show_bug.cgi?id=166797
+
+        Reviewed by Alex Christensen.
+
+        * Modules/webdatabase/Database.cpp:
+        (WebCore::Database::performOpenAndVerify): Pass a reference instead of a pointer.
+
+        * dom/Document.cpp:
+        (WebCore::canonicalizedTitle): Map backslashes to currency symbols inside the
+        existing loop through the characters instead of calling a function confusingly
+        named "displayBuffer" to do it. More straightforward, possibly more efficient,
+        one less function.
+        (WebCore::Document::displayStringModifiedByEncoding): Call replace to map
+        backslashes to currency symbols instead of calling a special displayString
+        function. There was no real benefit to using that function; the String::replace
+        function has all the same optimizations, and this was also the only call site.
+
+        * editing/SpellChecker.cpp:
+        (WebCore::SpellChecker::invokeRequest): Pass a reference instead of a pointer.
+
+        * inspector/InspectorOverlay.cpp:
+        (WebCore::InspectorOverlay::overlayPage): Call createEmptyEditorClient instead
+        of using the class EmptyEditorClient directly.
+
+        * loader/EmptyClients.cpp: Moved most of the empty clients here from the header.
+        Also made lots more things private.
+        (WebCore::createEmptyEditorClient): Added.
+        (WebCore::emptyDiagnosticLoggingClient): Added.
+        * loader/EmptyClients.h: Updated for above changes. Made more things private.
+
+        * page/DatabaseProvider.h: Removed unneeded include.
+        * page/MainFrame.cpp: Ditto.
+
+        * page/Page.cpp:
+        (WebCore::Page::diagnosticLoggingClient): Call emptyDiagnosticLoggingClient
+        instead of using the class EmptyDiagnosticLoggingClient directly.
+
+        * platform/sql/SQLiteDatabase.cpp:
+        (WebCore::SQLiteDatabase::setAuthorizer): Take a reference instead of a
+        PassRefPtr.
+        * platform/sql/SQLiteDatabase.h: Updated for above.
+
+        * platform/text/BidiContext.cpp:
+        (WebCore::BidiContext::BidiContext): Moved this function here from the header.
+        (WebCore::copyContextAndRebaselineLevel): Return a Ref instead of a PassRefPtr,
+        and take a reference rather than a raw pointer.
+        (WebCore::BidiContext::copyStackRemovingUnicodeEmbeddingContexts): Return a
+        Ref instead of a PassRefPtr.
+        * platform/text/BidiContext.h: Updated for the above changes.
+
+        * platform/text/BidiResolver.h: Simplify initialization, use more references,
+        auto, modern for loops, refer to derived class as that rather than the non-C++
+        term subclass.
+
+        * platform/text/TextCheckerClient.h: Changd argument from PassRefPtr to a
+        reference.
+
+        * platform/text/TextEncoding.h:
+        (WebCore::TextEncoding::displayString): Deleted.
+        (WebCore::TextEncoding::displayBuffer): Deleted.
+
+        * rendering/RootInlineBox.cpp: Style tweaks and use a modern for loop.
+
+        * svg/graphics/SVGImage.cpp:
+        (WebCore::SVGImage::dataChanged): Call createEmptyEditorClient instead
+        of using the class EmptyEditorClient directly.
+
 2017-01-07  Andy Estes  <aestes@apple.com>
 
         [QuickLook] Update quicklook test expectations
index f0162b5..51a337f 100644 (file)
@@ -422,7 +422,7 @@ ExceptionOr<void> Database::performOpenAndVerify(bool shouldSetVersionInNewDatab
         return Exception { INVALID_STATE_ERR, "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'" };
     }
 
-    m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer.ptr());
+    m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer.get());
 
     DatabaseTracker::singleton().addOpenDatabase(*this);
     m_opened = true;
index a006c87..e412eb5 100644 (file)
@@ -3,7 +3,7 @@
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
- * Copyright (C) 2004-2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
@@ -1452,7 +1452,7 @@ Element* Document::scrollingElement()
 
 template<typename CharacterType> static inline String canonicalizedTitle(Document& document, const String& title)
 {
-    // FIXME: Compiling a separate copy of this for each character type is likely unnecessary.
+    // FIXME: Compiling a separate copy of this for LChar and UChar is likely unnecessary.
     // FIXME: Missing an optimized case for when title is fine as-is. This unnecessarily allocates
     // and keeps around a new copy, and it's even the less optimal type of StringImpl with a separate buffer.
     // Could probably just use StringBuilder instead.
@@ -1463,13 +1463,20 @@ template<typename CharacterType> static inline String canonicalizedTitle(Documen
     StringBuffer<CharacterType> buffer { length };
     unsigned bufferLength = 0;
 
-    // Collapse runs of HTML spaces into single space characters; strip leading and trailing spaces.
+    auto* decoder = document.decoder();
+    auto backslashAsCurrencySymbol = decoder ? decoder->encoding().backslashAsCurrencySymbol() : '\\';
+
+    // Collapse runs of HTML spaces into single space characters.
+    // Strip leading and trailing spaces.
+    // Replace backslashes with currency symbols.
     bool previousCharacterWasHTMLSpace = false;
     for (unsigned i = 0; i < length; ++i) {
         auto character = characters[i];
         if (isHTMLSpace(character))
             previousCharacterWasHTMLSpace = true;
         else {
+            if (character == '\\')
+                character = backslashAsCurrencySymbol;
             if (previousCharacterWasHTMLSpace && bufferLength)
                 buffer[bufferLength++] = ' ';
             buffer[bufferLength++] = character;
@@ -1478,12 +1485,8 @@ template<typename CharacterType> static inline String canonicalizedTitle(Documen
     }
     if (!bufferLength)
         return { };
-    buffer.shrink(bufferLength);
-
-    // Replace backslashes with currency symbols if the encoding requires it.
-    if (auto* decoder = document.decoder())
-        decoder->encoding().displayBuffer(buffer.characters(), bufferLength);
 
+    buffer.shrink(bufferLength);
     return String::adopt(WTFMove(buffer));
 }
 
@@ -5460,8 +5463,6 @@ void Document::scriptedAnimationControllerSetThrottled(bool isThrottled)
 
 void Document::windowScreenDidChange(PlatformDisplayID displayID)
 {
-    UNUSED_PARAM(displayID);
-
 #if ENABLE(REQUEST_ANIMATION_FRAME)
     if (m_scriptedAnimationController)
         m_scriptedAnimationController->windowScreenDidChange(displayID);
@@ -5473,11 +5474,11 @@ void Document::windowScreenDidChange(PlatformDisplayID displayID)
     }
 }
 
-String Document::displayStringModifiedByEncoding(const String& str) const
+String Document::displayStringModifiedByEncoding(const String& string) const
 {
-    if (m_decoder)
-        return m_decoder->encoding().displayString(str.impl()).get();
-    return str;
+    if (!m_decoder)
+        return string;
+    return String { string }.replace('\\', m_decoder->encoding().backslashAsCurrencySymbol());
 }
 
 void Document::enqueuePageshowEvent(PageshowEventPersistence persisted)
index 9d0f873..7cb6237 100644 (file)
@@ -182,7 +182,7 @@ void SpellChecker::invokeRequest(PassRefPtr<SpellCheckRequest> request)
     if (!client())
         return;
     m_processingRequest = request;
-    client()->requestCheckingOfString(m_processingRequest, m_frame.selection().selection());
+    client()->requestCheckingOfString(*m_processingRequest, m_frame.selection().selection());
 }
 
 void SpellChecker::enqueueRequest(PassRefPtr<SpellCheckRequest> request)
index 5fca310..65af072 100644 (file)
@@ -30,6 +30,7 @@
 #include "InspectorOverlay.h"
 
 #include "DocumentLoader.h"
+#include "EditorClient.h"
 #include "Element.h"
 #include "EmptyClients.h"
 #include "FrameView.h"
@@ -54,6 +55,7 @@
 #include "ScriptController.h"
 #include "ScriptSourceCode.h"
 #include "Settings.h"
+#include "SocketProvider.h"
 #include "StyledElement.h"
 #include <inspector/InspectorProtocolObjects.h>
 #include <inspector/InspectorValues.h>
@@ -857,7 +859,7 @@ Page* InspectorOverlay::overlayPage()
     if (m_overlayPage)
         return m_overlayPage.get();
 
-    PageConfiguration pageConfiguration(makeUniqueRef<EmptyEditorClient>(), SocketProvider::create());
+    PageConfiguration pageConfiguration(createEmptyEditorClient(), SocketProvider::create());
     fillWithEmptyClients(pageConfiguration);
     m_overlayPage = std::make_unique<Page>(WTFMove(pageConfiguration));
     m_overlayPage->setDeviceScaleFactor(m_page.deviceScaleFactor());
index 5787c84..e0f6e5b 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
- * Copyright (C) 2008, 2009, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "ApplicationCacheStorage.h"
 #include "BackForwardClient.h"
 #include "ColorChooser.h"
-#include "DOMWrapperWorld.h"
+#include "ContextMenuClient.h"
 #include "DatabaseProvider.h"
+#include "DiagnosticLoggingClient.h"
+#include "DocumentFragment.h"
 #include "DocumentLoader.h"
+#include "DragClient.h"
+#include "EditorClient.h"
 #include "FileChooser.h"
 #include "FormState.h"
 #include "Frame.h"
+#include "FrameLoaderClient.h"
 #include "FrameNetworkingContext.h"
 #include "HTMLFormElement.h"
 #include "InProcessIDBServer.h"
+#include "InspectorClient.h"
 #include "Page.h"
 #include "PageConfiguration.h"
 #include "PaymentCoordinatorClient.h"
 #include "PluginInfoProvider.h"
+#include "ProgressTrackerClient.h"
 #include "SecurityOriginData.h"
 #include "StorageArea.h"
 #include "StorageNamespace.h"
 #include "StorageNamespaceProvider.h"
+#include "TextCheckerClient.h"
 #include "ThreadableWebSocketChannel.h"
 #include "UserContentProvider.h"
+#include "VisitedLinkStore.h"
 #include <heap/HeapInlines.h>
 #include <wtf/NeverDestroyed.h>
 
+#if ENABLE(CONTENT_EXTENSIONS)
+#include "CompiledContentExtension.h"
+#endif
+
 namespace WebCore {
 
-#if ENABLE(APPLE_PAY)
-class EmptyPaymentCoordinatorClient final : public PaymentCoordinatorClient {
-    bool supportsVersion(unsigned) override { return false; }
-    bool canMakePayments() override { return false; }
-    void canMakePaymentsWithActiveCard(const String&, const String&, std::function<void (bool)> completionHandler) override { callOnMainThread([completionHandler] { completionHandler(false); }); }
-    void openPaymentSetup(const String&, const String&, std::function<void (bool)> completionHandler) override { callOnMainThread([completionHandler] { completionHandler(false); }); }
-
-    bool showPaymentUI(const URL&, const Vector<URL>&, const PaymentRequest&) override { return false; }
-    void completeMerchantValidation(const PaymentMerchantSession&) override { }
-
-    void completeShippingMethodSelection(PaymentAuthorizationStatus, std::optional<PaymentRequest::TotalAndLineItems>) override { }
-    void completeShippingContactSelection(PaymentAuthorizationStatus, const Vector<PaymentRequest::ShippingMethod>&, std::optional<PaymentRequest::TotalAndLineItems>) override { }
-    void completePaymentMethodSelection(std::optional<WebCore::PaymentRequest::TotalAndLineItems>) override { }
-    void completePaymentSession(PaymentAuthorizationStatus) override { }
-    void abortPaymentSession() override { }
-    void paymentCoordinatorDestroyed() override { }
+class UserMessageHandlerDescriptor;
+
+class EmptyBackForwardClient final : public BackForwardClient {
+    void addItem(Ref<HistoryItem>&&) final { }
+    void goToItem(HistoryItem*) final { }
+    HistoryItem* itemAtIndex(int) final { return nullptr; }
+    int backListCount() final { return 0; }
+    int forwardListCount() final { return 0; }
+    void close() final { }
 };
+
+#if ENABLE(CONTEXT_MENUS)
+
+class EmptyContextMenuClient final : public ContextMenuClient {
+    void contextMenuDestroyed() final { }
+
+    void downloadURL(const URL&) final { }
+    void searchWithGoogle(const Frame*) final { }
+    void lookUpInDictionary(Frame*) final { }
+    bool isSpeaking() final { return false; }
+    void speak(const String&) final { }
+    void stopSpeaking() final { }
+
+#if PLATFORM(COCOA)
+    void searchWithSpotlight() final { }
 #endif
 
+#if USE(ACCESSIBILITY_CONTEXT_MENUS)
+    void showContextMenu() final { }
+#endif
+};
+
+#endif // ENABLE(CONTEXT_MENUS)
+
 class EmptyDatabaseProvider final : public DatabaseProvider {
 #if ENABLE(INDEXED_DATABASE)
-    virtual IDBClient::IDBConnectionToServer& idbConnectionToServerForSession(const SessionID&)
+    IDBClient::IDBConnectionToServer& idbConnectionToServerForSession(const SessionID&) final
     {
         static NeverDestroyed<Ref<InProcessIDBServer>> sharedConnection(InProcessIDBServer::create());
         return sharedConnection.get()->connectionToServer();
@@ -84,147 +112,461 @@ class EmptyDatabaseProvider final : public DatabaseProvider {
 #endif
 };
 
-class EmptyPluginInfoProvider final : public PluginInfoProvider {
-    void refreshPlugins() override { };
-    void getPluginInfo(Page&, Vector<PluginInfo>&) override { }
-    void getWebVisiblePluginInfo(Page&, Vector<PluginInfo>&) override { }
+class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
+    void logDiagnosticMessage(const String&, const String&, ShouldSample) final { }
+    void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) final { }
+    void logDiagnosticMessageWithValue(const String&, const String&, const String&, ShouldSample) final { }
 };
 
-class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {
-    struct EmptyStorageArea : public StorageArea {
-        unsigned length() override { return 0; }
-        String key(unsigned) override { return String(); }
-        String item(const String&) override { return String(); }
-        void setItem(Frame*, const String&, const String&, bool&) override { }
-        void removeItem(Frame*, const String&) override { }
-        void clear(Frame*) override { }
-        bool contains(const String&) override { return false; }
-        bool canAccessStorage(Frame*) override { return false; }
-        StorageType storageType() const override { return LocalStorage; }
-        size_t memoryBytesUsedByCache() override { return 0; }
-        SecurityOriginData securityOrigin() const override { return { }; }
-    };
+#if ENABLE(DRAG_SUPPORT)
 
-    struct EmptyStorageNamespace final : public StorageNamespace {
-        RefPtr<StorageArea> storageArea(const SecurityOriginData&) override { return adoptRef(new EmptyStorageArea); }
-        RefPtr<StorageNamespace> copy(Page*) override { return adoptRef(new EmptyStorageNamespace); }
-    };
+class EmptyDragClient final : public DragClient {
+    void willPerformDragDestinationAction(DragDestinationAction, const DragData&) final { }
+    void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) final { }
+    DragDestinationAction actionMaskForDrag(const DragData&) final { return DragDestinationActionNone; }
+    DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) final { return DragSourceActionNone; }
+    void startDrag(DragImageRef, const IntPoint&, const IntPoint&, DataTransfer&, Frame&, bool) final { }
+    void dragControllerDestroyed() final { }
+};
 
-    RefPtr<StorageNamespace> createSessionStorageNamespace(Page&, unsigned) override
-    {
-        return adoptRef(new EmptyStorageNamespace);
-    }
+#endif // ENABLE(DRAG_SUPPORT)
 
-    RefPtr<StorageNamespace> createLocalStorageNamespace(unsigned) override
-    {
-        return adoptRef(new EmptyStorageNamespace);
-    }
+class EmptyEditorClient final : public EditorClient {
+    WTF_MAKE_FAST_ALLOCATED;
 
-    RefPtr<StorageNamespace> createTransientLocalStorageNamespace(SecurityOrigin&, unsigned) override
-    {
-        return adoptRef(new EmptyStorageNamespace);
-    }
-};
+public:
+    EmptyEditorClient() = default;
 
-class EmptyUserContentProvider final : public UserContentProvider {
-    void forEachUserScript(const std::function<void(DOMWrapperWorld&, const UserScript&)>&) const override { }
-    void forEachUserStyleSheet(const std::function<void(const UserStyleSheet&)>&) const override { }
-#if ENABLE(USER_MESSAGE_HANDLERS)
-    void forEachUserMessageHandler(const std::function<void(const UserMessageHandlerDescriptor&)>&) const override { }
+private:
+    bool shouldDeleteRange(Range*) final { return false; }
+    bool smartInsertDeleteEnabled() final { return false; }
+    bool isSelectTrailingWhitespaceEnabled() final { return false; }
+    bool isContinuousSpellCheckingEnabled() final { return false; }
+    void toggleContinuousSpellChecking() final { }
+    bool isGrammarCheckingEnabled() final { return false; }
+    void toggleGrammarChecking() final { }
+    int spellCheckerDocumentTag() final { return -1; }
+
+    bool shouldBeginEditing(Range*) final { return false; }
+    bool shouldEndEditing(Range*) final { return false; }
+    bool shouldInsertNode(Node*, Range*, EditorInsertAction) final { return false; }
+    bool shouldInsertText(const String&, Range*, EditorInsertAction) final { return false; }
+    bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) final { return false; }
+
+    bool shouldApplyStyle(StyleProperties*, Range*) final { return false; }
+    void didApplyStyle() final { }
+    bool shouldMoveRangeAfterDelete(Range*, Range*) final { return false; }
+
+    void didBeginEditing() final { }
+    void respondToChangedContents() final { }
+    void respondToChangedSelection(Frame*) final { }
+    void didChangeSelectionAndUpdateLayout() final { }
+    void updateEditorStateAfterLayoutIfEditabilityChanged() final { }
+    void discardedComposition(Frame*) final { }
+    void canceledComposition() final { }
+    void didEndEditing() final { }
+    void willWriteSelectionToPasteboard(Range*) final { }
+    void didWriteSelectionToPasteboard() final { }
+    void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) final { }
+    void requestCandidatesForSelection(const VisibleSelection&) final { }
+    void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) final { }
+
+    void registerUndoStep(PassRefPtr<UndoStep>) final;
+    void registerRedoStep(PassRefPtr<UndoStep>) final;
+    void clearUndoRedoOperations() final { }
+
+    bool canCopyCut(Frame*, bool defaultValue) const final { return defaultValue; }
+    bool canPaste(Frame*, bool defaultValue) const final { return defaultValue; }
+    bool canUndo() const final { return false; }
+    bool canRedo() const final { return false; }
+
+    void undo() final { }
+    void redo() final { }
+
+    void handleKeyboardEvent(KeyboardEvent*) final { }
+    void handleInputMethodKeydown(KeyboardEvent*) final { }
+
+    void textFieldDidBeginEditing(Element*) final { }
+    void textFieldDidEndEditing(Element*) final { }
+    void textDidChangeInTextField(Element*) final { }
+    bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) final { return false; }
+    void textWillBeDeletedInTextField(Element*) final { }
+    void textDidChangeInTextArea(Element*) final { }
+    void overflowScrollPositionChanged() final { }
+
+#if PLATFORM(IOS)
+    void startDelayingAndCoalescingContentChangeNotifications() final { }
+    void stopDelayingAndCoalescingContentChangeNotifications() final { }
+    void writeDataToPasteboard(NSDictionary*) final { }
+    NSArray* supportedPasteboardTypesForCurrentSelection() final { return nullptr; }
+    NSArray* readDataFromPasteboard(NSString*, int) final { return nullptr; }
+    bool hasRichlyEditableSelection() final { return false; }
+    int getPasteboardItemsCount() final { return 0; }
+    RefPtr<DocumentFragment> documentFragmentFromDelegate(int) final { return nullptr; }
+    bool performsTwoStepPaste(DocumentFragment*) final { return false; }
+    int pasteboardChangeCount() final { return 0; }
 #endif
-#if ENABLE(CONTENT_EXTENSIONS)
-    ContentExtensions::ContentExtensionsBackend& userContentExtensionBackend() override { static NeverDestroyed<ContentExtensions::ContentExtensionsBackend> backend; return backend.get(); };
+
+#if PLATFORM(COCOA)
+    NSString *userVisibleString(NSURL *) final { return nullptr; }
+    void setInsertionPasteboard(const String&) final { };
+    NSURL *canonicalizeURL(NSURL *) final { return nullptr; }
+    NSURL *canonicalizeURLString(NSString *) final { return nullptr; }
 #endif
-};
 
-class EmptyVisitedLinkStore final : public VisitedLinkStore {
-    bool isLinkVisited(Page&, LinkHash, const URL&, const AtomicString&) override { return false; }
-    void addVisitedLink(Page&, LinkHash) override { }
-};
+#if USE(APPKIT)
+    void uppercaseWord() final { }
+    void lowercaseWord() final { }
+    void capitalizeWord() final { }
+#endif
 
-class EmptyBackForwardClient final : public BackForwardClient {
-    void addItem(Ref<HistoryItem>&&) override { }
-    void goToItem(HistoryItem*) override { }
-    HistoryItem* itemAtIndex(int) override { return nullptr; }
-    int backListCount() override { return 0; }
-    int forwardListCount() override { return 0; }
-    void close() override { }
+#if USE(AUTOMATIC_TEXT_REPLACEMENT)
+    void showSubstitutionsPanel(bool) final { }
+    bool substitutionsPanelIsShowing() final { return false; }
+    void toggleSmartInsertDelete() final { }
+    bool isAutomaticQuoteSubstitutionEnabled() final { return false; }
+    void toggleAutomaticQuoteSubstitution() final { }
+    bool isAutomaticLinkDetectionEnabled() final { return false; }
+    void toggleAutomaticLinkDetection() final { }
+    bool isAutomaticDashSubstitutionEnabled() final { return false; }
+    void toggleAutomaticDashSubstitution() final { }
+    bool isAutomaticTextReplacementEnabled() final { return false; }
+    void toggleAutomaticTextReplacement() final { }
+    bool isAutomaticSpellingCorrectionEnabled() final { return false; }
+    void toggleAutomaticSpellingCorrection() final { }
+#endif
+
+#if PLATFORM(GTK)
+    bool shouldShowUnicodeMenu() final { return false; }
+#endif
+
+    TextCheckerClient* textChecker() final { return &m_textCheckerClient; }
+
+    void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) final { }
+    void updateSpellingUIWithMisspelledWord(const String&) final { }
+    void showSpellingUI(bool) final { }
+    bool spellingUIIsShowing() final { return false; }
+
+    void willSetInputMethodState() final { }
+    void setInputMethodState(bool) final { }
+
+    class EmptyTextCheckerClient final : public TextCheckerClient {
+        bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const final { return true; }
+        void ignoreWordInSpellDocument(const String&) final { }
+        void learnWord(const String&) final { }
+        void checkSpellingOfString(StringView, int*, int*) final { }
+        String getAutoCorrectSuggestionForMisspelledWord(const String&) final { return { }; }
+        void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) final { }
+
+#if USE(UNIFIED_TEXT_CHECKING)
+        Vector<TextCheckingResult> checkTextOfParagraph(StringView, TextCheckingTypeMask, const VisibleSelection&) final { return Vector<TextCheckingResult>(); }
+#endif
+
+        void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) final { }
+        void requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&) final;
+    };
+
+    EmptyTextCheckerClient m_textCheckerClient;
 };
 
-void fillWithEmptyClients(PageConfiguration& pageConfiguration)
-{
-    static NeverDestroyed<EmptyChromeClient> dummyChromeClient;
-    pageConfiguration.chromeClient = &dummyChromeClient.get();
+class EmptyFrameLoaderClient final : public FrameLoaderClient {
+    void frameLoaderDestroyed() final { }
 
-#if ENABLE(APPLE_PAY)
-    static NeverDestroyed<EmptyPaymentCoordinatorClient> dummyPaymentCoordinatorClient;
-    pageConfiguration.paymentCoordinatorClient = &dummyPaymentCoordinatorClient.get();
+    bool hasWebView() const final { return true; } // mainly for assertions
+
+    void makeRepresentation(DocumentLoader*) final { }
+#if PLATFORM(IOS)
+    bool forceLayoutOnRestoreFromPageCache() final { return false; }
 #endif
+    void forceLayoutForNonHTML() final { }
 
-#if ENABLE(CONTEXT_MENUS)
-    static NeverDestroyed<EmptyContextMenuClient> dummyContextMenuClient;
-    pageConfiguration.contextMenuClient = &dummyContextMenuClient.get();
+    void setCopiesOnScroll() final { }
+
+    void detachedFromParent2() final { }
+    void detachedFromParent3() final { }
+
+    void convertMainResourceLoadToDownload(DocumentLoader*, SessionID, const ResourceRequest&, const ResourceResponse&) final { }
+
+    void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) final { }
+    bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) final { return false; }
+    void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) final { }
+    void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) final { }
+#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
+    bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) final { return false; }
 #endif
 
-#if ENABLE(DRAG_SUPPORT)
-    static NeverDestroyed<EmptyDragClient> dummyDragClient;
-    pageConfiguration.dragClient = &dummyDragClient.get();
+#if PLATFORM(IOS)
+    RetainPtr<CFDictionaryRef> connectionProperties(DocumentLoader*, unsigned long) final { return nullptr; }
 #endif
 
-    static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
-    pageConfiguration.inspectorClient = &dummyInspectorClient.get();
+    void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) final { }
+    void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) final { }
+    void dispatchDidFinishLoading(DocumentLoader*, unsigned long) final { }
+#if ENABLE(DATA_DETECTION)
+    void dispatchDidFinishDataDetection(NSArray *) final { }
+#endif
+    void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) final { }
+    bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) final { return false; }
+
+    void dispatchDidDispatchOnloadEvents() final { }
+    void dispatchDidReceiveServerRedirectForProvisionalLoad() final { }
+    void dispatchDidCancelClientRedirect() final { }
+    void dispatchWillPerformClientRedirect(const URL&, double, double) final { }
+    void dispatchDidChangeLocationWithinPage() final { }
+    void dispatchDidPushStateWithinPage() final { }
+    void dispatchDidReplaceStateWithinPage() final { }
+    void dispatchDidPopStateWithinPage() final { }
+    void dispatchWillClose() final { }
+    void dispatchDidReceiveIcon() final { }
+    void dispatchDidStartProvisionalLoad() final { }
+    void dispatchDidReceiveTitle(const StringWithDirection&) final { }
+    void dispatchDidCommitLoad(std::optional<HasInsecureContent>) final { }
+    void dispatchDidFailProvisionalLoad(const ResourceError&) final { }
+    void dispatchDidFailLoad(const ResourceError&) final { }
+    void dispatchDidFinishDocumentLoad() final { }
+    void dispatchDidFinishLoad() final { }
+    void dispatchDidReachLayoutMilestone(LayoutMilestones) final { }
+
+    Frame* dispatchCreatePage(const NavigationAction&) final { return nullptr; }
+    void dispatchShow() final { }
+
+    void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, FramePolicyFunction) final { }
+    void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&, FramePolicyFunction) final;
+    void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, FramePolicyFunction) final;
+    void cancelPolicyCheck() final { }
+
+    void dispatchUnableToImplementPolicy(const ResourceError&) final { }
+
+    void dispatchWillSendSubmitEvent(PassRefPtr<FormState>) final;
+    void dispatchWillSubmitForm(PassRefPtr<FormState>, FramePolicyFunction) final;
+
+    void revertToProvisionalState(DocumentLoader*) final { }
+    void setMainDocumentError(DocumentLoader*, const ResourceError&) final { }
+
+    void setMainFrameDocumentReady(bool) final { }
+
+    void startDownload(const ResourceRequest&, const String&) final { }
+
+    void willChangeTitle(DocumentLoader*) final { }
+    void didChangeTitle(DocumentLoader*) final { }
+
+    void willReplaceMultipartContent() final { }
+    void didReplaceMultipartContent() final { }
+
+    void committedLoad(DocumentLoader*, const char*, int) final { }
+    void finishedLoading(DocumentLoader*) final { }
+
+    ResourceError cancelledError(const ResourceRequest&) final { return { ResourceError::Type::Cancellation }; }
+    ResourceError blockedError(const ResourceRequest&) final { return { }; }
+    ResourceError blockedByContentBlockerError(const ResourceRequest&) final { return { }; }
+    ResourceError cannotShowURLError(const ResourceRequest&) final { return { }; }
+    ResourceError interruptedForPolicyChangeError(const ResourceRequest&) final { return { }; }
+#if ENABLE(CONTENT_FILTERING)
+    ResourceError blockedByContentFilterError(const ResourceRequest&) final { return { }; }
+#endif
 
-    static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
-    pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
+    ResourceError cannotShowMIMETypeError(const ResourceResponse&) final { return { }; }
+    ResourceError fileDoesNotExistError(const ResourceResponse&) final { return { }; }
+    ResourceError pluginWillHandleLoadError(const ResourceResponse&) final { return { }; }
 
-    static NeverDestroyed<EmptyProgressTrackerClient> dummyProgressTrackerClient;
-    pageConfiguration.progressTrackerClient = &dummyProgressTrackerClient.get();
+    bool shouldFallBack(const ResourceError&) final { return false; }
 
-    pageConfiguration.backForwardClient = adoptRef(new EmptyBackForwardClient);
-    pageConfiguration.diagnosticLoggingClient = std::make_unique<EmptyDiagnosticLoggingClient>();
+    bool canHandleRequest(const ResourceRequest&) const final { return false; }
+    bool canShowMIMEType(const String&) const final { return false; }
+    bool canShowMIMETypeAsHTML(const String&) const final { return false; }
+    bool representationExistsForURLScheme(const String&) const final { return false; }
+    String generatedMIMETypeForURLScheme(const String&) const final { return emptyString(); }
 
-    pageConfiguration.applicationCacheStorage = ApplicationCacheStorage::create(String(), String());
-    pageConfiguration.databaseProvider = adoptRef(new EmptyDatabaseProvider);
-    pageConfiguration.pluginInfoProvider = adoptRef(new EmptyPluginInfoProvider);
-    pageConfiguration.storageNamespaceProvider = adoptRef(new EmptyStorageNamespaceProvider);
-    pageConfiguration.userContentProvider = adoptRef(new EmptyUserContentProvider);
-    pageConfiguration.visitedLinkStore = adoptRef(new EmptyVisitedLinkStore);
-}
+    void frameLoadCompleted() final { }
+    void restoreViewState() final { }
+    void provisionalLoadStarted() final { }
+    void didFinishLoad() final { }
+    void prepareForDataSourceReplacement() final { }
+
+    Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) final;
+    void updateCachedDocumentLoader(DocumentLoader&) final { }
+    void setTitle(const StringWithDirection&, const URL&) final { }
+
+    String userAgent(const URL&) final { return emptyString(); }
+
+    void savePlatformDataToCachedFrame(CachedFrame*) final { }
+    void transitionToCommittedFromCachedFrame(CachedFrame*) final { }
+#if PLATFORM(IOS)
+    void didRestoreFrameHierarchyForCachedFrame() final { }
+#endif
+    void transitionToCommittedForNewPage() final { }
+
+    void didSaveToPageCache() final { }
+    void didRestoreFromPageCache() final { }
+
+    void dispatchDidBecomeFrameset(bool) final { }
+
+    void updateGlobalHistory() final { }
+    void updateGlobalHistoryRedirectLinks() final { }
+    bool shouldGoToHistoryItem(HistoryItem*) const final { return false; }
+    void updateGlobalHistoryItemForPage() final { }
+    void saveViewStateToItem(HistoryItem&) final { }
+    bool canCachePage() const final { return false; }
+    void didDisplayInsecureContent() final { }
+    void didRunInsecureContent(SecurityOrigin*, const URL&) final { }
+    void didDetectXSS(const URL&, bool) final { }
+    RefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) final;
+    RefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) final;
+    void recreatePlugin(Widget*) final;
+    PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) final;
+
+    ObjectContentType objectContentType(const URL&, const String&) final { return ObjectContentType::None; }
+    String overrideMediaType() const final { return { }; }
+
+    void redirectDataToPlugin(Widget*) final { }
+    void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&) final { }
+
+    void registerForIconNotification(bool) final { }
+
+#if PLATFORM(COCOA)
+    RemoteAXObjectRef accessibilityRemoteObject() final { return nullptr; }
+    NSCachedURLResponse *willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse *response) const final { return response; }
+#endif
+
+#if PLATFORM(WIN) && USE(CFURLCONNECTION)
+    bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) final { return true; }
+#endif
+
+    PassRefPtr<FrameNetworkingContext> createNetworkingContext() final;
+
+#if ENABLE(REQUEST_AUTOCOMPLETE)
+    void didRequestAutocomplete(PassRefPtr<FormState>) final { }
+#endif
+
+    bool isEmptyFrameLoaderClient() final { return true; }
+    void prefetchDNS(const String&) final { }
+};
+
+class EmptyInspectorClient final : public InspectorClient {
+    void inspectedPageDestroyed() final { }
+    Inspector::FrontendChannel* openLocalFrontend(InspectorController*) final { return nullptr; }
+    void bringFrontendToFront() final { }
+    void highlight() final { }
+    void hideHighlight() final { }
+};
+
+#if ENABLE(APPLE_PAY)
+
+class EmptyPaymentCoordinatorClient final : public PaymentCoordinatorClient {
+    bool supportsVersion(unsigned) final { return false; }
+    bool canMakePayments() final { return false; }
+    void canMakePaymentsWithActiveCard(const String&, const String&, std::function<void(bool)> completionHandler) final { callOnMainThread([completionHandler] { completionHandler(false); }); }
+    void openPaymentSetup(const String&, const String&, std::function<void(bool)> completionHandler) final { callOnMainThread([completionHandler] { completionHandler(false); }); }
+    bool showPaymentUI(const URL&, const Vector<URL>&, const PaymentRequest&) final { return false; }
+    void completeMerchantValidation(const PaymentMerchantSession&) final { }
+    void completeShippingMethodSelection(PaymentAuthorizationStatus, std::optional<PaymentRequest::TotalAndLineItems>) final { }
+    void completeShippingContactSelection(PaymentAuthorizationStatus, const Vector<PaymentRequest::ShippingMethod>&, std::optional<PaymentRequest::TotalAndLineItems>) final { }
+    void completePaymentMethodSelection(std::optional<WebCore::PaymentRequest::TotalAndLineItems>) final { }
+    void completePaymentSession(PaymentAuthorizationStatus) final { }
+    void abortPaymentSession() final { }
+    void paymentCoordinatorDestroyed() final { }
+};
+
+#endif
+
+class EmptyPluginInfoProvider final : public PluginInfoProvider {
+    void refreshPlugins() final { };
+    void getPluginInfo(Page&, Vector<PluginInfo>&) final { }
+    void getWebVisiblePluginInfo(Page&, Vector<PluginInfo>&) final { }
+};
 
 class EmptyPopupMenu : public PopupMenu {
 public:
-    void show(const IntRect&, FrameView*, int) override { }
-    void hide() override { }
-    void updateFromElement() override { }
-    void disconnectClient() override { }
+    EmptyPopupMenu() = default;
+private:
+    void show(const IntRect&, FrameView*, int) final { }
+    void hide() final { }
+    void updateFromElement() final { }
+    void disconnectClient() final { }
+};
+
+class EmptyProgressTrackerClient final : public ProgressTrackerClient {
+    void willChangeEstimatedProgress() final { }
+    void didChangeEstimatedProgress() final { }
+    void progressStarted(Frame&) final { }
+    void progressEstimateChanged(Frame&) final { }
+    void progressFinished(Frame&) final { }
 };
 
 class EmptySearchPopupMenu : public SearchPopupMenu {
 public:
-    PopupMenu* popupMenu() override { return m_popup.get(); }
-    void saveRecentSearches(const AtomicString&, const Vector<RecentSearch>&) override { }
-    void loadRecentSearches(const AtomicString&, Vector<RecentSearch>&) override { }
-    bool enabled() override { return false; }
+    EmptySearchPopupMenu()
+        : m_popup(adoptRef(*new EmptyPopupMenu))
+    {
+    }
 
 private:
-    RefPtr<EmptyPopupMenu> m_popup;
+    PopupMenu* popupMenu() final { return m_popup.ptr(); }
+    void saveRecentSearches(const AtomicString&, const Vector<RecentSearch>&) final { }
+    void loadRecentSearches(const AtomicString&, Vector<RecentSearch>&) final { }
+    bool enabled() final { return false; }
+
+    Ref<EmptyPopupMenu> m_popup;
+};
+
+class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {
+    struct EmptyStorageArea : public StorageArea {
+        unsigned length() final { return 0; }
+        String key(unsigned) final { return { }; }
+        String item(const String&) final { return { }; }
+        void setItem(Frame*, const String&, const String&, bool&) final { }
+        void removeItem(Frame*, const String&) final { }
+        void clear(Frame*) final { }
+        bool contains(const String&) final { return false; }
+        bool canAccessStorage(Frame*) final { return false; }
+        StorageType storageType() const final { return LocalStorage; }
+        size_t memoryBytesUsedByCache() final { return 0; }
+        SecurityOriginData securityOrigin() const final { return { }; }
+    };
+
+    struct EmptyStorageNamespace final : public StorageNamespace {
+        RefPtr<StorageArea> storageArea(const SecurityOriginData&) final { return adoptRef(*new EmptyStorageArea); }
+        RefPtr<StorageNamespace> copy(Page*) final { return adoptRef(*new EmptyStorageNamespace); }
+    };
+
+    RefPtr<StorageNamespace> createSessionStorageNamespace(Page&, unsigned) final;
+    RefPtr<StorageNamespace> createLocalStorageNamespace(unsigned) final;
+    RefPtr<StorageNamespace> createTransientLocalStorageNamespace(SecurityOrigin&, unsigned) final;
+};
+
+class EmptyUserContentProvider final : public UserContentProvider {
+    void forEachUserScript(const std::function<void(DOMWrapperWorld&, const UserScript&)>&) const final { }
+    void forEachUserStyleSheet(const std::function<void(const UserStyleSheet&)>&) const final { }
+#if ENABLE(USER_MESSAGE_HANDLERS)
+    void forEachUserMessageHandler(const std::function<void(const UserMessageHandlerDescriptor&)>&) const final { }
+#endif
+#if ENABLE(CONTENT_EXTENSIONS)
+    ContentExtensions::ContentExtensionsBackend& userContentExtensionBackend() final { static NeverDestroyed<ContentExtensions::ContentExtensionsBackend> backend; return backend.get(); };
+#endif
+};
+
+class EmptyVisitedLinkStore final : public VisitedLinkStore {
+    bool isLinkVisited(Page&, LinkHash, const URL&, const AtomicString&) final { return false; }
+    void addVisitedLink(Page&, LinkHash) final { }
 };
 
 RefPtr<PopupMenu> EmptyChromeClient::createPopupMenu(PopupMenuClient*) const
 {
-    return adoptRef(new EmptyPopupMenu());
+    return adoptRef(*new EmptyPopupMenu);
 }
 
 RefPtr<SearchPopupMenu> EmptyChromeClient::createSearchPopupMenu(PopupMenuClient*) const
 {
-    return adoptRef(new EmptySearchPopupMenu());
+    return adoptRef(*new EmptySearchPopupMenu);
 }
 
 #if ENABLE(INPUT_TYPE_COLOR)
+
 std::unique_ptr<ColorChooser> EmptyChromeClient::createColorChooser(ColorChooserClient*, const Color&)
 {
     return nullptr;
 }
+
 #endif
 
 void EmptyChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser>)
@@ -276,7 +618,7 @@ PassRefPtr<FrameNetworkingContext> EmptyFrameLoaderClient::createNetworkingConte
     return PassRefPtr<FrameNetworkingContext>();
 }
 
-void EmptyTextCheckerClient::requestCheckingOfString(PassRefPtr<TextCheckingRequest>, const VisibleSelection&)
+void EmptyEditorClient::EmptyTextCheckerClient::requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&)
 {
 }
 
@@ -288,4 +630,70 @@ void EmptyEditorClient::registerRedoStep(PassRefPtr<UndoStep>)
 {
 }
 
+RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createSessionStorageNamespace(Page&, unsigned)
+{
+    return adoptRef(*new EmptyStorageNamespace);
+}
+
+RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createLocalStorageNamespace(unsigned)
+{
+    return adoptRef(*new EmptyStorageNamespace);
+}
+
+RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createTransientLocalStorageNamespace(SecurityOrigin&, unsigned)
+{
+    return adoptRef(*new EmptyStorageNamespace);
+}
+
+void fillWithEmptyClients(PageConfiguration& pageConfiguration)
+{
+    static NeverDestroyed<EmptyChromeClient> dummyChromeClient;
+    pageConfiguration.chromeClient = &dummyChromeClient.get();
+
+#if ENABLE(APPLE_PAY)
+    static NeverDestroyed<EmptyPaymentCoordinatorClient> dummyPaymentCoordinatorClient;
+    pageConfiguration.paymentCoordinatorClient = &dummyPaymentCoordinatorClient.get();
+#endif
+
+#if ENABLE(CONTEXT_MENUS)
+    static NeverDestroyed<EmptyContextMenuClient> dummyContextMenuClient;
+    pageConfiguration.contextMenuClient = &dummyContextMenuClient.get();
+#endif
+
+#if ENABLE(DRAG_SUPPORT)
+    static NeverDestroyed<EmptyDragClient> dummyDragClient;
+    pageConfiguration.dragClient = &dummyDragClient.get();
+#endif
+
+    static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
+    pageConfiguration.inspectorClient = &dummyInspectorClient.get();
+
+    static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
+    pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
+
+    static NeverDestroyed<EmptyProgressTrackerClient> dummyProgressTrackerClient;
+    pageConfiguration.progressTrackerClient = &dummyProgressTrackerClient.get();
+
+    pageConfiguration.backForwardClient = adoptRef(*new EmptyBackForwardClient);
+    pageConfiguration.diagnosticLoggingClient = std::make_unique<EmptyDiagnosticLoggingClient>();
+
+    pageConfiguration.applicationCacheStorage = ApplicationCacheStorage::create({ }, { });
+    pageConfiguration.databaseProvider = adoptRef(*new EmptyDatabaseProvider);
+    pageConfiguration.pluginInfoProvider = adoptRef(*new EmptyPluginInfoProvider);
+    pageConfiguration.storageNamespaceProvider = adoptRef(*new EmptyStorageNamespaceProvider);
+    pageConfiguration.userContentProvider = adoptRef(*new EmptyUserContentProvider);
+    pageConfiguration.visitedLinkStore = adoptRef(*new EmptyVisitedLinkStore);
+}
+
+UniqueRef<EditorClient> createEmptyEditorClient()
+{
+    return makeUniqueRef<EmptyEditorClient>();
+}
+
+DiagnosticLoggingClient& emptyDiagnosticLoggingClient()
+{
+    static NeverDestroyed<EmptyDiagnosticLoggingClient> client;
+    return client;
+}
+
 }
index 49c9af6..1a1d53c 100644 (file)
 #pragma once
 
 #include "ChromeClient.h"
-#include "ContextMenuClient.h"
-#include "DeviceMotionClient.h"
-#include "DeviceOrientationClient.h"
-#include "DiagnosticLoggingClient.h"
-#include "DocumentFragment.h"
-#include "DragClient.h"
-#include "EditorClient.h"
-#include "FloatRect.h"
-#include "FocusDirection.h"
-#include "FrameLoaderClient.h"
-#include "InspectorClient.h"
-#include "ProgressTrackerClient.h"
-#include "ResourceError.h"
-#include "SessionID.h"
-#include "SocketProvider.h"
-#include "TextCheckerClient.h"
-#include "VisitedLinkStore.h"
-#include <wtf/text/StringView.h>
-
-#if ENABLE(USER_MESSAGE_HANDLERS)
-#include "UserMessageHandlerDescriptor.h"
-#endif
-
-#if ENABLE(CONTENT_EXTENSIONS)
-#include "CompiledContentExtension.h"
-#endif
-
-/*
- This file holds empty Client stubs for use by WebCore.
- Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.
- This tree depends heavily on Clients (usually provided by WebKit classes).
-
- This file was first created for SVGImage as it had no way to access the current Page (nor should it,
- since Images are not tied to a page).
- See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
+#include <wtf/UniqueRef.h>
 
- Ideally, whenever you change a Client class, you should add a stub here.
- Brittle, yes.  Unfortunate, yes.  Hopefully temporary.
-*/
+// Empty client classes for use by WebCore.
+//
+// First created for SVGImage as it had no way to access the current Page (nor should it, since Images are not tied to a page).
+// See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
 
 namespace WebCore {
 
-class Page;
+class DiagnosticLoggingClient;
+class EditorClient;
 class PageConfiguration;
 
 class EmptyChromeClient : public ChromeClient {
     WTF_MAKE_FAST_ALLOCATED;
-public:
-    virtual ~EmptyChromeClient() { }
+
     void chromeDestroyed() override { }
 
-    void setWindowRect(const FloatRect&) override { }
-    FloatRect windowRect() override { return FloatRect(); }
+    void setWindowRect(const FloatRect&) final { }
+    FloatRect windowRect() final { return FloatRect(); }
 
-    FloatRect pageRect() override { return FloatRect(); }
+    FloatRect pageRect() final { return FloatRect(); }
 
-    void focus() override { }
-    void unfocus() override { }
+    void focus() final { }
+    void unfocus() final { }
 
-    bool canTakeFocus(FocusDirection) override { return false; }
-    void takeFocus(FocusDirection) override { }
+    bool canTakeFocus(FocusDirection) final { return false; }
+    void takeFocus(FocusDirection) final { }
 
-    void focusedElementChanged(Element*) override { }
-    void focusedFrameChanged(Frame*) override { }
+    void focusedElementChanged(Element*) final { }
+    void focusedFrameChanged(Frame*) final { }
 
-    Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) override { return nullptr; }
-    void show() override { }
+    Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) final { return nullptr; }
+    void show() final { }
 
-    bool canRunModal() override { return false; }
-    void runModal() override { }
+    bool canRunModal() final { return false; }
+    void runModal() final { }
 
-    void setToolbarsVisible(bool) override { }
-    bool toolbarsVisible() override { return false; }
+    void setToolbarsVisible(bool) final { }
+    bool toolbarsVisible() final { return false; }
 
-    void setStatusbarVisible(bool) override { }
-    bool statusbarVisible() override { return false; }
+    void setStatusbarVisible(bool) final { }
+    bool statusbarVisible() final { return false; }
 
-    void setScrollbarsVisible(bool) override { }
-    bool scrollbarsVisible() override { return false; }
+    void setScrollbarsVisible(bool) final { }
+    bool scrollbarsVisible() final { return false; }
 
-    void setMenubarVisible(bool) override { }
-    bool menubarVisible() override { return false; }
+    void setMenubarVisible(bool) final { }
+    bool menubarVisible() final { return false; }
 
-    void setResizable(bool) override { }
+    void setResizable(bool) final { }
 
-    void addMessageToConsole(MessageSource, MessageLevel, const String&, unsigned, unsigned, const String&) override { }
+    void addMessageToConsole(MessageSource, MessageLevel, const String&, unsigned, unsigned, const String&) final { }
 
-    bool canRunBeforeUnloadConfirmPanel() override { return false; }
-    bool runBeforeUnloadConfirmPanel(const String&, Frame*) override { return true; }
+    bool canRunBeforeUnloadConfirmPanel() final { return false; }
+    bool runBeforeUnloadConfirmPanel(const String&, Frame*) final { return true; }
 
-    void closeWindowSoon() override { }
+    void closeWindowSoon() final { }
 
-    void runJavaScriptAlert(Frame*, const String&) override { }
-    bool runJavaScriptConfirm(Frame*, const String&) override { return false; }
-    bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) override { return false; }
+    void runJavaScriptAlert(Frame*, const String&) final { }
+    bool runJavaScriptConfirm(Frame*, const String&) final { return false; }
+    bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) final { return false; }
 
-    bool selectItemWritingDirectionIsNatural() override { return false; }
-    bool selectItemAlignmentFollowsMenuWritingDirection() override { return false; }
-    bool hasOpenedPopup() const override { return false; }
-    RefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const override;
-    RefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const override;
+    bool selectItemWritingDirectionIsNatural() final { return false; }
+    bool selectItemAlignmentFollowsMenuWritingDirection() final { return false; }
+    bool hasOpenedPopup() const final { return false; }
+    RefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const final;
+    RefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const final;
 
-    void setStatusbarText(const String&) override { }
+    void setStatusbarText(const String&) final { }
 
-    KeyboardUIMode keyboardUIMode() override { return KeyboardAccessDefault; }
+    KeyboardUIMode keyboardUIMode() final { return KeyboardAccessDefault; }
 
-    void invalidateRootView(const IntRect&) override { }
+    void invalidateRootView(const IntRect&) final { }
     void invalidateContentsAndRootView(const IntRect&) override { }
-    void invalidateContentsForSlowScroll(const IntRect&) override { }
-    void scroll(const IntSize&, const IntRect&, const IntRect&) override { }
+    void invalidateContentsForSlowScroll(const IntRect&) final { }
+    void scroll(const IntSize&, const IntRect&, const IntRect&) final { }
 #if USE(COORDINATED_GRAPHICS)
-    void delegatedScrollRequested(const IntPoint&) override { }
+    void delegatedScrollRequested(const IntPoint&) final { }
 #endif
 #if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
-    void scheduleAnimation() override { }
+    void scheduleAnimation() final { }
 #endif
 
-    IntPoint screenToRootView(const IntPoint& p) const override { return p; }
-    IntRect rootViewToScreen(const IntRect& r) const override { return r; }
+    IntPoint screenToRootView(const IntPoint& p) const final { return p; }
+    IntRect rootViewToScreen(const IntRect& r) const final { return r; }
 #if PLATFORM(IOS)
-    IntPoint accessibilityScreenToRootView(const IntPoint& p) const override { return p; };
-    IntRect rootViewToAccessibilityScreen(const IntRect& r) const override { return r; };
+    IntPoint accessibilityScreenToRootView(const IntPoint& p) const final { return p; };
+    IntRect rootViewToAccessibilityScreen(const IntRect& r) const final { return r; };
 #endif
-    PlatformPageClient platformPageClient() const override { return 0; }
-    void contentsSizeChanged(Frame*, const IntSize&) const override { }
+    PlatformPageClient platformPageClient() const final { return 0; }
+    void contentsSizeChanged(Frame*, const IntSize&) const final { }
 
-    void scrollbarsModeDidChange() const override { }
-    void mouseDidMoveOverElement(const HitTestResult&, unsigned) override { }
+    void scrollbarsModeDidChange() const final { }
+    void mouseDidMoveOverElement(const HitTestResult&, unsigned) final { }
 
-    void setToolTip(const String&, TextDirection) override { }
+    void setToolTip(const String&, TextDirection) final { }
 
-    void print(Frame*) override { }
+    void print(Frame*) final { }
 
-    void exceededDatabaseQuota(Frame*, const String&, DatabaseDetails) override { }
+    void exceededDatabaseQuota(Frame*, const String&, DatabaseDetails) final { }
 
-    void reachedMaxAppCacheSize(int64_t) override { }
-    void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t) override { }
+    void reachedMaxAppCacheSize(int64_t) final { }
+    void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t) final { }
 
 #if ENABLE(INPUT_TYPE_COLOR)
-    std::unique_ptr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) override;
+    std::unique_ptr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) final;
 #endif
 
-    void runOpenPanel(Frame*, PassRefPtr<FileChooser>) override;
-    void loadIconForFiles(const Vector<String>&, FileIconLoader&) override { }
+    void runOpenPanel(Frame*, PassRefPtr<FileChooser>) final;
+    void loadIconForFiles(const Vector<String>&, FileIconLoader&) final { }
 
-    void elementDidFocus(const Node*) override { }
-    void elementDidBlur(const Node*) override { }
+    void elementDidFocus(const Node*) final { }
+    void elementDidBlur(const Node*) final { }
 
 #if !PLATFORM(IOS)
-    void setCursor(const Cursor&) override { }
-    void setCursorHiddenUntilMouseMoves(bool) override { }
+    void setCursor(const Cursor&) final { }
+    void setCursorHiddenUntilMouseMoves(bool) final { }
 #endif
 
-    void scrollRectIntoView(const IntRect&) const override { }
+    void scrollRectIntoView(const IntRect&) const final { }
 
-    void attachRootGraphicsLayer(Frame*, GraphicsLayer*) override { }
-    void attachViewOverlayGraphicsLayer(Frame*, GraphicsLayer*) override { }
-    void setNeedsOneShotDrawingSynchronization() override { }
-    void scheduleCompositingLayerFlush() override { }
+    void attachRootGraphicsLayer(Frame*, GraphicsLayer*) final { }
+    void attachViewOverlayGraphicsLayer(Frame*, GraphicsLayer*) final { }
+    void setNeedsOneShotDrawingSynchronization() final { }
+    void scheduleCompositingLayerFlush() final { }
 
 #if PLATFORM(WIN)
-    void setLastSetCursorToCurrentCursor() override { }
-    void AXStartFrameLoad() override { }
-    void AXFinishFrameLoad() override { }
+    void setLastSetCursorToCurrentCursor() final { }
+    void AXStartFrameLoad() final { }
+    void AXFinishFrameLoad() final { }
 #endif
 
 #if PLATFORM(IOS)
 #if ENABLE(IOS_TOUCH_EVENTS)
-    void didPreventDefaultForEvent() override { }
-#endif
-    void didReceiveMobileDocType(bool) override { }
-    void setNeedsScrollNotifications(Frame*, bool) override { }
-    void observedContentChange(Frame*) override { }
-    void clearContentChangeObservers(Frame*) override { }
-    void notifyRevealedSelectionByScrollingFrame(Frame*) override { }
-    void didLayout(LayoutType) override { }
-    void didStartOverflowScroll() override { }
-    void didEndOverflowScroll() override { }
-
-    void suppressFormNotifications() override { }
-    void restoreFormNotifications() override { }
-
-    void addOrUpdateScrollingLayer(Node*, PlatformLayer*, PlatformLayer*, const IntSize&, bool, bool) override { }
-    void removeScrollingLayer(Node*, PlatformLayer*, PlatformLayer*) override { }
-
-    void webAppOrientationsUpdated() override { };
-    void showPlaybackTargetPicker(bool) override { };
-#endif // PLATFORM(IOS)
-
-#if ENABLE(ORIENTATION_EVENTS)
-    int deviceOrientation() const override { return 0; }
-#endif
-
-#if PLATFORM(IOS)
-    bool isStopping() override { return false; }
-#endif
-
-    void wheelEventHandlersChanged(bool) override { }
-    
-    bool isEmptyChromeClient() const override { return true; }
-
-    void didAssociateFormControls(const Vector<RefPtr<Element>>&) override { }
-    bool shouldNotifyOnFormChanges() override { return false; }
-};
-
-// FIXME (bug 116233): Get rid of EmptyFrameLoaderClient. It is a travesty.
-
-class EmptyFrameLoaderClient : public FrameLoaderClient {
-    WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
-public:
-    EmptyFrameLoaderClient() { }
-    virtual ~EmptyFrameLoaderClient() {  }
-    void frameLoaderDestroyed() override { }
-
-    bool hasWebView() const override { return true; } // mainly for assertions
-
-    void makeRepresentation(DocumentLoader*) override { }
-#if PLATFORM(IOS)
-    bool forceLayoutOnRestoreFromPageCache() override { return false; }
-#endif
-    void forceLayoutForNonHTML() override { }
-
-    void setCopiesOnScroll() override { }
-
-    void detachedFromParent2() override { }
-    void detachedFromParent3() override { }
-
-    void convertMainResourceLoadToDownload(DocumentLoader*, SessionID, const ResourceRequest&, const ResourceResponse&) override { }
-
-    void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) override { }
-    bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) override { return false; }
-    void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) override { }
-    void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) override { }
-#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
-    bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) override { return false; }
-#endif
-
-#if PLATFORM(IOS)
-    RetainPtr<CFDictionaryRef> connectionProperties(DocumentLoader*, unsigned long) override { return nullptr; }
-#endif
-
-    void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) override { }
-    void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) override { }
-    void dispatchDidFinishLoading(DocumentLoader*, unsigned long) override { }
-#if ENABLE(DATA_DETECTION)
-    void dispatchDidFinishDataDetection(NSArray *) override { }
-#endif
-    void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) override { }
-    bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) override { return false; }
-
-    void dispatchDidDispatchOnloadEvents() override { }
-    void dispatchDidReceiveServerRedirectForProvisionalLoad() override { }
-    void dispatchDidCancelClientRedirect() override { }
-    void dispatchWillPerformClientRedirect(const URL&, double, double) override { }
-    void dispatchDidChangeLocationWithinPage() override { }
-    void dispatchDidPushStateWithinPage() override { }
-    void dispatchDidReplaceStateWithinPage() override { }
-    void dispatchDidPopStateWithinPage() override { }
-    void dispatchWillClose() override { }
-    void dispatchDidReceiveIcon() override { }
-    void dispatchDidStartProvisionalLoad() override { }
-    void dispatchDidReceiveTitle(const StringWithDirection&) override { }
-    void dispatchDidCommitLoad(std::optional<HasInsecureContent>) override { }
-    void dispatchDidFailProvisionalLoad(const ResourceError&) override { }
-    void dispatchDidFailLoad(const ResourceError&) override { }
-    void dispatchDidFinishDocumentLoad() override { }
-    void dispatchDidFinishLoad() override { }
-    void dispatchDidReachLayoutMilestone(LayoutMilestones) override { }
-
-    Frame* dispatchCreatePage(const NavigationAction&) override { return nullptr; }
-    void dispatchShow() override { }
-
-    void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, FramePolicyFunction) override { }
-    void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&, FramePolicyFunction) override;
-    void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, FramePolicyFunction) override;
-    void cancelPolicyCheck() override { }
-
-    void dispatchUnableToImplementPolicy(const ResourceError&) override { }
-
-    void dispatchWillSendSubmitEvent(PassRefPtr<FormState>) override;
-    void dispatchWillSubmitForm(PassRefPtr<FormState>, FramePolicyFunction) override;
-
-    void revertToProvisionalState(DocumentLoader*) override { }
-    void setMainDocumentError(DocumentLoader*, const ResourceError&) override { }
-
-    void setMainFrameDocumentReady(bool) override { }
-
-    void startDownload(const ResourceRequest&, const String& suggestedName = String()) override { UNUSED_PARAM(suggestedName); }
-
-    void willChangeTitle(DocumentLoader*) override { }
-    void didChangeTitle(DocumentLoader*) override { }
-
-    void willReplaceMultipartContent() override { }
-    void didReplaceMultipartContent() override { }
-
-    void committedLoad(DocumentLoader*, const char*, int) override { }
-    void finishedLoading(DocumentLoader*) override { }
-
-    ResourceError cancelledError(const ResourceRequest&) override { return ResourceError(ResourceError::Type::Cancellation); }
-    ResourceError blockedError(const ResourceRequest&) override { return { }; }
-    ResourceError blockedByContentBlockerError(const ResourceRequest&) override { return { }; }
-    ResourceError cannotShowURLError(const ResourceRequest&) override { return { }; }
-    ResourceError interruptedForPolicyChangeError(const ResourceRequest&) override { return { }; }
-#if ENABLE(CONTENT_FILTERING)
-    ResourceError blockedByContentFilterError(const ResourceRequest&) override { return { }; }
-#endif
-
-    ResourceError cannotShowMIMETypeError(const ResourceResponse&) override { return { }; }
-    ResourceError fileDoesNotExistError(const ResourceResponse&) override { return { }; }
-    ResourceError pluginWillHandleLoadError(const ResourceResponse&) override { return { }; }
-
-    bool shouldFallBack(const ResourceError&) override { return false; }
-
-    bool canHandleRequest(const ResourceRequest&) const override { return false; }
-    bool canShowMIMEType(const String&) const override { return false; }
-    bool canShowMIMETypeAsHTML(const String&) const override { return false; }
-    bool representationExistsForURLScheme(const String&) const override { return false; }
-    String generatedMIMETypeForURLScheme(const String&) const override { return emptyString(); }
-
-    void frameLoadCompleted() override { }
-    void restoreViewState() override { }
-    void provisionalLoadStarted() override { }
-    void didFinishLoad() override { }
-    void prepareForDataSourceReplacement() override { }
-
-    Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) override;
-    void updateCachedDocumentLoader(DocumentLoader&) override { }
-    void setTitle(const StringWithDirection&, const URL&) override { }
-
-    String userAgent(const URL&) override { return emptyString(); }
-
-    void savePlatformDataToCachedFrame(CachedFrame*) override { }
-    void transitionToCommittedFromCachedFrame(CachedFrame*) override { }
-#if PLATFORM(IOS)
-    void didRestoreFrameHierarchyForCachedFrame() override { }
-#endif
-    void transitionToCommittedForNewPage() override { }
-
-    void didSaveToPageCache() override { }
-    void didRestoreFromPageCache() override { }
-
-    void dispatchDidBecomeFrameset(bool) override { }
-
-    void updateGlobalHistory() override { }
-    void updateGlobalHistoryRedirectLinks() override { }
-    bool shouldGoToHistoryItem(HistoryItem*) const override { return false; }
-    void updateGlobalHistoryItemForPage() override { }
-    void saveViewStateToItem(HistoryItem&) override { }
-    bool canCachePage() const override { return false; }
-    void didDisplayInsecureContent() override { }
-    void didRunInsecureContent(SecurityOrigin*, const URL&) override { }
-    void didDetectXSS(const URL&, bool) override { }
-    RefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) override;
-    RefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) override;
-    void recreatePlugin(Widget*) override;
-    PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) override;
-
-    ObjectContentType objectContentType(const URL&, const String&) override { return ObjectContentType::None; }
-    String overrideMediaType() const override { return String(); }
-
-    void redirectDataToPlugin(Widget*) override { }
-    void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&) override { }
-
-    void registerForIconNotification(bool) override { }
-
-#if PLATFORM(COCOA)
-    RemoteAXObjectRef accessibilityRemoteObject() override { return nullptr; }
-    NSCachedURLResponse* willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse* response) const override { return response; }
+    void didPreventDefaultForEvent() final { }
 #endif
-#if PLATFORM(WIN) && USE(CFURLCONNECTION)
-    // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
-    bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) override { return true; }
-#endif
-
-    PassRefPtr<FrameNetworkingContext> createNetworkingContext() override;
+    void didReceiveMobileDocType(bool) final { }
+    void setNeedsScrollNotifications(Frame*, bool) final { }
+    void observedContentChange(Frame*) final { }
+    void clearContentChangeObservers(Frame*) final { }
+    void notifyRevealedSelectionByScrollingFrame(Frame*) final { }
+    void didLayout(LayoutType) final { }
+    void didStartOverflowScroll() final { }
+    void didEndOverflowScroll() final { }
 
-#if ENABLE(REQUEST_AUTOCOMPLETE)
-    void didRequestAutocomplete(PassRefPtr<FormState>) override { }
-#endif
+    void suppressFormNotifications() final { }
+    void restoreFormNotifications() final { }
 
-    bool isEmptyFrameLoaderClient() override { return true; }
+    void addOrUpdateScrollingLayer(Node*, PlatformLayer*, PlatformLayer*, const IntSize&, bool, bool) final { }
+    void removeScrollingLayer(Node*, PlatformLayer*, PlatformLayer*) final { }
 
-    void prefetchDNS(const String&) override { }
-};
+    void webAppOrientationsUpdated() final { };
+    void showPlaybackTargetPicker(bool) final { };
+#endif // PLATFORM(IOS)
 
-class EmptyTextCheckerClient : public TextCheckerClient {
-public:
-    bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const override { return true; }
-    void ignoreWordInSpellDocument(const String&) override { }
-    void learnWord(const String&) override { }
-    void checkSpellingOfString(StringView, int*, int*) override { }
-    String getAutoCorrectSuggestionForMisspelledWord(const String&) override { return String(); }
-    void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) override { }
-
-#if USE(UNIFIED_TEXT_CHECKING)
-    Vector<TextCheckingResult> checkTextOfParagraph(StringView, TextCheckingTypeMask, const VisibleSelection&) override { return Vector<TextCheckingResult>(); }
+#if ENABLE(ORIENTATION_EVENTS)
+    int deviceOrientation() const final { return 0; }
 #endif
 
-    void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) override { }
-    void requestCheckingOfString(PassRefPtr<TextCheckingRequest>, const VisibleSelection&) override;
-};
-
-class EmptyEditorClient : public EditorClient {
-    WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
-public:
-    EmptyEditorClient() { }
-    virtual ~EmptyEditorClient() { }
-
-    bool shouldDeleteRange(Range*) override { return false; }
-    bool smartInsertDeleteEnabled() override { return false; }
-    bool isSelectTrailingWhitespaceEnabled() override { return false; }
-    bool isContinuousSpellCheckingEnabled() override { return false; }
-    void toggleContinuousSpellChecking() override { }
-    bool isGrammarCheckingEnabled() override { return false; }
-    void toggleGrammarChecking() override { }
-    int spellCheckerDocumentTag() override { return -1; }
-
-
-    bool shouldBeginEditing(Range*) override { return false; }
-    bool shouldEndEditing(Range*) override { return false; }
-    bool shouldInsertNode(Node*, Range*, EditorInsertAction) override { return false; }
-    bool shouldInsertText(const String&, Range*, EditorInsertAction) override { return false; }
-    bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) override { return false; }
-
-    bool shouldApplyStyle(StyleProperties*, Range*) override { return false; }
-    void didApplyStyle() override { }
-    bool shouldMoveRangeAfterDelete(Range*, Range*) override { return false; }
-
-    void didBeginEditing() override { }
-    void respondToChangedContents() override { }
-    void respondToChangedSelection(Frame*) override { }
-    void didChangeSelectionAndUpdateLayout() override { }
-    void updateEditorStateAfterLayoutIfEditabilityChanged() override { }
-    void discardedComposition(Frame*) override { }
-    void canceledComposition() override { }
-    void didEndEditing() override { }
-    void willWriteSelectionToPasteboard(Range*) override { }
-    void didWriteSelectionToPasteboard() override { }
-    void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) override { }
-    void requestCandidatesForSelection(const VisibleSelection&) override { }
-    void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) override { }
-
-    void registerUndoStep(PassRefPtr<UndoStep>) override;
-    void registerRedoStep(PassRefPtr<UndoStep>) override;
-    void clearUndoRedoOperations() override { }
-
-    bool canCopyCut(Frame*, bool defaultValue) const override { return defaultValue; }
-    bool canPaste(Frame*, bool defaultValue) const override { return defaultValue; }
-    bool canUndo() const override { return false; }
-    bool canRedo() const override { return false; }
-
-    void undo() override { }
-    void redo() override { }
-
-    void handleKeyboardEvent(KeyboardEvent*) override { }
-    void handleInputMethodKeydown(KeyboardEvent*) override { }
-
-    void textFieldDidBeginEditing(Element*) override { }
-    void textFieldDidEndEditing(Element*) override { }
-    void textDidChangeInTextField(Element*) override { }
-    bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) override { return false; }
-    void textWillBeDeletedInTextField(Element*) override { }
-    void textDidChangeInTextArea(Element*) override { }
-    void overflowScrollPositionChanged() override { }
-
 #if PLATFORM(IOS)
-    void startDelayingAndCoalescingContentChangeNotifications() override { }
-    void stopDelayingAndCoalescingContentChangeNotifications() override { }
-    void writeDataToPasteboard(NSDictionary*) override { }
-    NSArray* supportedPasteboardTypesForCurrentSelection() override { return nullptr; }
-    NSArray* readDataFromPasteboard(NSString*, int) override { return nullptr; }
-    bool hasRichlyEditableSelection() override { return false; }
-    int getPasteboardItemsCount() override { return 0; }
-    RefPtr<DocumentFragment> documentFragmentFromDelegate(int) override { return nullptr; }
-    bool performsTwoStepPaste(DocumentFragment*) override { return false; }
-    int pasteboardChangeCount() override { return 0; }
-#endif
-
-#if PLATFORM(COCOA)
-    NSString *userVisibleString(NSURL *) override { return nullptr; }
-    void setInsertionPasteboard(const String&) override { };
-    NSURL *canonicalizeURL(NSURL *) override { return nullptr; }
-    NSURL *canonicalizeURLString(NSString *) override { return nullptr; }
-#endif
-
-#if USE(APPKIT)
-    void uppercaseWord() override { }
-    void lowercaseWord() override { }
-    void capitalizeWord() override { }
-#endif
-
-#if USE(AUTOMATIC_TEXT_REPLACEMENT)
-    void showSubstitutionsPanel(bool) override { }
-    bool substitutionsPanelIsShowing() override { return false; }
-    void toggleSmartInsertDelete() override { }
-    bool isAutomaticQuoteSubstitutionEnabled() override { return false; }
-    void toggleAutomaticQuoteSubstitution() override { }
-    bool isAutomaticLinkDetectionEnabled() override { return false; }
-    void toggleAutomaticLinkDetection() override { }
-    bool isAutomaticDashSubstitutionEnabled() override { return false; }
-    void toggleAutomaticDashSubstitution() override { }
-    bool isAutomaticTextReplacementEnabled() override { return false; }
-    void toggleAutomaticTextReplacement() override { }
-    bool isAutomaticSpellingCorrectionEnabled() override { return false; }
-    void toggleAutomaticSpellingCorrection() override { }
-#endif
-
-#if PLATFORM(GTK)
-    bool shouldShowUnicodeMenu() override { return false; }
-#endif
-    TextCheckerClient* textChecker() override { return &m_textCheckerClient; }
-
-    void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) override { }
-    void updateSpellingUIWithMisspelledWord(const String&) override { }
-    void showSpellingUI(bool) override { }
-    bool spellingUIIsShowing() override { return false; }
-
-    void willSetInputMethodState() override { }
-    void setInputMethodState(bool) override { }
-
-private:
-    EmptyTextCheckerClient m_textCheckerClient;
-};
-
-#if ENABLE(CONTEXT_MENUS)
-class EmptyContextMenuClient : public ContextMenuClient {
-    WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
-public:
-    EmptyContextMenuClient() { }
-    virtual ~EmptyContextMenuClient() {  }
-    void contextMenuDestroyed() override { }
-
-    void downloadURL(const URL&) override { }
-    void searchWithGoogle(const Frame*) override { }
-    void lookUpInDictionary(Frame*) override { }
-    bool isSpeaking() override { return false; }
-    void speak(const String&) override { }
-    void stopSpeaking() override { }
-
-#if PLATFORM(COCOA)
-    void searchWithSpotlight() override { }
+    bool isStopping() final { return false; }
 #endif
 
-#if USE(ACCESSIBILITY_CONTEXT_MENUS)
-    void showContextMenu() override { }
-#endif
-};
-#endif // ENABLE(CONTEXT_MENUS)
-
-#if ENABLE(DRAG_SUPPORT)
-class EmptyDragClient : public DragClient {
-    WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
-public:
-    EmptyDragClient() { }
-    virtual ~EmptyDragClient() {}
-    void willPerformDragDestinationAction(DragDestinationAction, const DragData&) override { }
-    void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) override { }
-    DragDestinationAction actionMaskForDrag(const DragData&) override { return DragDestinationActionNone; }
-    DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) override { return DragSourceActionNone; }
-    void startDrag(DragImageRef, const IntPoint&, const IntPoint&, DataTransfer&, Frame&, bool) override { }
-    void dragControllerDestroyed() override { }
-};
-#endif // ENABLE(DRAG_SUPPORT)
-
-class EmptyInspectorClient : public InspectorClient {
-    WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
-public:
-    EmptyInspectorClient() { }
-    virtual ~EmptyInspectorClient() { }
-
-    void inspectedPageDestroyed() override { }
+    void wheelEventHandlersChanged(bool) final { }
     
-    Inspector::FrontendChannel* openLocalFrontend(InspectorController*) override { return nullptr; }
-    void bringFrontendToFront() override { }
-
-    void highlight() override { }
-    void hideHighlight() override { }
-};
-
-class EmptyDeviceClient : public DeviceClient {
-public:
-    void startUpdating() override { }
-    void stopUpdating() override { }
-};
-
-class EmptyDeviceMotionClient : public DeviceMotionClient {
-public:
-    void setController(DeviceMotionController*) override { }
-    DeviceMotionData* lastMotion() const override { return nullptr; }
-    void deviceMotionControllerDestroyed() override { }
-};
-
-class EmptyDeviceOrientationClient : public DeviceOrientationClient {
-public:
-    void setController(DeviceOrientationController*) override { }
-    DeviceOrientationData* lastOrientation() const override { return nullptr; }
-    void deviceOrientationControllerDestroyed() override { }
-};
-
-class EmptyProgressTrackerClient : public ProgressTrackerClient {
-    void willChangeEstimatedProgress() override { }
-    void didChangeEstimatedProgress() override { }
-
-    void progressStarted(Frame&) override { }
-    void progressEstimateChanged(Frame&) override { }
-    void progressFinished(Frame&) override { }
-};
+    bool isEmptyChromeClient() const final { return true; }
 
-class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
-    void logDiagnosticMessage(const String&, const String&, ShouldSample) override { }
-    void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) override { }
-    void logDiagnosticMessageWithValue(const String&, const String&, const String&, ShouldSample) override { }
+    void didAssociateFormControls(const Vector<RefPtr<Element>>&) final { }
+    bool shouldNotifyOnFormChanges() final { return false; }
 };
 
 void fillWithEmptyClients(PageConfiguration&);
+UniqueRef<EditorClient> createEmptyEditorClient();
+DiagnosticLoggingClient& emptyDiagnosticLoggingClient();
 
 }
index 54e4613..a76c791 100644 (file)
@@ -26,7 +26,6 @@
 #pragma once
 
 #include <wtf/RefCounted.h>
-#include <wtf/RefPtr.h>
 
 namespace WebCore {
 
index 06cb62d..48174cb 100644 (file)
@@ -27,7 +27,6 @@
 #include "MainFrame.h"
 
 #include "Element.h"
-#include "EmptyClients.h"
 #include "PageConfiguration.h"
 #include "PageOverlayController.h"
 #include "PaymentCoordinator.h"
index fecbc3b..9331b30 100644 (file)
@@ -83,6 +83,7 @@
 #include "ScrollingCoordinator.h"
 #include "Settings.h"
 #include "SharedBuffer.h"
+#include "SocketProvider.h"
 #include "StorageArea.h"
 #include "StorageNamespace.h"
 #include "StorageNamespaceProvider.h"
@@ -774,10 +775,8 @@ void Page::setInLowQualityImageInterpolationMode(bool mode)
 
 DiagnosticLoggingClient& Page::diagnosticLoggingClient() const
 {
-    static NeverDestroyed<EmptyDiagnosticLoggingClient> dummyClient;
     if (!settings().diagnosticLoggingEnabled() || !m_diagnosticLoggingClient)
-        return dummyClient;
-
+        return emptyDiagnosticLoggingClient();
     return *m_diagnosticLoggingClient;
 }
 
index af9a454..d03dc0e 100644 (file)
@@ -454,7 +454,7 @@ int SQLiteDatabase::authorizerFunction(void* userData, int actionCode, const cha
     }
 }
 
-void SQLiteDatabase::setAuthorizer(PassRefPtr<DatabaseAuthorizer> auth)
+void SQLiteDatabase::setAuthorizer(DatabaseAuthorizer& authorizer)
 {
     if (!m_db) {
         LOG_ERROR("Attempt to set an authorizer on a non-open SQL database");
@@ -464,7 +464,7 @@ void SQLiteDatabase::setAuthorizer(PassRefPtr<DatabaseAuthorizer> auth)
 
     LockHolder locker(m_authorizerLock);
 
-    m_authorizer = auth;
+    m_authorizer = &authorizer;
     
     enableAuthorizer(true);
 }
index bf3361a..ee9ba2b 100644 (file)
@@ -24,8 +24,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef SQLiteDatabase_h
-#define SQLiteDatabase_h
+#pragma once
 
 #include <functional>
 #include <sqlite3.h>
@@ -101,14 +100,15 @@ public:
     WEBCORE_EXPORT int lastError();
     WEBCORE_EXPORT const char* lastErrorMsg();
     
-    sqlite3* sqlite3Handle() const {
+    sqlite3* sqlite3Handle() const
+    {
 #if !PLATFORM(IOS)
         ASSERT(m_sharable || currentThread() == m_openingThread || !m_db);
 #endif
         return m_db;
     }
     
-    void setAuthorizer(PassRefPtr<DatabaseAuthorizer>);
+    void setAuthorizer(DatabaseAuthorizer&);
 
     Lock& databaseMutex() { return m_lockingMutex; }
     bool isAutoCommitOn() const;
@@ -166,5 +166,3 @@ private:
 };
 
 } // namespace WebCore
-
-#endif
index 977dbfd..c9f0f81 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2006, 2007, 2009, 2010 Apple Inc. All right reserved.
+ * Copyright (C) 2003-2017 Apple Inc. All right reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -21,6 +21,7 @@
 
 #include "config.h"
 #include "BidiContext.h"
+
 #include <wtf/Vector.h>
 
 namespace WebCore {
@@ -32,6 +33,15 @@ struct SameSizeAsBidiContext : public RefCounted<SameSizeAsBidiContext> {
 
 COMPILE_ASSERT(sizeof(BidiContext) == sizeof(SameSizeAsBidiContext), BidiContext_should_stay_small);
 
+inline BidiContext::BidiContext(unsigned char level, UCharDirection direction, bool override, BidiEmbeddingSource source, BidiContext* parent)
+    : m_level(level)
+    , m_direction(direction)
+    , m_override(override)
+    , m_source(source)
+    , m_parent(parent)
+{
+}
+
 inline Ref<BidiContext> BidiContext::createUncached(unsigned char level, UCharDirection direction, bool override, BidiEmbeddingSource source, BidiContext* parent)
 {
     return adoptRef(*new BidiContext(level, direction, override, source, parent));
@@ -64,35 +74,31 @@ Ref<BidiContext> BidiContext::create(unsigned char level, UCharDirection directi
     return rtlOverrideContext;
 }
 
-static inline PassRefPtr<BidiContext> copyContextAndRebaselineLevel(BidiContext* context, BidiContext* parent)
+static inline Ref<BidiContext> copyContextAndRebaselineLevel(BidiContext& context, BidiContext* parent)
 {
-    ASSERT(context);
-    unsigned char newLevel = parent ? parent->level() : 0;
-    if (context->dir() == U_RIGHT_TO_LEFT)
+    auto newLevel = parent ? parent->level() : 0;
+    if (context.dir() == U_RIGHT_TO_LEFT)
         newLevel = nextGreaterOddLevel(newLevel);
     else if (parent)
         newLevel = nextGreaterEvenLevel(newLevel);
-
-    return BidiContext::create(newLevel, context->dir(), context->override(), context->source(), parent);
+    return BidiContext::create(newLevel, context.dir(), context.override(), context.source(), parent);
 }
 
 // The BidiContext stack must be immutable -- they're re-used for re-layout after
-// DOM modification/editing -- so we copy all the non-unicode contexts, and
+// DOM modification/editing -- so we copy all the non-Unicode contexts, and
 // recalculate their levels.
-PassRefPtr<BidiContext> BidiContext::copyStackRemovingUnicodeEmbeddingContexts()
+Ref<BidiContext> BidiContext::copyStackRemovingUnicodeEmbeddingContexts()
 {
     Vector<BidiContext*, 64> contexts;
-    for (BidiContext* iter = this; iter; iter = iter->parent()) {
-        if (iter->source() != FromUnicode)
-            contexts.append(iter);
+    for (auto* ancestor = this; ancestor; ancestor = ancestor->parent()) {
+        if (ancestor->source() != FromUnicode)
+            contexts.append(ancestor);
     }
     ASSERT(contexts.size());
-    RefPtr<BidiContext> topContext = copyContextAndRebaselineLevel(contexts.last(), 0);
-    for (int i = contexts.size() - 1; i > 0; --i)
-        topContext = copyContextAndRebaselineLevel(contexts[i - 1], topContext.get());
-
-    return WTFMove(topContext);
+    auto topContext = copyContextAndRebaselineLevel(*contexts.last(), nullptr);
+    for (unsigned i = contexts.size() - 1; i; --i)
+        topContext = copyContextAndRebaselineLevel(*contexts[i - 1], topContext.ptr());
+    return topContext;
 }
 
 bool operator==(const BidiContext& c1, const BidiContext& c2)
index 60b1188..d4c4e57 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2006, 2007, 2009, 2010 Apple Inc. All right reserved.
+ * Copyright (C) 2003-2017 Apple Inc. All right reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  */
 
-#ifndef BidiContext_h
-#define BidiContext_h
+#pragma once
 
 #include <unicode/uchar.h>
-#include <wtf/Assertions.h>
-#include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 
 namespace WebCore {
 
-enum BidiEmbeddingSource {
-    FromStyleOrDOM,
-    FromUnicode
-};
+enum BidiEmbeddingSource { FromStyleOrDOM, FromUnicode };
 
 // Used to keep track of explicit embeddings.
 class BidiContext : public RefCounted<BidiContext> {
 public:
-    WEBCORE_EXPORT static Ref<BidiContext> create(unsigned char level, UCharDirection, bool override = false, BidiEmbeddingSource = FromStyleOrDOM, BidiContext* parent = 0);
+    WEBCORE_EXPORT static Ref<BidiContext> create(unsigned char level, UCharDirection, bool override = false, BidiEmbeddingSource = FromStyleOrDOM, BidiContext* parent = nullptr);
 
     BidiContext* parent() const { return m_parent.get(); }
     unsigned char level() const { return m_level; }
@@ -46,16 +40,10 @@ public:
     bool override() const { return m_override; }
     BidiEmbeddingSource source() const { return static_cast<BidiEmbeddingSource>(m_source); }
 
-    WEBCORE_EXPORT PassRefPtr<BidiContext> copyStackRemovingUnicodeEmbeddingContexts();
+    WEBCORE_EXPORT Ref<BidiContext> copyStackRemovingUnicodeEmbeddingContexts();
+
 private:
-    BidiContext(unsigned char level, UCharDirection direction, bool override, BidiEmbeddingSource source, BidiContext* parent)
-        : m_level(level)
-        , m_direction(direction)
-        , m_override(override)
-        , m_source(source)
-        , m_parent(parent)
-    {
-    }
+    BidiContext(unsigned char level, UCharDirection, bool override, BidiEmbeddingSource, BidiContext* parent);
 
     static Ref<BidiContext> createUncached(unsigned char level, UCharDirection, bool override, BidiEmbeddingSource, BidiContext* parent);
 
@@ -79,5 +67,3 @@ inline unsigned char nextGreaterEvenLevel(unsigned char level)
 bool operator==(const BidiContext&, const BidiContext&);
 
 } // namespace WebCore
-
-#endif // BidiContext_h
index 49cfd23..1b13ef3 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2016 Apple Inc.  All right reserved.
+ * Copyright (C) 2003-2017 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  */
 
-#ifndef BidiResolver_h
-#define BidiResolver_h
+#pragma once
 
 #include "BidiContext.h"
 #include "BidiRunList.h"
 #include "WritingMode.h"
 #include <wtf/HashMap.h>
 #include <wtf/Noncopyable.h>
-#include <wtf/PassRefPtr.h>
 #include <wtf/Vector.h>
 
 namespace WebCore {
 
 class RenderObject;
 
-template <class Iterator> class WhitespaceCollapsingState {
+template<typename Iterator> class WhitespaceCollapsingState {
 public:
     void reset()
     {
@@ -83,49 +81,41 @@ private:
 // The BidiStatus at a given position (typically the end of a line) can
 // be cached and then used to restart bidi resolution at that position.
 struct BidiStatus {
-    BidiStatus()
-        : eor(U_OTHER_NEUTRAL)
-        , lastStrong(U_OTHER_NEUTRAL)
-        , last(U_OTHER_NEUTRAL)
-    {
-    }
+    BidiStatus() = default;
 
     // Creates a BidiStatus representing a new paragraph root with a default direction.
     // Uses TextDirection as it only has two possibilities instead of UCharDirection which has at least 19.
-    BidiStatus(TextDirection textDirection, bool isOverride)
+    BidiStatus(TextDirection direction, bool isOverride)
+        : eor(direction == LTR ? U_LEFT_TO_RIGHT : U_RIGHT_TO_LEFT)
+        , lastStrong(eor)
+        , last(eor)
+        , context(BidiContext::create(direction == LTR ? 0 : 1, eor, isOverride))
     {
-        UCharDirection direction = textDirection == LTR ? U_LEFT_TO_RIGHT : U_RIGHT_TO_LEFT;
-        eor = lastStrong = last = direction;
-        context = BidiContext::create(textDirection == LTR ? 0 : 1, direction, isOverride);
     }
 
-    BidiStatus(UCharDirection eorDir, UCharDirection lastStrongDir, UCharDirection lastDir, PassRefPtr<BidiContext> bidiContext)
-        : eor(eorDir)
-        , lastStrong(lastStrongDir)
-        , last(lastDir)
-        , context(bidiContext)
+    BidiStatus(UCharDirection eor, UCharDirection lastStrong, UCharDirection last, RefPtr<BidiContext>&& context)
+        : eor(eor)
+        , lastStrong(lastStrong)
+        , last(last)
+        , context(WTFMove(context))
     {
     }
 
-    UCharDirection eor;
-    UCharDirection lastStrong;
-    UCharDirection last;
+    UCharDirection eor { U_OTHER_NEUTRAL };
+    UCharDirection lastStrong { U_OTHER_NEUTRAL };
+    UCharDirection last { U_OTHER_NEUTRAL };
     RefPtr<BidiContext> context;
 };
 
-class BidiEmbedding {
-public:
+struct BidiEmbedding {
     BidiEmbedding(UCharDirection direction, BidiEmbeddingSource source)
-    : m_direction(direction)
-    , m_source(source)
+        : direction(direction)
+        , source(source)
     {
     }
 
-    UCharDirection direction() const { return m_direction; }
-    BidiEmbeddingSource source() const { return m_source; }
-private:
-    UCharDirection m_direction;
-    BidiEmbeddingSource m_source;
+    UCharDirection direction;
+    BidiEmbeddingSource source;
 };
 
 inline bool operator==(const BidiStatus& status1, const BidiStatus& status2)
@@ -200,17 +190,9 @@ enum VisualDirectionOverride {
 
 // BidiResolver is WebKit's implementation of the Unicode Bidi Algorithm
 // http://unicode.org/reports/tr9
-template <class Iterator, class Run, class Subclass> class BidiResolverBase {
+template<typename Iterator, typename Run, typename DerivedClass> class BidiResolverBase {
     WTF_MAKE_NONCOPYABLE(BidiResolverBase);
 public:
-    BidiResolverBase()
-        : m_direction(U_OTHER_NEUTRAL)
-        , m_reachedEndOfLine(false)
-        , m_emptyRun(true)
-        , m_nestedIsolateCount(0)
-    {
-    }
-
     const Iterator& position() const { return m_current; }
     void setPositionIgnoringNestedIsolates(const Iterator& position) { m_current = position; }
     void setPosition(const Iterator& position, unsigned nestedIsolatedCount)
@@ -219,20 +201,20 @@ public:
         m_nestedIsolateCount = nestedIsolatedCount;
     }
 
-    void increment() { static_cast<Subclass*>(this)->incrementInternal(); }
+    void increment() { static_cast<DerivedClass&>(*this).incrementInternal(); }
 
     BidiContext* context() const { return m_status.context.get(); }
-    void setContext(PassRefPtr<BidiContext> c) { m_status.context = c; }
+    void setContext(RefPtr<BidiContext>&& context) { m_status.context = WTFMove(context); }
 
     void setLastDir(UCharDirection lastDir) { m_status.last = lastDir; }
     void setLastStrongDir(UCharDirection lastStrongDir) { m_status.lastStrong = lastStrongDir; }
     void setEorDir(UCharDirection eorDir) { m_status.eor = eorDir; }
 
     UCharDirection dir() const { return m_direction; }
-    void setDir(UCharDirection d) { m_direction = d; }
+    void setDir(UCharDirection direction) { m_direction = direction; }
 
     const BidiStatus& status() const { return m_status; }
-    void setStatus(const BidiStatus s) { m_status = s; }
+    void setStatus(BidiStatus status) { m_status = status; }
 
     WhitespaceCollapsingState<Iterator>& whitespaceCollapsingState() { return m_whitespaceCollapsingState; }
 
@@ -258,9 +240,11 @@ public:
     unsigned whitespaceCollapsingTransitionForIsolatedRun(Run&);
 
 protected:
+    BidiResolverBase() = default;
+
     // FIXME: Instead of InlineBidiResolvers subclassing this method, we should
     // pass in some sort of Traits object which knows how to create runs for appending.
-    void appendRun() { static_cast<Subclass*>(this)->appendRunInternal(); }
+    void appendRun() { static_cast<DerivedClass&>(*this).appendRunInternal(); }
 
     Iterator m_current;
     // sor and eor are "start of run" and "end of run" respectively and correpond
@@ -269,11 +253,11 @@ protected:
     Iterator m_eor; // Points to the last character in the current run.
     Iterator m_last;
     BidiStatus m_status;
-    UCharDirection m_direction;
+    UCharDirection m_direction { U_OTHER_NEUTRAL };
     Iterator endOfLine;
-    bool m_reachedEndOfLine;
+    bool m_reachedEndOfLine { false };
     Iterator m_lastBeforeET; // Before a U_EUROPEAN_NUMBER_TERMINATOR
-    bool m_emptyRun;
+    bool m_emptyRun { true };
 
     // FIXME: This should not belong to the resolver, but rather be passed
     // into createBidiRunsForLine by the caller.
@@ -281,7 +265,7 @@ protected:
 
     WhitespaceCollapsingState<Iterator> m_whitespaceCollapsingState;
 
-    unsigned m_nestedIsolateCount;
+    unsigned m_nestedIsolateCount { 0 };
     HashMap<Run*, unsigned> m_whitespaceCollapsingTransitionForIsolatedRun;
 
 private:
@@ -297,16 +281,14 @@ private:
     Vector<BidiEmbedding, 8> m_currentExplicitEmbeddingSequence;
 };
 
-template <class Iterator, class Run>
+template<typename Iterator, typename Run>
 class BidiResolver : public BidiResolverBase<Iterator, Run, BidiResolver<Iterator, Run>> {
 };
 
-template <class Iterator, class Run, class IsolateRun>
+template<typename Iterator, typename Run, typename IsolateRun>
 class BidiResolverWithIsolate : public BidiResolverBase<Iterator, Run, BidiResolverWithIsolate<Iterator, Run, IsolateRun>> {
 public:
-#ifndef NDEBUG
     ~BidiResolverWithIsolate();
-#endif
 
     void incrementInternal();
     void appendRunInternal();
@@ -316,17 +298,15 @@ private:
     Vector<IsolateRun> m_isolatedRuns;
 };
 
-#ifndef NDEBUG
-template <class Iterator, class Run, class IsolateRun>
-BidiResolverWithIsolate<Iterator, Run, IsolateRun>::~BidiResolverWithIsolate()
+template<typename Iterator, typename Run, typename IsolateRun>
+inline BidiResolverWithIsolate<Iterator, Run, IsolateRun>::~BidiResolverWithIsolate()
 {
     // The owner of this resolver should have handled the isolated runs.
     ASSERT(m_isolatedRuns.isEmpty());
 }
-#endif
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::appendRunInternal()
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::appendRunInternal()
 {
     if (!m_emptyRun && !m_eor.atEnd()) {
         unsigned startOffset = m_sor.offset();
@@ -348,8 +328,8 @@ void BidiResolverBase<Iterator, Run, Subclass>::appendRunInternal()
     m_status.eor = U_OTHER_NEUTRAL;
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::embed(UCharDirection dir, BidiEmbeddingSource source)
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::embed(UCharDirection dir, BidiEmbeddingSource source)
 {
     // Isolated spans compute base directionality during their own UBA run.
     // Do not insert fake embed characters once we enter an isolated span.
@@ -359,8 +339,8 @@ void BidiResolverBase<Iterator, Run, Subclass>::embed(UCharDirection dir, BidiEm
     m_currentExplicitEmbeddingSequence.append(BidiEmbedding(dir, source));
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::checkDirectionInLowerRaiseEmbeddingLevel()
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::checkDirectionInLowerRaiseEmbeddingLevel()
 {
     ASSERT(m_status.eor != U_OTHER_NEUTRAL || m_eor.atEnd());
     ASSERT(m_status.last != U_DIR_NON_SPACING_MARK
@@ -374,8 +354,8 @@ void BidiResolverBase<Iterator, Run, Subclass>::checkDirectionInLowerRaiseEmbedd
         m_direction = m_status.lastStrong == U_LEFT_TO_RIGHT ? U_LEFT_TO_RIGHT : U_RIGHT_TO_LEFT;
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::lowerExplicitEmbeddingLevel(UCharDirection from)
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::lowerExplicitEmbeddingLevel(UCharDirection from)
 {
     if (!m_emptyRun && m_eor != m_last) {
         checkDirectionInLowerRaiseEmbeddingLevel();
@@ -410,8 +390,8 @@ void BidiResolverBase<Iterator, Run, Subclass>::lowerExplicitEmbeddingLevel(UCha
     m_eor = Iterator();
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::raiseExplicitEmbeddingLevel(UCharDirection from, UCharDirection to)
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::raiseExplicitEmbeddingLevel(UCharDirection from, UCharDirection to)
 {
     if (!m_emptyRun && m_eor != m_last) {
         checkDirectionInLowerRaiseEmbeddingLevel();
@@ -447,51 +427,50 @@ void BidiResolverBase<Iterator, Run, Subclass>::raiseExplicitEmbeddingLevel(UCha
     m_eor = Iterator();
 }
 
-template <class Iterator, class Run, class Subclass>
-bool BidiResolverBase<Iterator, Run, Subclass>::commitExplicitEmbedding()
+template<typename Iterator, typename Run, typename DerivedClass>
+bool BidiResolverBase<Iterator, Run, DerivedClass>::commitExplicitEmbedding()
 {
     // When we're "inIsolate()" we're resolving the parent context which
     // ignores (skips over) the isolated content, including embedding levels.
     // We should never accrue embedding levels while skipping over isolated content.
     ASSERT(!inIsolate() || m_currentExplicitEmbeddingSequence.isEmpty());
 
-    unsigned char fromLevel = context()->level();
+    auto fromLevel = context()->level();
     RefPtr<BidiContext> toContext = context();
 
-    for (size_t i = 0; i < m_currentExplicitEmbeddingSequence.size(); ++i) {
-        BidiEmbedding embedding = m_currentExplicitEmbeddingSequence[i];
-        if (embedding.direction() == U_POP_DIRECTIONAL_FORMAT) {
-            if (BidiContext* parentContext = toContext->parent())
+    for (auto& embedding : m_currentExplicitEmbeddingSequence) {
+        if (embedding.direction == U_POP_DIRECTIONAL_FORMAT) {
+            if (auto* parentContext = toContext->parent())
                 toContext = parentContext;
         } else {
-            UCharDirection direction = (embedding.direction() == U_RIGHT_TO_LEFT_EMBEDDING || embedding.direction() == U_RIGHT_TO_LEFT_OVERRIDE) ? U_RIGHT_TO_LEFT : U_LEFT_TO_RIGHT;
-            bool override = embedding.direction() == U_LEFT_TO_RIGHT_OVERRIDE || embedding.direction() == U_RIGHT_TO_LEFT_OVERRIDE;
+            UCharDirection direction = (embedding.direction == U_RIGHT_TO_LEFT_EMBEDDING || embedding.direction == U_RIGHT_TO_LEFT_OVERRIDE) ? U_RIGHT_TO_LEFT : U_LEFT_TO_RIGHT;
+            bool override = embedding.direction == U_LEFT_TO_RIGHT_OVERRIDE || embedding.direction == U_RIGHT_TO_LEFT_OVERRIDE;
             unsigned char level = toContext->level();
             if (direction == U_RIGHT_TO_LEFT)
                 level = nextGreaterOddLevel(level);
             else
                 level = nextGreaterEvenLevel(level);
             if (level < 61)
-                toContext = BidiContext::create(level, direction, override, embedding.source(), toContext.get());
+                toContext = BidiContext::create(level, direction, override, embedding.source, toContext.get());
         }
     }
 
-    unsigned char toLevel = toContext->level();
+    auto toLevel = toContext->level();
 
     if (toLevel > fromLevel)
         raiseExplicitEmbeddingLevel(fromLevel % 2 ? U_RIGHT_TO_LEFT : U_LEFT_TO_RIGHT, toLevel % 2 ? U_RIGHT_TO_LEFT : U_LEFT_TO_RIGHT);
     else if (toLevel < fromLevel)
         lowerExplicitEmbeddingLevel(fromLevel % 2 ? U_RIGHT_TO_LEFT : U_LEFT_TO_RIGHT);
 
-    setContext(toContext);
+    setContext(WTFMove(toContext));
 
     m_currentExplicitEmbeddingSequence.clear();
 
     return fromLevel != toLevel;
 }
 
-template <class Iterator, class Run, class Subclass>
-inline void BidiResolverBase<Iterator, Run, Subclass>::updateStatusLastFromCurrentDirection(UCharDirection dirCurrent)
+template<typename Iterator, typename Run, typename DerivedClass>
+inline void BidiResolverBase<Iterator, Run, DerivedClass>::updateStatusLastFromCurrentDirection(UCharDirection dirCurrent)
 {
     switch (dirCurrent) {
     case U_EUROPEAN_NUMBER_TERMINATOR:
@@ -531,8 +510,8 @@ inline void BidiResolverBase<Iterator, Run, Subclass>::updateStatusLastFromCurre
     }
 }
 
-template <class Iterator, class Run, class Subclass>
-inline void BidiResolverBase<Iterator, Run, Subclass>::reorderRunsFromLevels()
+template<typename Iterator, typename Run, typename DerivedClass>
+inline void BidiResolverBase<Iterator, Run, DerivedClass>::reorderRunsFromLevels()
 {
     unsigned char levelLow = 128;
     unsigned char levelHigh = 0;
@@ -568,8 +547,8 @@ inline void BidiResolverBase<Iterator, Run, Subclass>::reorderRunsFromLevels()
     }
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak)
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak)
 {
     ASSERT(m_direction == U_OTHER_NEUTRAL);
 
@@ -595,7 +574,7 @@ void BidiResolverBase<Iterator, Run, Subclass>::createBidiRunsForLine(const Iter
 
     m_last = m_current;
     bool pastEnd = false;
-    BidiResolverBase<Iterator, Run, Subclass> stateAtEnd;
+    BidiResolverBase<Iterator, Run, DerivedClass> stateAtEnd;
 
     while (true) {
         UCharDirection dirCurrent;
@@ -975,19 +954,17 @@ void BidiResolverBase<Iterator, Run, Subclass>::createBidiRunsForLine(const Iter
     endOfLine = Iterator();
 }
 
-template <class Iterator, class Run, class Subclass>
-void BidiResolverBase<Iterator, Run, Subclass>::setWhitespaceCollapsingTransitionForIsolatedRun(Run& run, size_t transition)
+template<typename Iterator, typename Run, typename DerivedClass>
+void BidiResolverBase<Iterator, Run, DerivedClass>::setWhitespaceCollapsingTransitionForIsolatedRun(Run& run, size_t transition)
 {
     ASSERT(!m_whitespaceCollapsingTransitionForIsolatedRun.contains(&run));
     m_whitespaceCollapsingTransitionForIsolatedRun.add(&run, transition);
 }
 
-template<class Iterator, class Run, class Subclass>
-unsigned BidiResolverBase<Iterator, Run, Subclass>::whitespaceCollapsingTransitionForIsolatedRun(Run& run)
+template<typename Iterator, typename Run, typename DerivedClass>
+unsigned BidiResolverBase<Iterator, Run, DerivedClass>::whitespaceCollapsingTransitionForIsolatedRun(Run& run)
 {
     return m_whitespaceCollapsingTransitionForIsolatedRun.take(&run);
 }
 
 } // namespace WebCore
-
-#endif // BidiResolver_h
index ec45870..39e3211 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TextCheckerClient_h
-#define TextCheckerClient_h
+#pragma once
 
 #include "TextChecking.h"
 
-#include <wtf/Forward.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/Vector.h>
-#include <wtf/text/WTFString.h>
-
 namespace WebCore {
 
 class VisibleSelection;
 
 class TextCheckerClient {
 public:
-    virtual ~TextCheckerClient() {}
+    virtual ~TextCheckerClient() { }
 
     virtual bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const = 0;
     virtual void ignoreWordInSpellDocument(const String&) = 0;
@@ -58,9 +52,7 @@ public:
     // provide more accurate correction suggestions. Caller can pass in more text in "context" to aid such spellcheckers on language
     // identification. Noramlly it's the text surrounding the "word" for which we are getting correction suggestions.
     virtual void getGuessesForWord(const String& word, const String& context, const VisibleSelection& currentSelection, Vector<String>& guesses) = 0;
-    virtual void requestCheckingOfString(PassRefPtr<TextCheckingRequest>, const VisibleSelection& currentSelection) = 0;
+    virtual void requestCheckingOfString(TextCheckingRequest&, const VisibleSelection& currentSelection) = 0;
 };
 
 }
-
-#endif // TextCheckerClient_h
index 4bfe932..a349c38 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef TextEncoding_h
-#define TextEncoding_h
+#pragma once
 
 #include "TextCodec.h"
 #include <wtf/Forward.h>
 
 namespace WebCore {
 
-    class TextEncoding {
-    public:
-        TextEncoding() : m_name(0) { }
-        TextEncoding(const char* name);
-        WEBCORE_EXPORT TextEncoding(const String& name);
+class TextEncoding {
+public:
+    TextEncoding() = default;
+    TextEncoding(const char* name);
+    WEBCORE_EXPORT TextEncoding(const String& name);
 
-        bool isValid() const { return m_name; }
-        const char* name() const { return m_name; }
-        WEBCORE_EXPORT const char* domName() const; // name exposed via DOM
-        bool usesVisualOrdering() const;
-        bool isJapanese() const;
-        
-        PassRefPtr<StringImpl> displayString(PassRefPtr<StringImpl> str) const
-        {
-            if (m_backslashAsCurrencySymbol == '\\' || !str)
-                return str;
-            return str->replace('\\', m_backslashAsCurrencySymbol);
-        }
-        template <typename CharacterType>
-        void displayBuffer(CharacterType* characters, unsigned len) const
-        {
-            if (m_backslashAsCurrencySymbol == '\\')
-                return;
-            for (unsigned i = 0; i < len; ++i) {
-                if (characters[i] == '\\')
-                    characters[i] = m_backslashAsCurrencySymbol;
-            }
-        }
+    bool isValid() const { return m_name; }
+    const char* name() const { return m_name; }
+    WEBCORE_EXPORT const char* domName() const; // name exposed via DOM
+    bool usesVisualOrdering() const;
+    bool isJapanese() const;
 
-        const TextEncoding& closestByteBasedEquivalent() const;
-        const TextEncoding& encodingForFormSubmission() const;
+    const TextEncoding& closestByteBasedEquivalent() const;
+    const TextEncoding& encodingForFormSubmission() const;
 
-        String decode(const char* str, size_t length) const
-        {
-            bool ignored;
-            return decode(str, length, false, ignored);
-        }
-        WEBCORE_EXPORT String decode(const char*, size_t length, bool stopOnError, bool& sawError) const;
-        CString encode(StringView, UnencodableHandling) const;
+    WEBCORE_EXPORT String decode(const char*, size_t length, bool stopOnError, bool& sawError) const;
+    String decode(const char*, size_t length) const;
+    CString encode(StringView, UnencodableHandling) const;
 
-        UChar backslashAsCurrencySymbol() const;
-        bool isByteBasedEncoding() const { return !isNonByteBasedEncoding(); }
+    UChar backslashAsCurrencySymbol() const;
+    bool isByteBasedEncoding() const { return !isNonByteBasedEncoding(); }
 
-    private:
-        bool isNonByteBasedEncoding() const;
-        bool isUTF7Encoding() const;
+private:
+    bool isNonByteBasedEncoding() const;
+    bool isUTF7Encoding() const;
 
-        const char* m_name;
-        UChar m_backslashAsCurrencySymbol;
-    };
+    const char* m_name { nullptr };
+    UChar m_backslashAsCurrencySymbol;
+};
 
-    inline bool operator==(const TextEncoding& a, const TextEncoding& b) { return a.name() == b.name(); }
-    inline bool operator!=(const TextEncoding& a, const TextEncoding& b) { return a.name() != b.name(); }
+inline bool operator==(const TextEncoding& a, const TextEncoding& b) { return a.name() == b.name(); }
+inline bool operator!=(const TextEncoding& a, const TextEncoding& b) { return a.name() != b.name(); }
 
-    const TextEncoding& ASCIIEncoding();
-    const TextEncoding& Latin1Encoding();
-    const TextEncoding& UTF16BigEndianEncoding();
-    const TextEncoding& UTF16LittleEndianEncoding();
-    const TextEncoding& UTF32BigEndianEncoding();
-    const TextEncoding& UTF32LittleEndianEncoding();
-    WEBCORE_EXPORT const TextEncoding& UTF8Encoding();
-    WEBCORE_EXPORT const TextEncoding& WindowsLatin1Encoding();
+const TextEncoding& ASCIIEncoding();
+const TextEncoding& Latin1Encoding();
+const TextEncoding& UTF16BigEndianEncoding();
+const TextEncoding& UTF16LittleEndianEncoding();
+const TextEncoding& UTF32BigEndianEncoding();
+const TextEncoding& UTF32LittleEndianEncoding();
+WEBCORE_EXPORT const TextEncoding& UTF8Encoding();
+WEBCORE_EXPORT const TextEncoding& WindowsLatin1Encoding();
 
-} // namespace WebCore
+inline String TextEncoding::decode(const char* characters, size_t length) const
+{
+    bool ignored;
+    return decode(characters, length, false, ignored);
+}
 
-#endif // TextEncoding_h
+} // namespace WebCore
index 06d9142..d7dec73 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2003-2017 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -50,7 +50,7 @@ struct SameSizeAsRootInlineBox : public InlineFlowBox {
 COMPILE_ASSERT(sizeof(RootInlineBox) == sizeof(SameSizeAsRootInlineBox), RootInlineBox_should_stay_small);
 
 typedef WTF::HashMap<const RootInlineBox*, std::unique_ptr<EllipsisBox>> EllipsisBoxMap;
-static EllipsisBoxMap* gEllipsisBoxMap = 0;
+static EllipsisBoxMap* gEllipsisBoxMap;
 
 static ContainingRegionMap& containingRegionMap(RenderBlockFlow& block)
 {
@@ -208,10 +208,10 @@ void RootInlineBox::adjustPosition(float dx, float dy)
 void RootInlineBox::childRemoved(InlineBox* box)
 {
     if (&box->renderer() == m_lineBreakObj)
-        setLineBreakInfo(0, 0, BidiStatus());
+        setLineBreakInfo(nullptr, 0, BidiStatus());
 
     for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == &box->renderer(); prev = prev->prevRootBox()) {
-        prev->setLineBreakInfo(0, 0, BidiStatus());
+        prev->setLineBreakInfo(nullptr, 0, BidiStatus());
         prev->markDirty();
     }
 }
@@ -566,22 +566,20 @@ RenderObject::SelectionState RootInlineBox::selectionState()
 
 InlineBox* RootInlineBox::firstSelectedBox()
 {
-    for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
+    for (auto* box = firstLeafChild(); box; box = box->nextLeafChild()) {
         if (box->selectionState() != RenderObject::SelectionNone)
             return box;
     }
-
-    return 0;
+    return nullptr;
 }
 
 InlineBox* RootInlineBox::lastSelectedBox()
 {
-    for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
+    for (auto* box = lastLeafChild(); box; box = box->prevLeafChild()) {
         if (box->selectionState() != RenderObject::SelectionNone)
             return box;
     }
-
-    return 0;
+    return nullptr;
 }
 
 LayoutUnit RootInlineBox::selectionTop() const
@@ -805,7 +803,7 @@ InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(int leftPositio
         // Return it.
         return lastLeaf;
 
-    InlineBox* closestLeaf = 0;
+    InlineBox* closestLeaf = nullptr;
     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
         if (!leaf->renderer().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
             closestLeaf = leaf;
@@ -821,13 +819,13 @@ InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(int leftPositio
 
 BidiStatus RootInlineBox::lineBreakBidiStatus() const
 { 
-    return BidiStatus(static_cast<UCharDirection>(m_lineBreakBidiStatusEor), static_cast<UCharDirection>(m_lineBreakBidiStatusLastStrong), static_cast<UCharDirection>(m_lineBreakBidiStatusLast), m_lineBreakContext);
+    return { static_cast<UCharDirection>(m_lineBreakBidiStatusEor), static_cast<UCharDirection>(m_lineBreakBidiStatusLastStrong), static_cast<UCharDirection>(m_lineBreakBidiStatusLast), m_lineBreakContext.copyRef() };
 }
 
-void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status)
+void RootInlineBox::setLineBreakInfo(RenderObject* object, unsigned breakPosition, const BidiStatus& status)
 {
-    m_lineBreakObj = obj;
-    m_lineBreakPos = breakPos;
+    m_lineBreakObj = object;
+    m_lineBreakPos = breakPosition;
     m_lineBreakBidiStatusEor = status.eor;
     m_lineBreakBidiStatusLastStrong = status.lastStrong;
     m_lineBreakBidiStatusLast = status.last;
@@ -837,7 +835,7 @@ void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const
 EllipsisBox* RootInlineBox::ellipsisBox() const
 {
     if (!hasEllipsisBox())
-        return 0;
+        return nullptr;
     return gEllipsisBoxMap->get(this);
 }
 
@@ -936,8 +934,8 @@ void RootInlineBox::ascentAndDescentForBox(InlineBox& box, GlyphOverflowAndFallb
     const RenderStyle& boxLineStyle = box.lineStyle();
     if (usedFonts && !usedFonts->isEmpty() && (includeFont || (boxLineStyle.lineHeight().isNegative() && includeLeading))) {
         usedFonts->append(&boxLineStyle.fontCascade().primaryFont());
-        for (size_t i = 0; i < usedFonts->size(); ++i) {
-            const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();
+        for (auto& font : *usedFonts) {
+            auto& fontMetrics = font->fontMetrics();
             int usedFontAscent = fontMetrics.ascent(baselineType());
             int usedFontDescent = fontMetrics.descent(baselineType());
             int halfLeading = (fontMetrics.lineSpacing() - fontMetrics.height()) / 2;
index b341d6c..14115a1 100644 (file)
@@ -32,6 +32,7 @@
 #include "CommonVM.h"
 #include "DOMWindow.h"
 #include "DocumentLoader.h"
+#include "EditorClient.h"
 #include "ElementIterator.h"
 #include "FrameLoader.h"
 #include "FrameView.h"
@@ -51,6 +52,7 @@
 #include "SVGImageElement.h"
 #include "SVGSVGElement.h"
 #include "Settings.h"
+#include "SocketProvider.h"
 #include "TextStream.h"
 #include <runtime/JSCInlines.h>
 #include <runtime/JSLock.h>
@@ -412,7 +414,7 @@ bool SVGImage::dataChanged(bool allDataReceived)
         return true;
 
     if (allDataReceived) {
-        PageConfiguration pageConfiguration(makeUniqueRef<EmptyEditorClient>(), SocketProvider::create());
+        PageConfiguration pageConfiguration(createEmptyEditorClient(), SocketProvider::create());
         fillWithEmptyClients(pageConfiguration);
         m_chromeClient = std::make_unique<SVGImageChromeClient>(this);
         pageConfiguration.chromeClient = m_chromeClient.get();
index 5f14a1d..8a065f1 100644 (file)
@@ -1,3 +1,15 @@
+2017-01-06  Darin Adler  <darin@apple.com>
+
+        Remove PassRefPtr use from "inspector", "platform/sql", and "platform/text"
+        https://bugs.webkit.org/show_bug.cgi?id=166797
+
+        Reviewed by Alex Christensen.
+
+        * WebCoreSupport/WebEditorClient.h: Updated to take a reference.
+        * WebCoreSupport/WebEditorClient.mm:
+        (WebEditorClient::requestCheckingOfString): Take a reference
+        instead of a PassRefPtr.
+
 2017-01-05  Chris Dumez  <cdumez@apple.com>
 
         Turn preferLowPowerWebGLRendering setting on by default
index 12eee2b..3b35d4d 100644 (file)
@@ -166,7 +166,7 @@ private:
 
     void willSetInputMethodState() final;
     void setInputMethodState(bool enabled) final;
-    void requestCheckingOfString(PassRefPtr<WebCore::TextCheckingRequest>, const WebCore::VisibleSelection& currentSelection) final;
+    void requestCheckingOfString(WebCore::TextCheckingRequest&, const WebCore::VisibleSelection& currentSelection) final;
 
 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
     void requestCandidatesForSelection(const WebCore::VisibleSelection&) final;
index d86f38c..7f9f417 100644 (file)
@@ -1323,11 +1323,11 @@ void WebEditorClient::didCheckSucceed(int sequence, NSArray* results)
 
 #endif
 
-void WebEditorClient::requestCheckingOfString(PassRefPtr<WebCore::TextCheckingRequest> request, const VisibleSelection& currentSelection)
+void WebEditorClient::requestCheckingOfString(WebCore::TextCheckingRequest& request, const VisibleSelection& currentSelection)
 {
 #if !PLATFORM(IOS)
     ASSERT(!m_textCheckingRequest);
-    m_textCheckingRequest = request;
+    m_textCheckingRequest = &request;
 
     int sequence = m_textCheckingRequest->data().sequence();
     NSRange range = NSMakeRange(0, m_textCheckingRequest->data().text().length());
index ec45b2e..6d0a730 100644 (file)
@@ -1,3 +1,13 @@
+2017-01-06  Darin Adler  <darin@apple.com>
+
+        Remove PassRefPtr use from "inspector", "platform/sql", and "platform/text"
+        https://bugs.webkit.org/show_bug.cgi?id=166797
+
+        Reviewed by Alex Christensen.
+
+        * WebCoreSupport/WebEditorClient.h: Update argument to take a reference
+        instead of a PassRefPtr.
+
 2017-01-05  Andreas Kling  <akling@apple.com>
 
         Remove ChromeClient::needTouchEvents().
index 594c48d..b148be7 100644 (file)
@@ -113,7 +113,7 @@ public:
 
     void willSetInputMethodState() override;
     void setInputMethodState(bool) override;
-    void requestCheckingOfString(WTF::PassRefPtr<WebCore::TextCheckingRequest>, const WebCore::VisibleSelection&) override { }
+    void requestCheckingOfString(WebCore::TextCheckingRequest&, const WebCore::VisibleSelection&) override { }
 
     WebCore::TextCheckerClient* textChecker() override { return this; }
 
index d177a99..c405b5e 100644 (file)
@@ -1,3 +1,15 @@
+2017-01-06  Darin Adler  <darin@apple.com>
+
+        Remove PassRefPtr use from "inspector", "platform/sql", and "platform/text"
+        https://bugs.webkit.org/show_bug.cgi?id=166797
+
+        Reviewed by Alex Christensen.
+
+        * WebProcess/WebCoreSupport/WebEditorClient.cpp:
+        (WebKit::WebEditorClient::requestCheckingOfString): Take a reference
+        instead of a PassRefPtr.
+        * WebProcess/WebCoreSupport/WebEditorClient.h: Updated for above change.
+
 2017-01-07  Andy Estes  <aestes@apple.com>
 
         [QuickLook] Consolidate usage of QuickLookHandle into SubresourceLoader
index 2212acd..54b27b4 100644 (file)
@@ -526,14 +526,12 @@ void WebEditorClient::getGuessesForWord(const String& word, const String& contex
     m_page->sendSync(Messages::WebPageProxy::GetGuessesForWord(word, context, insertionPointFromCurrentSelection(currentSelection)), Messages::WebPageProxy::GetGuessesForWord::Reply(guesses));
 }
 
-void WebEditorClient::requestCheckingOfString(WTF::PassRefPtr<TextCheckingRequest> prpRequest, const WebCore::VisibleSelection& currentSelection)
+void WebEditorClient::requestCheckingOfString(TextCheckingRequest& request, const WebCore::VisibleSelection& currentSelection)
 {
-    RefPtr<TextCheckingRequest> request = prpRequest;
-
     uint64_t requestID = generateTextCheckingRequestID();
-    m_page->addTextCheckingRequest(requestID, request);
+    m_page->addTextCheckingRequest(requestID, &request);
 
-    m_page->send(Messages::WebPageProxy::RequestCheckingOfString(requestID, request->data(), insertionPointFromCurrentSelection(currentSelection)));
+    m_page->send(Messages::WebPageProxy::RequestCheckingOfString(requestID, request.data(), insertionPointFromCurrentSelection(currentSelection)));
 }
 
 void WebEditorClient::willSetInputMethodState()
index 6b3a20f..8d8174d 100644 (file)
@@ -149,7 +149,7 @@ private:
     void getGuessesForWord(const String& word, const String& context, const WebCore::VisibleSelection& currentSelection, Vector<String>& guesses) final;
     void willSetInputMethodState() final;
     void setInputMethodState(bool enabled) final;
-    void requestCheckingOfString(WTF::PassRefPtr<WebCore::TextCheckingRequest>, const WebCore::VisibleSelection& currentSelection) final;
+    void requestCheckingOfString(WebCore::TextCheckingRequest&, const WebCore::VisibleSelection& currentSelection) final;
 
 #if PLATFORM(GTK)
     bool shouldShowUnicodeMenu() final;