[rendertext,i18n] Added flag to force RTL rendering

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/render_text_harfbuzz.h"
 
 #include <limits>
 #include <set>
 
+#include "base/command_line.h"
+#include "base/i18n/base_i18n_switches.h"
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
@@ skipping 579 matching lines @@
 };
 
 // Function object for case insensitive string comparison.
 struct CaseInsensitiveCompare {
   bool operator() (const Font& a, const Font& b) const {
     return base::CompareCaseInsensitiveASCII(a.GetFontName(), b.GetFontName()) <
            0;
   }
 };
 
+bool HasForcedTextDirectionSwitch() {

[msw, 2017/05/01 20:56:18]

ditto nit: "// Get the cached switch presence; avoids repeated lookup in the
common case." (or you can inline this static bool in the function below)

[Kevin Bailey, 2017/05/01 21:21:42]

Done. Again, absorbed code.

+  static bool value = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kForceTextDirection);
+  return value;
+}
+
 }  // namespace
 
 namespace internal {
 
 #if !defined(OS_MACOSX)
 sk_sp<SkTypeface> CreateSkiaTypeface(const Font& font,
                                      bool italic,
                                      Font::Weight weight) {
   SkFontStyle skia_style(
       static_cast<int>(weight), SkFontStyle::kNormal_Width,
@@ skipping 713 matching lines @@
   return SelectionModel(position, CURSOR_BACKWARD);
 }
 
 SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun(
     const internal::TextRunHarfBuzz* run) {
   size_t position = DisplayIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
+void RenderTextHarfBuzz::CheckForcedDirection(UBiDiLevel* level) {

[msw, 2017/05/01 20:56:18]

nit: "// Applies a forced direction if specified by a commandline switch."

[Kevin Bailey, 2017/05/01 21:21:42]

Done.

+  if (!HasForcedTextDirectionSwitch())
+    return;
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kForceTextDirection)) {
+    std::string force_flag =
+        command_line->GetSwitchValueASCII(switches::kForceTextDirection);
+
+    if (force_flag == switches::kForceDirectionRTL)
+      *level = UBIDI_RTL;
+    if (force_flag == switches::kForceDirectionLTR)
+      *level = UBIDI_LTR;
+  }
+}
+
 void RenderTextHarfBuzz::ItemizeTextToRuns(
     const base::string16& text,
     internal::TextRunList* run_list_out) {
   DCHECK_NE(0U, text.length());
 
   // If ICU fails to itemize the text, we create a run that spans the entire
   // text. This is needed because leaving the runs set empty causes some clients
   // to misbehave since they expect non-zero text metrics from a non-empty text.
   base::i18n::BiDiLineIterator bidi_iterator;
   if (!bidi_iterator.Open(text, GetTextDirection(text))) {
@@ skipping 23 matching lines @@
     run->range.set_start(run_break);
     run->italic = style.style(ITALIC);
     run->baseline_type = style.baseline();
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
     run->weight = style.weight();
     int32_t script_item_break = 0;
     bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level);
     CHECK_GT(static_cast<size_t>(script_item_break), run_break);
+    CheckForcedDirection(&run->level);
     // Odd BiDi embedding levels correspond to RTL runs.
     run->is_rtl = (run->level % 2) == 1;
     // Find the length and script of this script run.
     script_item_break = ScriptInterval(text, run_break,
         script_item_break - run_break, &run->script) + run_break;
 
     // Find the next break and advance the iterators as needed.
     const size_t new_run_break = std::min(
         static_cast<size_t>(script_item_break),
         TextIndexToGivenTextIndex(text, style.GetRange().end()));
@@ skipping 308 matching lines @@
 
       attribute.strike = run.strike;
       attribute.diagonal_strike = run.diagonal_strike;
       decorated_text->attributes.push_back(attribute);
     }
   }
   return true;
 }
 
 }  // namespace gfx