[Smart Lock] Add a private API to show an error bubble anchored to the Smart Lock app window.

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 <limits>
 #include <vector>
 
 #include "base/strings/string_util.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/styled_label_listener.h"
 
@@ skipping 75 matching lines @@
 
 // StyledLabel ----------------------------------------------------------------
 
 // static
 const char StyledLabel::kViewClassName[] = "StyledLabel";
 
 StyledLabel::StyledLabel(const base::string16& text,
                          StyledLabelListener* listener)
     : specified_line_height_(0),
       listener_(listener),
+      width_at_last_size_calculation_(0),
       width_at_last_layout_(0),
       displayed_on_background_color_(SkColorSetRGB(0xFF, 0xFF, 0xFF)),
       displayed_on_background_color_set_(false),
       auto_color_readability_enabled_(true) {
   base::TrimWhitespace(text, base::TRIM_TRAILING, &text_);
 }
 
 StyledLabel::~StyledLabel() {}
 
 void StyledLabel::SetText(const base::string16& text) {
@@ skipping 40 matching lines @@
   displayed_on_background_color_ = color;
   displayed_on_background_color_set_ = true;
 
   for (int i = 0, count = child_count(); i < count; ++i) {
     DCHECK((child_at(i)->GetClassName() == Label::kViewClassName) ||
            (child_at(i)->GetClassName() == Link::kViewClassName));
     static_cast<Label*>(child_at(i))->SetBackgroundColor(color);
   }
 }
 
+void StyledLabel::SizeToFit(int max_width) {
+  if (max_width == 0)
+    max_width = std::numeric_limits<int>::max();
+
+  SetSize(CalculateAndDoLayout(max_width, true));
+}
+
 const char* StyledLabel::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Insets StyledLabel::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
 
   // We need a focus border iff we contain a link that will have a focus border.
   // That in turn will be true only if the link is non-empty.
   for (StyleRanges::const_iterator i(style_ranges_.begin());
         i != style_ranges_.end(); ++i) {
     if (i->style_info.is_link && !i->range.is_empty()) {
       const gfx::Insets focus_border_padding(
           Label::kFocusBorderPadding, Label::kFocusBorderPadding,
           Label::kFocusBorderPadding, Label::kFocusBorderPadding);
       insets += focus_border_padding;
       break;
     }
   }
 
   return insets;
 }
 
+gfx::Size StyledLabel::GetPreferredSize() const {
+  return calculated_size_;
+}
+
 int StyledLabel::GetHeightForWidth(int w) const {
   // TODO(erg): Munge the const-ness of the style label. CalculateAndDoLayout
   // doesn't actually make any changes to member variables when |dry_run| is
   // set to true. In general, the mutating and non-mutating parts shouldn't
   // be in the same codepath.
-  calculated_size_ =
-      const_cast<StyledLabel*>(this)->CalculateAndDoLayout(w, true);
-  return calculated_size_.height();
+  return const_cast<StyledLabel*>(this)->CalculateAndDoLayout(w, true).height();
 }
 
 void StyledLabel::Layout() {
-  calculated_size_ = CalculateAndDoLayout(GetLocalBounds().width(), false);
-  width_at_last_layout_ = calculated_size_.width();
+  CalculateAndDoLayout(GetLocalBounds().width(), false);
 }
 
 void StyledLabel::PreferredSizeChanged() {
   calculated_size_ = gfx::Size();
+  width_at_last_size_calculation_ = 0;
+  width_at_last_layout_ = 0;
   View::PreferredSizeChanged();
 }
 
 void StyledLabel::LinkClicked(Link* source, int event_flags) {
   if (listener_)
     listener_->StyledLabelLinkClicked(link_targets_[source], event_flags);
 }
 
 gfx::Size StyledLabel::CalculateAndDoLayout(int width, bool dry_run) {
+  if (width == width_at_last_size_calculation_ &&
+      (dry_run || width == width_at_last_layout_))
+    return calculated_size_;
+
+  width_at_last_size_calculation_ = width;
+  if (!dry_run)
+    width_at_last_layout_ = width;
+
   width -= GetInsets().width();
-  if (width == calculated_size_.width() &&
-      (dry_run || width_at_last_layout_ == width))
-    return calculated_size_;
 
   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_);
   // 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
   // bounds.
   int x = 0;
+  // The width that was actually used. Guaranteed to be no larger than |width|.
+  int used_width = 0;
 
   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) {
@@ skipping 85 matching lines @@
     const gfx::Size view_size = label->GetPreferredSize();
     if (!dry_run) {
       label->SetBoundsRect(gfx::Rect(
           gfx::Point(GetInsets().left() + x - focus_border_insets.left(),
                      GetInsets().top() + line * line_height -
                          focus_border_insets.top()),
           view_size));
       AddChildView(label.release());
     }
     x += view_size.width() - focus_border_insets.width();
+    used_width = std::max(used_width, x);
 
     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();
-  return gfx::Size(width, total_height);
+  calculated_size_ = gfx::Size(used_width + GetInsets().width(), total_height);
+  return calculated_size_;
 }
 
 }  // namespace views