🤠 Revert "Merge blink::WritingDirection to mojom::TextDirection"

This reverts commit 6b1e649d.

Reason for revert: Fail to compile. https://crbug.com/1108238

Original change's description:
> Merge blink::WritingDirection to mojom::TextDirection
> 
> In this CL, WritingDirection {kNatural, kLeftToRight, kRightToLeft} is
> replaced by TextDirection {UNKNOWN_DIRECTION, RIGHT_TO_LEFT,
> LEFT_TO_RIGHT} and dependant files are ported to use |TextDirection|
> enum.
> 
> Bug: 1088377
> Change-Id: Iac185f2d34eddd78127c3f59b7dc90fe380b5f34
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2306127
> Reviewed-by: Koji Ishii <kojii@chromium.org>
> Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
> Cr-Commit-Position: refs/heads/master@{#790314}

TBR=kojii@chromium.org,abhijeet@igalia.com

Change-Id: If73ac51c1f0ed22c4a1962884c735d70eb9dd7b1
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1088377
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2310537Reviewed-by: Arthur Sonzogni <arthursonzogni@chromium.org>
Commit-Queue: Arthur Sonzogni <arthursonzogni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790759}

third_party/blink/renderer/core/editing/BUILD.gn

@@ -336,6 +336,7 @@ blink_core_sources("editing") {
     "visible_units_paragraph.cc",
     "visible_units_sentence.cc",
     "visible_units_word.cc",
+    "writing_direction.h",
   ]
 
   if (is_mac) {

third_party/blink/renderer/core/editing/commands/apply_style_command.cc

@@ -48,6 +48,7 @@
 #include "third_party/blink/renderer/core/editing/visible_position.h"
 #include "third_party/blink/renderer/core/editing/visible_selection.h"
 #include "third_party/blink/renderer/core/editing/visible_units.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/html/html_font_element.h"
 #include "third_party/blink/renderer/core/html/html_span_element.h"
 #include "third_party/blink/renderer/core/html_names.h"
@@ -565,7 +566,7 @@ void ApplyStyleCommand::CleanupUnstyledAppleStyleSpans(
 HTMLElement* ApplyStyleCommand::SplitAncestorsWithUnicodeBidi(
     Node* node,
     bool before,
-    mojo_base::mojom::blink::TextDirection allowed_direction) {
+    WritingDirection allowed_direction) {
   // We are allowed to leave the highest ancestor with unicode-bidi unsplit if
   // it is unicode-bidi: embed and direction: allowedDirection. In that case, we
   // return the unsplit ancestor. Otherwise, we return 0.
@@ -596,11 +597,10 @@ HTMLElement* ApplyStyleCommand::SplitAncestorsWithUnicodeBidi(
 
   HTMLElement* unsplit_ancestor = nullptr;
 
-  mojo_base::mojom::blink::TextDirection highest_ancestor_direction;
+  WritingDirection highest_ancestor_direction;
   auto* highest_ancestor_html_element =
       DynamicTo<HTMLElement>(highest_ancestor_with_unicode_bidi);
-  if (allowed_direction !=
-          mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION &&
+  if (allowed_direction != WritingDirection::kNatural &&
       highest_ancestor_unicode_bidi != CSSValueID::kBidiOverride &&
       highest_ancestor_html_element &&
       MakeGarbageCollected<EditingStyle>(highest_ancestor_with_unicode_bidi,
@@ -750,8 +750,7 @@ void ApplyStyleCommand::ApplyInlineStyle(EditingStyle* style,
   // selection and prevent us from adding redundant ones, as described in:
   // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
   Position remove_start = MostBackwardCaretPosition(start);
-  mojo_base::mojom::blink::TextDirection text_direction =
-      mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+  WritingDirection text_direction = WritingDirection::kNatural;
   bool has_text_direction = style->GetTextDirection(text_direction);
   EditingStyle* style_without_embedding = nullptr;
   EditingStyle* embedding_style = nullptr;

third_party/blink/renderer/core/editing/commands/apply_style_command.h

@@ -38,6 +38,8 @@ class StyleChange;
 
 enum ShouldIncludeTypingStyle { kIncludeTypingStyle, kIgnoreTypingStyle };
 
+enum class WritingDirection;
+
 class CORE_EXPORT ApplyStyleCommand final : public CompositeEditCommand {
  public:
   enum PropertyLevel { kPropertyDefault, kForceBlockProperties };
@@ -159,7 +161,7 @@ class CORE_EXPORT ApplyStyleCommand final : public CompositeEditCommand {
   HTMLElement* SplitAncestorsWithUnicodeBidi(
       Node*,
       bool before,
-      mojo_base::mojom::blink::TextDirection allowed_direction);
+      WritingDirection allowed_direction);
   void RemoveEmbeddingUpToEnclosingBlock(Node*,
                                          HTMLElement* unsplit_ancestor,
                                          EditingState*);

third_party/blink/renderer/core/editing/commands/style_commands.cc

@@ -44,6 +44,7 @@
 #include "third_party/blink/renderer/core/editing/ephemeral_range.h"
 #include "third_party/blink/renderer/core/editing/frame_selection.h"
 #include "third_party/blink/renderer/core/editing/visible_position.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/html/html_font_element.h"
@@ -416,20 +417,20 @@ bool StyleCommands::IsUnicodeBidiNestedOrMultipleEmbeddings(
          value_id == CSSValueID::kPlaintext;
 }
 
-mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
+WritingDirection StyleCommands::TextDirectionForSelection(
     const VisibleSelection& selection,
     EditingStyle* typing_style,
     bool& has_nested_or_multiple_embeddings) {
   has_nested_or_multiple_embeddings = true;
 
   if (selection.IsNone())
-    return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+    return WritingDirection::kNatural;
 
   const Position position = MostForwardCaretPosition(selection.Start());
 
   const Node* anchor_node = position.AnchorNode();
   if (!anchor_node)
-    return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+    return WritingDirection::kNatural;
 
   Position end;
   if (selection.IsRange()) {
@@ -454,12 +455,12 @@ mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
       const CSSValueID unicode_bidi_value =
           unicode_bidi_identifier_value->GetValueID();
       if (IsUnicodeBidiNestedOrMultipleEmbeddings(unicode_bidi_value))
-        return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+        return WritingDirection::kNatural;
     }
   }
 
   if (selection.IsCaret()) {
-    mojo_base::mojom::blink::TextDirection direction;
+    WritingDirection direction;
     if (typing_style && typing_style->GetTextDirection(direction)) {
       has_nested_or_multiple_embeddings = false;
       return direction;
@@ -471,8 +472,7 @@ mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
   // 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.
   const Node* block = EnclosingBlock(anchor_node);
-  mojo_base::mojom::blink::TextDirection found_direction =
-      mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+  WritingDirection found_direction = WritingDirection::kNatural;
 
   for (Node& runner : NodeTraversal::InclusiveAncestorsOf(*anchor_node)) {
     if (runner == block)
@@ -496,7 +496,7 @@ mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
       continue;
 
     if (unicode_bidi_value == CSSValueID::kBidiOverride)
-      return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+      return WritingDirection::kNatural;
 
     DCHECK(EditingStyleUtilities::IsEmbedOrIsolate(unicode_bidi_value))
         << static_cast<int>(unicode_bidi_value);
@@ -511,19 +511,17 @@ mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
         direction_value != CSSValueID::kRtl)
       continue;
 
-    if (found_direction !=
-        mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION)
-      return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+    if (found_direction != WritingDirection::kNatural)
+      return WritingDirection::kNatural;
 
     // In the range case, make sure that the embedding element persists until
     // the end of the range.
     if (selection.IsRange() && !end.AnchorNode()->IsDescendantOf(element))
-      return mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+      return WritingDirection::kNatural;
 
-    found_direction =
-        direction_value == CSSValueID::kLtr
-            ? mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT
-            : mojo_base::mojom::blink::TextDirection::RIGHT_TO_LEFT;
+    found_direction = direction_value == CSSValueID::kLtr
+                          ? WritingDirection::kLeftToRight
+                          : WritingDirection::kRightToLeft;
   }
   has_nested_or_multiple_embeddings = false;
   return found_direction;
@@ -531,14 +529,13 @@ mojo_base::mojom::blink::TextDirection StyleCommands::TextDirectionForSelection(
 
 EditingTriState StyleCommands::StateTextWritingDirection(
     LocalFrame& frame,
-    mojo_base::mojom::blink::TextDirection direction) {
+    WritingDirection direction) {
   frame.GetDocument()->UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
 
   bool has_nested_or_multiple_embeddings;
-  mojo_base::mojom::blink::TextDirection selection_direction =
-      TextDirectionForSelection(
-          frame.Selection().ComputeVisibleSelectionInDOMTreeDeprecated(),
-          frame.GetEditor().TypingStyle(), has_nested_or_multiple_embeddings);
+  WritingDirection selection_direction = TextDirectionForSelection(
+      frame.Selection().ComputeVisibleSelectionInDOMTreeDeprecated(),
+      frame.GetEditor().TypingStyle(), has_nested_or_multiple_embeddings);
   // TODO(editing-dev): We should be returning MixedTriState when
   // selectionDirection == direction && hasNestedOrMultipleEmbeddings
   return (selection_direction == direction &&
@@ -550,22 +547,19 @@ EditingTriState StyleCommands::StateTextWritingDirection(
 EditingTriState StyleCommands::StateTextWritingDirectionLeftToRight(
     LocalFrame& frame,
     Event*) {
-  return StateTextWritingDirection(
-      frame, mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT);
+  return StateTextWritingDirection(frame, WritingDirection::kLeftToRight);
 }
 
 EditingTriState StyleCommands::StateTextWritingDirectionNatural(
     LocalFrame& frame,
     Event*) {
-  return StateTextWritingDirection(
-      frame, mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION);
+  return StateTextWritingDirection(frame, WritingDirection::kNatural);
 }
 
 EditingTriState StyleCommands::StateTextWritingDirectionRightToLeft(
     LocalFrame& frame,
     Event*) {
-  return StateTextWritingDirection(
-      frame, mojo_base::mojom::blink::TextDirection::RIGHT_TO_LEFT);
+  return StateTextWritingDirection(frame, WritingDirection::kRightToLeft);
 }
 
 EditingTriState StyleCommands::StateUnderline(LocalFrame& frame, Event*) {

third_party/blink/renderer/core/editing/commands/style_commands.h

@@ -47,6 +47,7 @@ class LocalFrame;
 
 enum class EditingTriState;
 enum class EditorCommandSource;
+enum class WritingDirection;
 
 // This class provides static functions about commands related to style.
 class StyleCommands {
@@ -203,11 +204,11 @@ class StyleCommands {
 
   // TODO(editing-dev): We should make |textDirectionForSelection()| to take
   // |selectionInDOMTree|.
-  static mojo_base::mojom::blink::TextDirection
-  TextDirectionForSelection(const VisibleSelection&, EditingStyle*, bool&);
-  static EditingTriState StateTextWritingDirection(
-      LocalFrame&,
-      mojo_base::mojom::blink::TextDirection);
+  static WritingDirection TextDirectionForSelection(const VisibleSelection&,
+                                                    EditingStyle*,
+                                                    bool&);
+  static EditingTriState StateTextWritingDirection(LocalFrame&,
+                                                   WritingDirection);
 };
 
 }  // namespace blink

third_party/blink/renderer/core/editing/editing_style.cc

@@ -57,6 +57,7 @@
 #include "third_party/blink/renderer/core/editing/position.h"
 #include "third_party/blink/renderer/core/editing/serializers/html_interchange.h"
 #include "third_party/blink/renderer/core/editing/visible_selection.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/html/html_font_element.h"
@@ -635,8 +636,7 @@ bool EditingStyle::IsEmpty() const {
          font_size_delta_ == kNoFontDelta;
 }
 
-bool EditingStyle::GetTextDirection(
-    mojo_base::mojom::blink::TextDirection& writing_direction) const {
+bool EditingStyle::GetTextDirection(WritingDirection& writing_direction) const {
   if (!mutable_style_)
     return false;
 
@@ -657,15 +657,14 @@ bool EditingStyle::GetTextDirection(
 
     writing_direction =
         direction_identifier_value->GetValueID() == CSSValueID::kLtr
-            ? mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT
-            : mojo_base::mojom::blink::TextDirection::RIGHT_TO_LEFT;
+            ? WritingDirection::kLeftToRight
+            : WritingDirection::kRightToLeft;
 
     return true;
   }
 
   if (unicode_bidi_value == CSSValueID::kNormal) {
-    writing_direction =
-        mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
+    writing_direction = WritingDirection::kNatural;
     return true;
   }
 

third_party/blink/renderer/core/editing/editing_style.h

@@ -32,7 +32,6 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_EDITING_EDITING_STYLE_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_EDITING_EDITING_STYLE_H_
 
-#include "mojo/public/mojom/base/text_direction.mojom-blink-forward.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/css/css_property_names.h"
 #include "third_party/blink/renderer/core/css_value_keywords.h"
@@ -59,6 +58,7 @@ class ComputedStyle;
 class CSSPropertyValueSet;
 enum class EditingTriState;
 enum class SecureContextMode;
+enum class WritingDirection;
 
 class CORE_EXPORT EditingStyle final : public GarbageCollected<EditingStyle> {
  public:
@@ -86,7 +86,7 @@ class CORE_EXPORT EditingStyle final : public GarbageCollected<EditingStyle> {
   EditingStyle(CSSPropertyID, const String& value, SecureContextMode);
 
   MutableCSSPropertyValueSet* Style() { return mutable_style_.Get(); }
-  bool GetTextDirection(mojo_base::mojom::blink::TextDirection&) const;
+  bool GetTextDirection(WritingDirection&) const;
   bool IsEmpty() const;
   void OverrideWithStyle(const CSSPropertyValueSet*);
   void Clear();

third_party/blink/renderer/core/editing/editor.cc

@@ -65,6 +65,7 @@
 #include "third_party/blink/renderer/core/editing/spellcheck/spell_checker.h"
 #include "third_party/blink/renderer/core/editing/visible_position.h"
 #include "third_party/blink/renderer/core/editing/visible_units.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/events/keyboard_event.h"
 #include "third_party/blink/renderer/core/events/text_event.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
@@ -632,17 +633,14 @@ void Editor::Redo() {
   undo_stack_->Redo();
 }
 
-void Editor::SetBaseWritingDirection(
-    mojo_base::mojom::blink::TextDirection direction) {
+void Editor::SetBaseWritingDirection(WritingDirection direction) {
   Element* focused_element = GetFrame().GetDocument()->FocusedElement();
   if (auto* text_control = ToTextControlOrNull(focused_element)) {
-    if (direction == mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION)
+    if (direction == WritingDirection::kNatural)
       return;
     text_control->setAttribute(
         html_names::kDirAttr,
-        direction == mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT
-            ? "ltr"
-            : "rtl");
+        direction == WritingDirection::kLeftToRight ? "ltr" : "rtl");
     text_control->DispatchInputEvent();
     return;
   }
@@ -651,11 +649,9 @@ void Editor::SetBaseWritingDirection(
       MakeGarbageCollected<MutableCSSPropertyValueSet>(kHTMLQuirksMode);
   style->SetProperty(
       CSSPropertyID::kDirection,
-      direction == mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT
+      direction == WritingDirection::kLeftToRight
           ? "ltr"
-          : direction == mojo_base::mojom::blink::TextDirection::RIGHT_TO_LEFT
-                ? "rtl"
-                : "inherit",
+          : direction == WritingDirection::kRightToLeft ? "rtl" : "inherit",
       /* important */ false, GetFrame().DomWindow()->GetSecureContextMode());
   ApplyParagraphStyleToSelection(
       style, InputEvent::InputType::kFormatSetBlockTextDirection);

third_party/blink/renderer/core/editing/editor.h

@@ -59,6 +59,7 @@ enum class InsertMode { kSimple, kSmart };
 enum class DragSourceType { kHTMLSource, kPlainTextSource };
 enum class EditorParagraphSeparator { kIsDiv, kIsP };
 enum class EditorCommandSource { kMenuOrKeyBinding, kDOM };
+enum class WritingDirection;
 
 class CORE_EXPORT Editor final : public GarbageCollected<Editor> {
  public:
@@ -132,7 +133,7 @@ class CORE_EXPORT Editor final : public GarbageCollected<Editor> {
   // Supposed to be used as |const UndoStack&|.
   UndoStack& GetUndoStack() const { return *undo_stack_; }
 
-  void SetBaseWritingDirection(mojo_base::mojom::blink::TextDirection);
+  void SetBaseWritingDirection(WritingDirection);
 
   // smartInsertDeleteEnabled and selectTrailingWhitespaceEnabled are
   // mutually exclusive, meaning that enabling one will disable the other.

third_party/blink/renderer/core/editing/writing_direction.h

+/*
+ * Copyright (C) 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_EDITING_WRITING_DIRECTION_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_EDITING_WRITING_DIRECTION_H_
+
+namespace blink {
+
+enum class WritingDirection { kNatural, kLeftToRight, kRightToLeft };
+
+}  // namespace blink
+
+#endif

third_party/blink/renderer/core/frame/local_frame.cc

@@ -91,6 +91,7 @@
 #include "third_party/blink/renderer/core/editing/spellcheck/spell_checker.h"
 #include "third_party/blink/renderer/core/editing/suggestion/text_suggestion_controller.h"
 #include "third_party/blink/renderer/core/editing/surrounding_text.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/execution_context/window_agent.h"
 #include "third_party/blink/renderer/core/exported/web_plugin_container_impl.h"
 #include "third_party/blink/renderer/core/fileapi/public_url_manager.h"
@@ -805,18 +806,15 @@ void LocalFrame::SetTextDirection(base::i18n::TextDirection direction) {
 
   switch (direction) {
     case base::i18n::TextDirection::UNKNOWN_DIRECTION:
-      editor.SetBaseWritingDirection(
-          mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION);
+      editor.SetBaseWritingDirection(WritingDirection::kNatural);
       break;
 
     case base::i18n::TextDirection::LEFT_TO_RIGHT:
-      editor.SetBaseWritingDirection(
-          mojo_base::mojom::blink::TextDirection::LEFT_TO_RIGHT);
+      editor.SetBaseWritingDirection(WritingDirection::kLeftToRight);
       break;
 
     case base::i18n::TextDirection::RIGHT_TO_LEFT:
-      editor.SetBaseWritingDirection(
-          mojo_base::mojom::blink::TextDirection::RIGHT_TO_LEFT);
+      editor.SetBaseWritingDirection(WritingDirection::kRightToLeft);
       break;
 
     default:

third_party/blink/renderer/core/frame/web_local_frame_impl.cc

@@ -169,6 +169,7 @@
 #include "third_party/blink/renderer/core/editing/spellcheck/spell_checker.h"
 #include "third_party/blink/renderer/core/editing/text_affinity.h"
 #include "third_party/blink/renderer/core/editing/visible_position.h"
+#include "third_party/blink/renderer/core/editing/writing_direction.h"
 #include "third_party/blink/renderer/core/events/after_print_event.h"
 #include "third_party/blink/renderer/core/events/before_print_event.h"
 #include "third_party/blink/renderer/core/exported/local_frame_client_impl.h"