Prefix string16 with base:: in ui/.

ui/message_center/views/bounded_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/message_center/views/bounded_label.h"
 
 #include <limits>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 22 matching lines @@
 class InnerBoundedLabel : public views::Label {
  public:
   InnerBoundedLabel(const BoundedLabel& owner);
   virtual ~InnerBoundedLabel();
 
   void SetNativeTheme(const ui::NativeTheme* theme);
 
   // Pass in a -1 width to use the preferred width, a -1 limit to skip limits.
   int GetLinesForWidthAndLimit(int width, int limit);
   gfx::Size GetSizeForWidthAndLines(int width, int lines);
-  std::vector<string16> GetWrappedText(int width, int lines);
+  std::vector<base::string16> GetWrappedText(int width, int lines);
 
  protected:
   // Overridden from views::Label.
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
  private:
   int GetTextFlags();
 
   void ClearCaches();
   int GetCachedLines(int width);
   void SetCachedLines(int width, int lines);
   gfx::Size GetCachedSize(const std::pair<int, int>& width_and_lines);
   void SetCachedSize(std::pair<int, int> width_and_lines, gfx::Size size);
 
   const BoundedLabel* owner_;  // Weak reference.
-  string16 wrapped_text_;
+  base::string16 wrapped_text_;
   int wrapped_text_width_;
   int wrapped_text_lines_;
   std::map<int, int> lines_cache_;
   std::list<int> lines_widths_;  // Most recently used in front.
   std::map<std::pair<int, int>, gfx::Size> size_cache_;
   std::list<std::pair<int, int> > size_widths_and_lines_;  // Recent in front.
 
   DISALLOW_COPY_AND_ASSIGN(InnerBoundedLabel);
 };
 
@@ skipping 30 matching lines @@
 gfx::Size InnerBoundedLabel::GetSizeForWidthAndLines(int width, int lines) {
   if (width == 0 || lines == 0)
     return gfx::Size();
   std::pair<int, int> key(width, lines);
   gfx::Size size = GetCachedSize(key);
   if (size.height() == std::numeric_limits<int>::max()) {
     gfx::Insets insets = owner_->GetInsets();
     int text_width = (width < 0) ? std::numeric_limits<int>::max() :
                                    std::max(width - insets.width(), 0);
     int text_height = std::numeric_limits<int>::max();
-    std::vector<string16> wrapped = GetWrappedText(text_width, lines);
+    std::vector<base::string16> wrapped = GetWrappedText(text_width, lines);
     gfx::Canvas::SizeStringInt(JoinString(wrapped, '\n'), font(),
                                &text_width, &text_height,
                                owner_->GetLineHeight(),
                                GetTextFlags());
     size.set_width(text_width + insets.width());
     size.set_height(text_height + insets.height());
     SetCachedSize(key, size);
   }
   return size;
 }
 
-std::vector<string16> InnerBoundedLabel::GetWrappedText(int width, int lines) {
+std::vector<base::string16> InnerBoundedLabel::GetWrappedText(int width,
+                                                              int lines) {
   // Short circuit simple case.
   if (width == 0 || lines == 0)
-    return std::vector<string16>();
+    return std::vector<base::string16>();
 
   // Restrict line limit to ensure (lines + 1) * line_height <= INT_MAX and
   // use it to calculate a reasonable text height.
   int height = std::numeric_limits<int>::max();
   if (lines > 0) {
     int line_height = std::max(font().GetHeight(), 2);  // At least 2 pixels.
     int max_lines = std::numeric_limits<int>::max() / line_height - 1;
     lines = std::min(lines, max_lines);
     height = (lines + 1) * line_height;
   }
 
   // Try to ensure that the width is no smaller than the width of the text's
   // characters to avoid the http://crbug.com/237700 infinite loop.
   // TODO(dharcourt): Remove when http://crbug.com/237700 is fixed.
   width = std::max(width, 2 * font().GetStringWidth(UTF8ToUTF16("W")));
 
   // Wrap, using INT_MAX for -1 widths that indicate no wrapping.
-  std::vector<string16> wrapped;
+  std::vector<base::string16> wrapped;
   gfx::ElideRectangleText(text(), font_list(),
                           (width < 0) ? std::numeric_limits<int>::max() : width,
                           height, gfx::WRAP_LONG_WORDS, &wrapped);
 
   // Elide if necessary.
   if (lines > 0 && wrapped.size() > static_cast<unsigned int>(lines)) {
     // Add an ellipsis to the last line. If this ellipsis makes the last line
     // too wide, that line will be further elided by the gfx::ElideText below,
     // so for example "ABC" could become "ABC..." and then "AB...".
-    string16 last = wrapped[lines - 1] + UTF8ToUTF16(gfx::kEllipsis);
+    base::string16 last = wrapped[lines - 1] + UTF8ToUTF16(gfx::kEllipsis);
     if (width > 0 && font().GetStringWidth(last) > width)
       last = gfx::ElideText(last, font(), width, gfx::ELIDE_AT_END);
     wrapped.resize(lines - 1);
     wrapped.push_back(last);
   }
 
   return wrapped;
 }
 
 void InnerBoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) {
@@ skipping 85 matching lines @@
   if (size_cache_.size() >= kPreferredLinesCacheSize) {
     size_cache_.erase(size_widths_and_lines_.back());
     size_widths_and_lines_.pop_back();
   }
   size_cache_[width_and_lines] = size;
   size_widths_and_lines_.push_front(width_and_lines);
 }
 
 // BoundedLabel ///////////////////////////////////////////////////////////
 
-BoundedLabel::BoundedLabel(const string16& text, const gfx::FontList& font_list)
+BoundedLabel::BoundedLabel(const base::string16& text,
+                           const gfx::FontList& font_list)
     : line_limit_(-1) {
   label_.reset(new InnerBoundedLabel(*this));
   label_->SetFontList(font_list);
   label_->SetText(text);
 }
 
-BoundedLabel::BoundedLabel(const string16& text)
+BoundedLabel::BoundedLabel(const base::string16& text)
     : line_limit_(-1) {
   label_.reset(new InnerBoundedLabel(*this));
   label_->SetText(text);
 }
 
 BoundedLabel::~BoundedLabel() {
 }
 
 void BoundedLabel::SetColors(SkColor textColor, SkColor backgroundColor) {
   label_->SetEnabledColor(textColor);
@@ skipping 53 matching lines @@
 
 void BoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   label_->SetBoundsRect(bounds());
   views::View::OnBoundsChanged(previous_bounds);
 }
 
 void BoundedLabel::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   label_->SetNativeTheme(theme);
 }
 
-string16 BoundedLabel::GetWrappedTextForTest(int width, int lines) {
+base::string16 BoundedLabel::GetWrappedTextForTest(int width, int lines) {
   return JoinString(label_->GetWrappedText(width, lines), '\n');
 }
 
 }  // namespace message_center