Attachment 356604 Details for Bug 192401 – Patch

[patch] Patch

bug-192401-20181205073006.patch (text/plain), 23.52 KB, created by Wenson Hsieh on 2018-12-05 07:30:07 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Wenson Hsieh

Created: 2018-12-05 07:30:07 PST

Size: 23.52 KB

patch

obsolete

>Subversion Revision: 238807
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 021c6299756d8ba75ae38c71a774553f9b171bf6..bdf2dbb0a11e18b7846f7937320761f8ef06362c 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,37 @@
>+2018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Turn WritingDirection into an enum class
>+        https://bugs.webkit.org/show_bug.cgi?id=192401
>+        Work towards <rdar://problem/42075638>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change WritingDirection from an enum to an enum class. No change in behavior.
>+
>+        * editing/ApplyStyleCommand.cpp:
>+        (WebCore::ApplyStyleCommand::splitAncestorsWithUnicodeBidi):
>+        (WebCore::ApplyStyleCommand::applyInlineStyle):
>+        * editing/EditingStyle.cpp:
>+        (WebCore::EditingStyle::textDirection const):
>+        (WebCore::EditingStyle::textDirectionForSelection):
>+        * editing/Editor.cpp:
>+        (WebCore::Editor::setBaseWritingDirection):
>+        (WebCore::Editor::baseWritingDirectionForSelectionStart const):
>+        * editing/EditorCommand.cpp:
>+        (WebCore::stateTextWritingDirectionLeftToRight):
>+        (WebCore::stateTextWritingDirectionNatural):
>+        (WebCore::stateTextWritingDirectionRightToLeft):
>+        * editing/WritingDirection.h:
>+
>+        Additionally wrap this enum in `namespace WebCore`, and update the copyright year.
>+
>+        * editing/ios/EditorIOS.mm:
>+        (WebCore::Editor::setTextAlignmentForChangedBaseWritingDirection):
>+        * page/ContextMenuController.cpp:
>+        (WebCore::ContextMenuController::contextMenuItemSelected):
>+        * testing/Internals.cpp:
>+        (WebCore::Internals::setBaseWritingDirection):
>+
> 2018-12-03  Michael Catanzaro  <mcatanzaro@igalia.com>
> 
>         [SOUP] Use SoupSession instead of SoupSessionAsync
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 18bb6ad6828f969be7272a5c7e2ef5610b0ea112..77550756a806b695f078d95cfccd01ffde2b1f51 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,16 @@
>+2018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Turn WritingDirection into an enum class
>+        https://bugs.webkit.org/show_bug.cgi?id=192401
>+        Work towards <rdar://problem/42075638>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change WritingDirection from an enum to an enum class. No change in behavior.
>+
>+        * WebProcess/WebPage/WebFrame.cpp:
>+        (WebKit::WebFrame::setTextDirection):
>+
> 2018-12-03  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
> 
>         Use WallTime for file time
>diff --git a/Source/WebKitLegacy/ios/ChangeLog b/Source/WebKitLegacy/ios/ChangeLog
>index 45226fd4d494d579f563ce2d0afe7be6b0b3527b..e68b48c6e8e05b80100bc90071ace847af647da2 100644
>--- a/Source/WebKitLegacy/ios/ChangeLog
>+++ b/Source/WebKitLegacy/ios/ChangeLog
>@@ -1,3 +1,17 @@
>+2018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Turn WritingDirection into an enum class
>+        https://bugs.webkit.org/show_bug.cgi?id=192401
>+        Work towards <rdar://problem/42075638>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change WritingDirection from an enum to an enum class. No change in behavior.
>+
>+        * WebCoreSupport/WebFrameIOS.mm:
>+        (-[WebFrame selectionBaseWritingDirection]):
>+        (-[WebFrame setBaseWritingDirection:]):
>+
> 2018-11-29  Zalan Bujtas  <zalan@apple.com>
> 
>         Rename *ObservedContentModifier(s) to *ObservedDOMTimer(s)
>diff --git a/Source/WebKitLegacy/mac/ChangeLog b/Source/WebKitLegacy/mac/ChangeLog
>index 1efaf52cc017ca68897afe8584b56de5e7b2d674..1ca7985eafc9467d0e35751ed19481da53ab7879 100644
>--- a/Source/WebKitLegacy/mac/ChangeLog
>+++ b/Source/WebKitLegacy/mac/ChangeLog
>@@ -1,3 +1,18 @@
>+2018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Turn WritingDirection into an enum class
>+        https://bugs.webkit.org/show_bug.cgi?id=192401
>+        Work towards <rdar://problem/42075638>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change WritingDirection from an enum to an enum class. No change in behavior.
>+
>+        * WebView/WebHTMLView.mm:
>+        (-[WebHTMLView toggleBaseWritingDirection:]):
>+        (-[WebHTMLView changeBaseWritingDirection:]):
>+        (-[WebHTMLView _changeBaseWritingDirectionTo:]):
>+
> 2018-12-02  Zalan Bujtas  <zalan@apple.com>
> 
>         Add a runtime feature flag for LayoutFormattingContext.
>diff --git a/Source/WebCore/editing/ApplyStyleCommand.cpp b/Source/WebCore/editing/ApplyStyleCommand.cpp
>index 3700f3771ef5923d65bc7abb26bce6b8b05fe297..c3d814ad1d3fda6af869688bfc2ca1b79c95c6a3 100644
>--- a/Source/WebCore/editing/ApplyStyleCommand.cpp
>+++ b/Source/WebCore/editing/ApplyStyleCommand.cpp
>@@ -484,7 +484,7 @@ HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool b
>     HTMLElement* unsplitAncestor = nullptr;
> 
>     WritingDirection highestAncestorDirection;
>-    if (allowedDirection != NaturalWritingDirection
>+    if (allowedDirection != WritingDirection::Natural
>         && highestAncestorUnicodeBidi != CSSValueBidiOverride
>         && is<HTMLElement>(*highestAncestorWithUnicodeBidi)
>         && EditingStyle::create(highestAncestorWithUnicodeBidi, EditingStyle::AllProperties)->textDirection(highestAncestorDirection)
>@@ -614,7 +614,7 @@ void ApplyStyleCommand::applyInlineStyle(EditingStyle& style)
>     // and prevent us from adding redundant ones, as described in:
>     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
>     Position removeStart = start.upstream();
>-    WritingDirection textDirection = NaturalWritingDirection;
>+    WritingDirection textDirection = WritingDirection::Natural;
>     bool hasTextDirection = style.textDirection(textDirection);
>     RefPtr<EditingStyle> styleWithoutEmbedding;
>     RefPtr<EditingStyle> embeddingStyle;
>diff --git a/Source/WebCore/editing/EditingStyle.cpp b/Source/WebCore/editing/EditingStyle.cpp
>index ea9885e4bfefae288a836ff8de7862d4d7bce4f4..64216c986064b67ee3995e001389d1c8adb4738a 100644
>--- a/Source/WebCore/editing/EditingStyle.cpp
>+++ b/Source/WebCore/editing/EditingStyle.cpp
>@@ -567,13 +567,13 @@ bool EditingStyle::textDirection(WritingDirection& writingDirection) const
>         if (!is<CSSPrimitiveValue>(direction))
>             return false;
> 
>-        writingDirection = downcast<CSSPrimitiveValue>(*direction).valueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
>+        writingDirection = downcast<CSSPrimitiveValue>(*direction).valueID() == CSSValueLtr ? WritingDirection::LeftToRight : WritingDirection::RightToLeft;
> 
>         return true;
>     }
> 
>     if (unicodeBidiValue == CSSValueNormal) {
>-        writingDirection = NaturalWritingDirection;
>+        writingDirection = WritingDirection::Natural;
>         return true;
>     }
> 
>@@ -1468,13 +1468,13 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
>     hasNestedOrMultipleEmbeddings = true;
> 
>     if (selection.isNone())
>-        return NaturalWritingDirection;
>+        return WritingDirection::Natural;
> 
>     Position position = selection.start().downstream();
> 
>     Node* node = position.deprecatedNode();
>     if (!node)
>-        return NaturalWritingDirection;
>+        return WritingDirection::Natural;
> 
>     Position end;
>     if (selection.isRange()) {
>@@ -1491,7 +1491,7 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
> 
>             CSSValueID unicodeBidiValue = downcast<CSSPrimitiveValue>(*unicodeBidi).valueID();
>             if (unicodeBidiValue == CSSValueEmbed || unicodeBidiValue == CSSValueBidiOverride)
>-                return NaturalWritingDirection;
>+                return WritingDirection::Natural;
>         }
>     }
> 
>@@ -1507,7 +1507,7 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
>     // The selection is either a caret with no typing attributes or a range in which no embedding is added, so just use the start position
>     // to decide.
>     Node* block = enclosingBlock(node);
>-    WritingDirection foundDirection = NaturalWritingDirection;
>+    auto foundDirection = WritingDirection::Natural;
> 
>     for (; node != block; node = node->parentNode()) {
>         if (!node->isStyledElement())
>@@ -1523,7 +1523,7 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
>             continue;
> 
>         if (unicodeBidiValue == CSSValueBidiOverride)
>-            return NaturalWritingDirection;
>+            return WritingDirection::Natural;
> 
>         ASSERT(unicodeBidiValue == CSSValueEmbed);
>         RefPtr<CSSValue> direction = computedStyle.propertyValue(CSSPropertyDirection);
>@@ -1534,14 +1534,14 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
>         if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
>             continue;
> 
>-        if (foundDirection != NaturalWritingDirection)
>-            return NaturalWritingDirection;
>+        if (foundDirection != WritingDirection::Natural)
>+            return WritingDirection::Natural;
> 
>         // In the range case, make sure that the embedding element persists until the end of the range.
>         if (selection.isRange() && !end.deprecatedNode()->isDescendantOf(*node))
>-            return NaturalWritingDirection;
>+            return WritingDirection::Natural;
>         
>-        foundDirection = directionValue == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
>+        foundDirection = directionValue == CSSValueLtr ? WritingDirection::LeftToRight : WritingDirection::RightToLeft;
>     }
>     hasNestedOrMultipleEmbeddings = false;
>     return foundDirection;
>diff --git a/Source/WebCore/editing/Editor.cpp b/Source/WebCore/editing/Editor.cpp
>index adccf94e888bc394ec1c8db94290d139c42ed86b..69c16a94dd9dbd83a09d0e6df33ca83d8b32f954 100644
>--- a/Source/WebCore/editing/Editor.cpp
>+++ b/Source/WebCore/editing/Editor.cpp
>@@ -1780,11 +1780,11 @@ void Editor::setBaseWritingDirection(WritingDirection direction)
>         
>     Element* focusedElement = document().focusedElement();
>     if (focusedElement && focusedElement->isTextField()) {
>-        if (direction == NaturalWritingDirection)
>+        if (direction == WritingDirection::Natural)
>             return;
> 
>         auto& focusedFormElement = downcast<HTMLTextFormControlElement>(*focusedElement);
>-        auto directionValue = direction == LeftToRightWritingDirection ? "ltr" : "rtl";
>+        auto directionValue = direction == WritingDirection::LeftToRight ? "ltr" : "rtl";
>         auto writingDirectionInputTypeName = inputTypeNameForEditingAction(EditAction::SetWritingDirection);
>         if (!dispatchBeforeInputEvent(focusedFormElement, writingDirectionInputTypeName, directionValue))
>             return;
>@@ -1796,13 +1796,13 @@ void Editor::setBaseWritingDirection(WritingDirection direction)
>     }
> 
>     RefPtr<MutableStyleProperties> style = MutableStyleProperties::create();
>-    style->setProperty(CSSPropertyDirection, direction == LeftToRightWritingDirection ? "ltr" : direction == RightToLeftWritingDirection ? "rtl" : "inherit", false);
>+    style->setProperty(CSSPropertyDirection, direction == WritingDirection::LeftToRight ? "ltr" : direction == WritingDirection::RightToLeft ? "rtl" : "inherit", false);
>     applyParagraphStyleToSelection(style.get(), EditAction::SetWritingDirection);
> }
> 
> WritingDirection Editor::baseWritingDirectionForSelectionStart() const
> {
>-    WritingDirection result = LeftToRightWritingDirection;
>+    auto result = WritingDirection::LeftToRight;
> 
>     Position pos = m_frame.selection().selection().visibleStart().deepEquivalent();
>     Node* node = pos.deprecatedNode();
>@@ -1821,9 +1821,9 @@ WritingDirection Editor::baseWritingDirectionForSelectionStart() const
> 
>     switch (renderer->style().direction()) {
>     case TextDirection::LTR:
>-        return LeftToRightWritingDirection;
>+        return WritingDirection::LeftToRight;
>     case TextDirection::RTL:
>-        return RightToLeftWritingDirection;
>+        return WritingDirection::RightToLeft;
>     }
>     
>     return result;
>diff --git a/Source/WebCore/editing/EditorCommand.cpp b/Source/WebCore/editing/EditorCommand.cpp
>index 8cd66fee7578bdf97a017b0a5624f1ba7a6f733b..56ca5bf0a7f89340ec7b242f015b0e578cc39d57 100644
>--- a/Source/WebCore/editing/EditorCommand.cpp
>+++ b/Source/WebCore/editing/EditorCommand.cpp
>@@ -1430,17 +1430,17 @@ static TriState stateSuperscript(Frame& frame, Event*)
> 
> static TriState stateTextWritingDirectionLeftToRight(Frame& frame, Event*)
> {
>-    return stateTextWritingDirection(frame, LeftToRightWritingDirection);
>+    return stateTextWritingDirection(frame, WritingDirection::LeftToRight);
> }
> 
> static TriState stateTextWritingDirectionNatural(Frame& frame, Event*)
> {
>-    return stateTextWritingDirection(frame, NaturalWritingDirection);
>+    return stateTextWritingDirection(frame, WritingDirection::Natural);
> }
> 
> static TriState stateTextWritingDirectionRightToLeft(Frame& frame, Event*)
> {
>-    return stateTextWritingDirection(frame, RightToLeftWritingDirection);
>+    return stateTextWritingDirection(frame, WritingDirection::RightToLeft);
> }
> 
> static TriState stateUnderline(Frame& frame, Event*)
>diff --git a/Source/WebCore/editing/WritingDirection.h b/Source/WebCore/editing/WritingDirection.h
>index 768b3c25d146cb65cf6d862adf9b4d73d376e36e..34478aed81d43d78a9cd08dd0607677ebd115a30 100644
>--- a/Source/WebCore/editing/WritingDirection.h
>+++ b/Source/WebCore/editing/WritingDirection.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2008 Apple Inc. All rights reserved.
>+ * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -23,9 +23,29 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  */
> 
>-#ifndef WritingDirection_h
>-#define WritingDirection_h
>+#pragma once
> 
>-enum WritingDirection { NaturalWritingDirection, LeftToRightWritingDirection, RightToLeftWritingDirection };
>+#include <wtf/Forward.h>
> 
>-#endif
>+namespace WebCore {
>+
>+enum class WritingDirection : uint8_t {
>+    Natural,
>+    LeftToRight,
>+    RightToLeft
>+};
>+
>+} // namespace WebCore
>+
>+namespace WTF {
>+
>+template<> struct EnumTraits<WebCore::WritingDirection> {
>+    using values = EnumValues<
>+        WebCore::WritingDirection,
>+        WebCore::WritingDirection::Natural,
>+        WebCore::WritingDirection::LeftToRight,
>+        WebCore::WritingDirection::RightToLeft
>+    >;
>+};
>+
>+} // namespace WTF
>diff --git a/Source/WebCore/editing/ios/EditorIOS.mm b/Source/WebCore/editing/ios/EditorIOS.mm
>index e8b622aa820cf9aab56f2bc58461688d6c938b7b..f37fde7ff45dbb55a55602982eef2c89cc4e4c77 100644
>--- a/Source/WebCore/editing/ios/EditorIOS.mm
>+++ b/Source/WebCore/editing/ios/EditorIOS.mm
>@@ -97,13 +97,13 @@ void Editor::setTextAlignmentForChangedBaseWritingDirection(WritingDirection dir
>     case TextAlignMode::Start:
>     case TextAlignMode::End: {
>         switch (direction) {
>-        case NaturalWritingDirection:
>+        case WritingDirection::Natural:
>             // no-op
>             break;
>-        case LeftToRightWritingDirection:
>+        case WritingDirection::LeftToRight:
>             newValue = "left";
>             break;
>-        case RightToLeftWritingDirection:
>+        case WritingDirection::RightToLeft:
>             newValue = "right";
>             break;
>         }
>@@ -131,7 +131,7 @@ void Editor::setTextAlignmentForChangedBaseWritingDirection(WritingDirection dir
>     if (focusedElement && (is<HTMLTextAreaElement>(*focusedElement) || (is<HTMLInputElement>(*focusedElement)
>         && (downcast<HTMLInputElement>(*focusedElement).isTextField()
>             || downcast<HTMLInputElement>(*focusedElement).isSearchField())))) {
>-        if (direction == NaturalWritingDirection)
>+        if (direction == WritingDirection::Natural)
>             return;
>         downcast<HTMLElement>(*focusedElement).setAttributeWithoutSynchronization(alignAttr, newValue);
>         m_frame.document()->updateStyleIfNeeded();
>diff --git a/Source/WebCore/page/ContextMenuController.cpp b/Source/WebCore/page/ContextMenuController.cpp
>index a3e5eae894d6427637dd845edaade71c6151c1aa..c775deeae0a9f3b6a89b1d503d04ec896bf52ba0 100644
>--- a/Source/WebCore/page/ContextMenuController.cpp
>+++ b/Source/WebCore/page/ContextMenuController.cpp
>@@ -429,13 +429,13 @@ void ContextMenuController::contextMenuItemSelected(ContextMenuAction action, co
>         m_client.stopSpeaking();
>         break;
>     case ContextMenuItemTagDefaultDirection:
>-        frame->editor().setBaseWritingDirection(NaturalWritingDirection);
>+        frame->editor().setBaseWritingDirection(WritingDirection::Natural);
>         break;
>     case ContextMenuItemTagLeftToRight:
>-        frame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
>+        frame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
>         break;
>     case ContextMenuItemTagRightToLeft:
>-        frame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
>+        frame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
>         break;
>     case ContextMenuItemTagTextDirectionDefault:
>         frame->editor().command("MakeTextWritingDirectionNatural").execute();
>diff --git a/Source/WebCore/testing/Internals.cpp b/Source/WebCore/testing/Internals.cpp
>index bf31334664b1513c58f459601fc64d810b6f436d..77bfc9821a5dcf054408b28e710c1b3adf236492 100644
>--- a/Source/WebCore/testing/Internals.cpp
>+++ b/Source/WebCore/testing/Internals.cpp
>@@ -4338,13 +4338,13 @@ void Internals::setBaseWritingDirection(BaseWritingDirection direction)
>         if (auto* frame = document->frame()) {
>             switch (direction) {
>             case BaseWritingDirection::Ltr:
>-                frame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
>+                frame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
>                 break;
>             case BaseWritingDirection::Rtl:
>-                frame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
>+                frame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
>                 break;
>             case BaseWritingDirection::Natural:
>-                frame->editor().setBaseWritingDirection(NaturalWritingDirection);
>+                frame->editor().setBaseWritingDirection(WritingDirection::Natural);
>                 break;
>             }
>         }
>diff --git a/Source/WebKit/WebProcess/WebPage/WebFrame.cpp b/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>index 2332a569cd078cbb05599c2ae22199991dc3c86b..7b15c65712179640af497f2f19c71996b7134528 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>@@ -802,11 +802,11 @@ void WebFrame::setTextDirection(const String& direction)
>         return;
> 
>     if (direction == "auto")
>-        m_coreFrame->editor().setBaseWritingDirection(NaturalWritingDirection);
>+        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::Natural);
>     else if (direction == "ltr")
>-        m_coreFrame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
>+        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
>     else if (direction == "rtl")
>-        m_coreFrame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
>+        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
> }
> 
> void WebFrame::documentLoaderDetached(uint64_t navigationID)
>diff --git a/Source/WebKitLegacy/ios/WebCoreSupport/WebFrameIOS.mm b/Source/WebKitLegacy/ios/WebCoreSupport/WebFrameIOS.mm
>index fb7ef8f140bff650ae0f247469f924c7ec7d8d08..a4f0f599cf206d5ec0632cd791ef9bbf0a2b05d2 100644
>--- a/Source/WebKitLegacy/ios/WebCoreSupport/WebFrameIOS.mm
>+++ b/Source/WebKitLegacy/ios/WebCoreSupport/WebFrameIOS.mm
>@@ -533,10 +533,10 @@ - (WKWritingDirection)selectionBaseWritingDirection
> {
>     Frame *frame = [self coreFrame];
>     switch (frame->editor().baseWritingDirectionForSelectionStart()) {
>-    case LeftToRightWritingDirection:
>+    case WritingDirection::LeftToRight:
>         return WKWritingDirectionLeftToRight;
> 
>-    case RightToLeftWritingDirection:
>+    case WritingDirection::RightToLeft:
>         return WKWritingDirectionRightToLeft;
> 
>     default:
>@@ -573,16 +573,16 @@ - (void)setBaseWritingDirection:(WKWritingDirection)direction
>     if (!frame->selection().selection().isContentEditable())
>         return;
>     
>-    WritingDirection wcDirection = LeftToRightWritingDirection;
>+    auto wcDirection = WritingDirection::LeftToRight;
>     switch (direction) {
>         case WKWritingDirectionNatural:
>-            wcDirection = NaturalWritingDirection;
>+            wcDirection = WritingDirection::Natural;
>             break;
>         case WKWritingDirectionLeftToRight:
>-            wcDirection = LeftToRightWritingDirection;
>+            wcDirection = WritingDirection::LeftToRight;
>             break;
>         case WKWritingDirectionRightToLeft:
>-            wcDirection = RightToLeftWritingDirection;
>+            wcDirection = WritingDirection::RightToLeft;
>             break;
>         default:
>             ASSERT_NOT_REACHED();
>diff --git a/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm b/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>index 88a9e4b175e2d9d02f6741b746c62f18f58278ab..a919c47b464b78e7b767bd0e4054f52db9cf6686 100644
>--- a/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>+++ b/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>@@ -5520,18 +5520,18 @@ - (void)toggleBaseWritingDirection:(id)sender
>     if (!coreFrame)
>         return;
> 
>-    WritingDirection direction = RightToLeftWritingDirection;
>+    auto direction = WritingDirection::RightToLeft;
>     switch (coreFrame->editor().baseWritingDirectionForSelectionStart()) {
>-        case LeftToRightWritingDirection:
>-            break;
>-        case RightToLeftWritingDirection:
>-            direction = LeftToRightWritingDirection;
>-            break;
>-        // The writingDirectionForSelectionStart method will never return "natural". It
>-        // will always return a concrete direction. So, keep the compiler happy, and assert not reached.
>-        case NaturalWritingDirection:
>-            ASSERT_NOT_REACHED();
>-            break;
>+    case WritingDirection::LeftToRight:
>+        break;
>+    case WritingDirection::RightToLeft:
>+        direction = WritingDirection::LeftToRight;
>+        break;
>+    // The writingDirectionForSelectionStart method will never return "natural". It
>+    // will always return a concrete direction. So, keep the compiler happy, and assert not reached.
>+    case WritingDirection::Natural:
>+        ASSERT_NOT_REACHED();
>+        break;
>     }
> 
>     if (Frame* coreFrame = core([self _frame]))
>@@ -5552,7 +5552,7 @@ - (void)changeBaseWritingDirection:(id)sender
>     ASSERT(writingDirection != NSWritingDirectionNatural);
> 
>     if (Frame* coreFrame = core([self _frame]))
>-        coreFrame->editor().setBaseWritingDirection(writingDirection == NSWritingDirectionLeftToRight ? LeftToRightWritingDirection : RightToLeftWritingDirection);
>+        coreFrame->editor().setBaseWritingDirection(writingDirection == NSWritingDirectionLeftToRight ? WritingDirection::LeftToRight : WritingDirection::RightToLeft);
> }
> 
> static BOOL writingDirectionKeyBindingsEnabled()
>@@ -5573,7 +5573,7 @@ - (void)_changeBaseWritingDirectionTo:(NSWritingDirection)direction
>     }
> 
>     if (Frame* coreFrame = core([self _frame]))
>-        coreFrame->editor().setBaseWritingDirection(direction == NSWritingDirectionLeftToRight ? LeftToRightWritingDirection : RightToLeftWritingDirection);
>+        coreFrame->editor().setBaseWritingDirection(direction == NSWritingDirectionLeftToRight ? WritingDirection::LeftToRight : WritingDirection::RightToLeft);
> }
> 
> - (void)makeBaseWritingDirectionLeftToRight:(id)sender

Actions: View | Formatted Diff | Diff

Attachments on bug 192401: 356604 | 356606