Prepare to use gfx::RenderText in views::Label.

ui/gfx/render_text.cc

 // Copyright (c) 2012 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.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/command_line.h"
@@ skipping 451 matching lines @@
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
+  const int font_style = font_list.GetFontStyle();
+  SetStyle(BOLD, (font_style & gfx::Font::BOLD) != 0);
+  SetStyle(ITALIC, (font_style & gfx::Font::ITALIC) != 0);
+  SetStyle(UNDERLINE, (font_style & gfx::Font::UNDERLINE) != 0);
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 }
 
 void RenderText::SetCursorEnabled(bool cursor_enabled) {
   cursor_enabled_ = cursor_enabled;
   cached_bounds_and_offset_valid_ = false;
 }
 
@@ skipping 13 matching lines @@
 
 void RenderText::SetObscuredRevealIndex(int index) {
   if (obscured_reveal_index_ == index)
     return;
 
   obscured_reveal_index_ = index;
   cached_bounds_and_offset_valid_ = false;
   UpdateLayoutText();
 }
 
+void RenderText::SetReplaceNewlineCharsWithSymbols(bool replace) {
+  replace_newline_chars_with_symbols_ = replace;
+  cached_bounds_and_offset_valid_ = false;
+  UpdateLayoutText();
+}
+
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
   }
 }
 
 void RenderText::SetElideBehavior(ElideBehavior elide_behavior) {
   // TODO(skanuj) : Add a test for triggering layout change.
@@ skipping 416 matching lines @@
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       elide_behavior_(NO_ELIDE),
+      replace_newline_chars_with_symbols_(true),
       multiline_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
       cached_bounds_and_offset_valid_(false) {
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
@@ skipping 125 matching lines @@
                   0, intersection.length(), lines_[line].size.height());
         rects.push_back(rect + offset);
       }
       line_x += segment->x_range.length();
     }
   }
 
   return rects;
 }
 
+HorizontalAlignment RenderText::GetCurrentHorizontalAlignment() {
+  if (horizontal_alignment_ != ALIGN_TO_HEAD)
+    return horizontal_alignment_;
+  return GetTextDirection() == base::i18n::RIGHT_TO_LEFT ? ALIGN_RIGHT
+                                                         : ALIGN_LEFT;
+}
+
 Vector2d RenderText::GetAlignmentOffset(size_t line_number) {
   // TODO(ckocagil): Enable |lines_| usage in other platforms.
 #if defined(OS_WIN)
   DCHECK_LT(line_number, lines_.size());
 #endif
   Vector2d offset;
-  if (horizontal_alignment_ != ALIGN_LEFT) {
+  HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
+  if (horizontal_alignment != ALIGN_LEFT) {
 #if defined(OS_WIN)
     const int width = lines_[line_number].size.width() +
         (cursor_enabled_ ? 1 : 0);
 #else
     const int width = GetContentWidth();
 #endif
     offset.set_x(display_rect().width() - width);
-    if (horizontal_alignment_ == ALIGN_CENTER)
-      offset.set_x(offset.x() / 2);
+    // Put any extra margin pixel on the left to match legacy behavior.
+    if (horizontal_alignment == ALIGN_CENTER)
+      offset.set_x((offset.x() + 1) / 2);
   }
 
   // Vertically center the text.
   if (multiline_) {
     const int text_height = lines_.back().preceding_heights +
         lines_.back().size.height();
     offset.set_y((display_rect_.height() - text_height) / 2);
   } else {
     offset.set_y(GetBaseline() - GetLayoutTextBaseline());
   }
 
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   const int width = display_rect().width();
   if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
     return;
 
   const int gradient_width = CalculateFadeGradientWidth(font_list(), width);
   if (gradient_width == 0)
     return;
 
+  HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
   Rect solid_part = display_rect();
   Rect left_part;
   Rect right_part;
-  if (horizontal_alignment_ != ALIGN_LEFT) {
+  if (horizontal_alignment != ALIGN_LEFT) {
     left_part = solid_part;
     left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
     solid_part.Inset(gradient_width, 0, 0, 0);
   }
-  if (horizontal_alignment_ != ALIGN_RIGHT) {
+  if (horizontal_alignment != ALIGN_RIGHT) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
   skia::RefPtr<SkShader> shader = CreateFadeShader(
@@ skipping 79 matching lines @@
       !layout_text_.empty() && GetContentWidth() > display_rect_.width()) {
     // This doesn't trim styles so ellipsis may get rendered as a different
     // style than the preceding text. See crbug.com/327850.
     layout_text_.assign(
         Elide(layout_text_, display_rect_.width(), elide_behavior_));
   }
 
   // Replace the newline character with a newline symbol in single line mode.
   static const base::char16 kNewline[] = { '\n', 0 };
   static const base::char16 kNewlineSymbol[] = { 0x2424, 0 };
-  if (!multiline_)
+  if (!multiline_ && replace_newline_chars_with_symbols_)
     base::ReplaceChars(layout_text_, kNewline, kNewlineSymbol, &layout_text_);
 
   ResetLayout();
 }
 
 base::string16 RenderText::Elide(const base::string16& text,
                                  float available_width,
                                  ElideBehavior behavior) {
   if (available_width <= 0 || text.empty())
     return base::string16();
@@ skipping 160 matching lines @@
     delta_x = display_rect_.right() - cursor_bounds_.right();
   } else if (cursor_bounds_.x() < display_rect_.x()) {
     // TODO(xji): have similar problem as above when overflow character is a
     // LTR character.
     //
     // Pan to show the cursor when it overflows to the left.
     delta_x = display_rect_.x() - cursor_bounds_.x();
   } else if (display_offset_.x() != 0) {
     // Reduce the pan offset to show additional overflow text when the display
     // width increases.
-    const int negate_rtl = horizontal_alignment_ == ALIGN_RIGHT ? -1 : 1;
+    HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
+    const int negate_rtl = horizontal_alignment == ALIGN_RIGHT ? -1 : 1;
     const int offset = negate_rtl * display_offset_.x();
     if (display_width > (content_width + offset)) {
       delta_x = negate_rtl * (display_width - (content_width + offset));
     }
   }
 
   Vector2d delta_offset(delta_x, 0);
   display_offset_ += delta_offset;
   cursor_bounds_ += delta_offset;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx