StyledLabel: Added AddEmbeddedView method.

ui/views/controls/styled_label.cc

 // Copyright 2013 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/views/controls/styled_label.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <vector>
@@ skipping 114 matching lines @@
 }
 
 void StyledLabel::AddStyleRange(const gfx::Range& range,
                                 const RangeStyleInfo& style_info) {
   DCHECK(!range.is_reversed());
   DCHECK(!range.is_empty());
   DCHECK(gfx::Range(0, text_.size()).Contains(range));
 
   // Insert the new range in sorted order.
   StyleRanges new_range;
-  new_range.push_front(StyleRange(range, style_info));
+  new_range.push_front(StyleRange(range, style_info, nullptr));
   style_ranges_.merge(new_range);
 
   PreferredSizeChanged();
+}
+
+void StyledLabel::AddEmbeddedView(uint32_t position, scoped_ptr<View> view) {
+  DCHECK_LE(position, text_.size());
+  DCHECK(!view->parent());
+
+  // Set the view as owned by the StyledLabel so the Views hierarchy doesn't
+  // clean it up.
+  view->set_owned_by_client();
+
+  // Insert the new range in sorted order.
+  StyleRanges new_range;
+  embedded_views_.push_back(std::move(view));
+  new_range.push_front(StyleRange(gfx::Range(position, position),
+                                  RangeStyleInfo(),
+                                  embedded_views_.back().get()));
+  style_ranges_.merge(new_range);
+
+  PreferredSizeChanged();
 }
 
 void StyledLabel::SetDefaultStyle(const RangeStyleInfo& style_info) {
   default_style_info_ = style_info;
   PreferredSizeChanged();
 }
 
 void StyledLabel::SetLineHeight(int line_height) {
   specified_line_height_ = line_height;
   PreferredSizeChanged();
@@ skipping 84 matching lines @@
   width -= GetInsets().width();
 
   if (!dry_run) {
     RemoveAllChildViews(true);
     link_targets_.clear();
   }
 
   if (width <= 0 || text_.empty())
     return gfx::Size();
 
-  const int line_height = specified_line_height_ > 0 ? specified_line_height_
-      : CalculateLineHeight(font_list_);
+  const int usual_line_height = specified_line_height_ > 0
+                                    ? specified_line_height_
+                                    : CalculateLineHeight(font_list_);
   // The index of the line we're on.
   int line = 0;
-  // The x position (in pixels) of the line we're on, relative to content
+  // The x, y position (in pixels) of the line we're on, relative to content
   // bounds.
-  int x = 0;
+  int x = 0, y = 0;
   // The width that was actually used. Guaranteed to be no larger than |width|.
   int used_width = 0;
+  // The height of the actual current line. Guaranteed to be no smaller than
+  // |usual_line_height|.
+  int line_height = usual_line_height;
 
   base::string16 remaining_string = text_;
   StyleRanges::const_iterator current_range = style_ranges_.begin();
 
   // Iterate over the text, creating a bunch of labels and links and laying them
   // out in the appropriate positions.
   while (!remaining_string.empty()) {
     // Don't put whitespace at beginning of a line with an exception for the
     // first line (so the text's leading whitespace is respected).
     if (x == 0 && line > 0) {
       base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
                            &remaining_string);
     }
 
     gfx::Range range(gfx::Range::InvalidRange());
     if (current_range != style_ranges_.end())
       range = current_range->range;
 
     const size_t position = text_.size() - remaining_string.size();
 
-    const gfx::Rect chunk_bounds(x, 0, width - x, 2 * line_height);
+    const gfx::Rect chunk_bounds(x, 0, width - x, 2 * usual_line_height);
     std::vector<base::string16> substrings;
     gfx::FontList text_font_list = font_list_;
     // If the start of the remaining text is inside a styled range, the font
     // style may differ from the base font. The font specified by the range
     // should be used when eliding text.
     if (position >= range.start()) {
       text_font_list = text_font_list.DeriveWithStyle(
           current_range->style_info.font_style);
     }
     gfx::ElideRectangleText(remaining_string,
@@ skipping 11 matching lines @@
       if (x == 0) {
         if (line == 0) {
           base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
                                &remaining_string);
           continue;
         }
         break;
       }
 
       x = 0;
+      y += line_height;
+      line_height = usual_line_height;
       line++;
       continue;
     }
 
     base::string16 chunk = substrings[0];
 
+    View* view = current_range->embedded_view;
     scoped_ptr<Label> label;
     if (position >= range.start()) {
+      if (view)
+        line_height = std::max(line_height, view->GetPreferredSize().height());
+
       const RangeStyleInfo& style_info = current_range->style_info;
 
       if (style_info.disable_line_wrapping && chunk.size() < range.length() &&
           position == range.start() && x != 0) {
         // If the chunk should not be wrapped, try to fit it entirely on the
         // next line.
         x = 0;
+        y += line_height;
+        line_height = usual_line_height;
         line++;
         continue;
       }
 
       if (chunk.size() > range.end() - position)
         chunk = chunk.substr(0, range.end() - position);
 
-      label = CreateLabelRange(chunk, font_list_, style_info, this);
+      if (!view) {
+        label = CreateLabelRange(chunk, font_list_, style_info, this);
 
-      if (style_info.is_link && !dry_run)
-        link_targets_[label.get()] = range;
+        if (style_info.is_link && !dry_run)
+          link_targets_[label.get()] = range;
+      }
 
       if (position + chunk.size() >= range.end())
         ++current_range;
     } else {
       // This chunk is normal text.
       if (position + chunk.size() > range.start())
         chunk = chunk.substr(0, range.start() - position);
       label = CreateLabelRange(chunk, font_list_, default_style_info_, this);
     }
 
-    if (displayed_on_background_color_set_)
-      label->SetBackgroundColor(displayed_on_background_color_);
-    label->SetAutoColorReadabilityEnabled(auto_color_readability_enabled_);
+    if (label) {
+      if (displayed_on_background_color_set_)
+        label->SetBackgroundColor(displayed_on_background_color_);
+      label->SetAutoColorReadabilityEnabled(auto_color_readability_enabled_);
+
+      // |view| temporarily owns the pointer to the Label. This will be owned by
+      // the views hierarchy.
+      view = label.release();
+    }
 
     // Calculate the size of the optional focus border, and overlap by that
     // amount. Otherwise, "<a>link</a>," will render as "link ,".
-    gfx::Insets focus_border_insets(label->GetInsets());
-    focus_border_insets += -label->View::GetInsets();
-    const gfx::Size view_size = label->GetPreferredSize();
+    gfx::Insets focus_border_insets(view->GetInsets());
+    focus_border_insets += -view->View::GetInsets();
+    const gfx::Size view_size = view->GetPreferredSize();
     if (!dry_run) {
-      label->SetBoundsRect(gfx::Rect(
+      view->SetBoundsRect(gfx::Rect(
           gfx::Point(GetInsets().left() + x - focus_border_insets.left(),
-                     GetInsets().top() + line * line_height -
-                         focus_border_insets.top()),
+                     GetInsets().top() + y - focus_border_insets.top()),
           view_size));
-      AddChildView(label.release());
+
+      // Ownership: If |view| came from a Label created above, it will be owned
+      // by the views hierarchy from now on. If |view| came from an externally
+      // supplied embedded view, it will continue to be owned by the
+      // |embedded_views_| vector.
+      AddChildView(view);
     }
     x += view_size.width() - focus_border_insets.width();
     used_width = std::max(used_width, x);
 
     // If |gfx::ElideRectangleText| returned more than one substring, that
     // means the whole text did not fit into remaining line width, with text
     // after |susbtring[0]| spilling into next line. If whole |substring[0]|
     // was added to the current line (this may not be the case if part of the
     // substring has different style), proceed to the next line.
     if (substrings.size() > 1 && chunk.size() == substrings[0].size()) {
       x = 0;
+      y += line_height;
+      line_height = usual_line_height;
       ++line;
     }
 
     remaining_string = remaining_string.substr(chunk.size());
   }
 
   DCHECK_LE(used_width, width);
   // The user-specified line height only applies to interline spacing, so the
   // final line's height is unaffected.
-  int total_height = line * line_height +
-      CalculateLineHeight(font_list_) + GetInsets().height();
+  // TODO(mgiuca): I think this makes a bad assumption about the final line.
+  int total_height = y + CalculateLineHeight(font_list_) + GetInsets().height();
   calculated_size_ = gfx::Size(used_width + GetInsets().width(), total_height);
   return calculated_size_;
 }
 
 }  // namespace views