tracing for RenderTextMac::GetDisplayText() eliding goo

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 513 matching lines @@
 
 void RenderText::SetElideBehavior(ElideBehavior elide_behavior) {
   // TODO(skanuj) : Add a test for triggering layout change.
   if (elide_behavior_ != elide_behavior) {
     elide_behavior_ = elide_behavior;
     OnDisplayTextAttributeChanged();
   }
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
+  DLOG(INFO) << "in SetDisplayRect.";
   if (r != display_rect_) {
     display_rect_ = r;
     baseline_ = kInvalidBaseline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
     if (elide_behavior_ != NO_ELIDE &&
         elide_behavior_ != FADE_TAIL) {
+      DLOG(INFO) << "via set display rect: " << GetDisplayText();
       OnDisplayTextAttributeChanged();
     }
   }
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursor(BreakType break_type,
@@ skipping 193 matching lines @@
 int RenderText::GetBaseline() {
   if (baseline_ == kInvalidBaseline)
     baseline_ = DetermineBaselineCenteringText(display_rect(), font_list());
   DCHECK_NE(kInvalidBaseline, baseline_);
   return baseline_;
 }
 
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
+  DLOG(INFO) << "Draw: " << GetDisplayText();
+
   if (clip_to_display_rect()) {
     Rect clip_rect(display_rect());
     clip_rect.Inset(ShadowValue::GetMargin(shadows_));
 
     canvas->Save();
     canvas->ClipRect(clip_rect);
   }
 
   if (!text().empty() && focused())
     DrawSelection(canvas);
@@ skipping 507 matching lines @@
   if (!multiline_ && replace_newline_chars_with_symbols_)
     base::ReplaceChars(layout_text_, kNewline, kNewlineSymbol, &layout_text_);
 
   OnLayoutTextAttributeChanged(true);
 }
 
 base::string16 RenderText::Elide(const base::string16& text,
                                  float text_width,
                                  float available_width,
                                  ElideBehavior behavior) {
+  DLOG(INFO) << "Elide: '" << text << "' " << text_width << ", " << available_width << ", " << behavior;
   if (available_width <= 0 || text.empty())
     return base::string16();
   if (behavior == ELIDE_EMAIL)
     return ElideEmail(text, available_width);
   if (text_width > 0 && text_width < available_width)
     return text;
 
   TRACE_EVENT0("ui", "RenderText::Elide");
 
   // Create a RenderText copy with attributes that affect the rendering width.
@@ skipping 12 matching lines @@
     return text;
 
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
   const bool elide_at_beginning = (behavior == ELIDE_HEAD);
 
   if (insert_ellipsis) {
     render_text->SetText(ellipsis);
     const float ellipsis_width = render_text->GetContentWidthF();
+    DLOG(INFO) << " added elipsis of width: "  << ellipsis_width;
     if (ellipsis_width > available_width)
       return base::string16();
   }
 
   StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
 
   // Use binary search to compute the elided text.
   size_t lo = 0;
   size_t hi = text.length() - 1;
   const base::i18n::TextDirection text_direction = GetTextDirection(text);
@@ skipping 15 matching lines @@
       base::i18n::TextDirection trailing_text_direction =
           base::i18n::GetLastStrongCharacterDirection(new_text);
       new_text.append(ellipsis);
       if (trailing_text_direction != text_direction) {
         if (trailing_text_direction == base::i18n::LEFT_TO_RIGHT)
           new_text += base::i18n::kLeftToRightMark;
         else
           new_text += base::i18n::kRightToLeftMark;
       }
       render_text->SetText(new_text);
+      DLOG(INFO) << "text set to: " << new_text;
     }
 
     // Restore styles. Make sure style ranges don't break new text graphemes.
     render_text->styles_ = styles_;
     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style) {
       BreakList<bool>& break_list = render_text->styles_[style];
       break_list.SetMax(render_text->text_.length());
       Range range;
       while (range.end() < break_list.max()) {
         BreakList<bool>::const_iterator current_break =
@@ skipping 16 matching lines @@
     if (guess_width > available_width) {
       hi = guess - 1;
       // Move back on the loop terminating condition when the guess is too wide.
       if (hi < lo)
         lo = hi;
     } else {
       lo = guess + 1;
     }
   }
 
+  DLOG(INFO) << "returning " << render_text->text();
+
   return render_text->text();
 }
 
 base::string16 RenderText::ElideEmail(const base::string16& email,
                                       float available_width) {
   // The returned string will have at least one character besides the ellipsis
   // on either side of '@'; if that's impossible, a single ellipsis is returned.
   // If possible, only the username is elided. Otherwise, the domain is elided
   // in the middle, splitting available width equally with the elided username.
   // If the username is short enough that it doesn't need half the available
@@ skipping 70 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx