Prefix string16 with base:: in ui/.

ui/views/controls/label.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/views/controls/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
@@ skipping 26 matching lines @@
 }
 
 }  // namespace
 
 namespace views {
 
 // static
 const char Label::kViewClassName[] = "Label";
 
 Label::Label() {
-  Init(string16(), GetDefaultFontList());
+  Init(base::string16(), GetDefaultFontList());
 }
 
-Label::Label(const string16& text) {
+Label::Label(const base::string16& text) {
   Init(text, GetDefaultFontList());
 }
 
-Label::Label(const string16& text, const gfx::FontList& font_list) {
+Label::Label(const base::string16& text, const gfx::FontList& font_list) {
   Init(text, font_list);
 }
 
-Label::Label(const string16& text, const gfx::Font& font) {
+Label::Label(const base::string16& text, const gfx::Font& font) {
   Init(text, gfx::FontList(font));
 }
 
 Label::~Label() {
 }
 
 void Label::SetFontList(const gfx::FontList& font_list) {
   font_list_ = font_list;
   ResetCachedSize();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 const gfx::Font& Label::font() const {
   return font_list_.GetPrimaryFont();
 }
 
 void Label::SetFont(const gfx::Font& font) {
   SetFontList(gfx::FontList(font));
 }
 
-void Label::SetText(const string16& text) {
+void Label::SetText(const base::string16& text) {
   if (text == text_)
     return;
   text_ = text;
   ResetCachedSize();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 void Label::SetAutoColorReadabilityEnabled(bool enabled) {
   auto_color_readability_ = enabled;
@@ skipping 78 matching lines @@
 void Label::SetElideBehavior(ElideBehavior elide_behavior) {
   DCHECK(elide_behavior != ELIDE_IN_MIDDLE || !is_multi_line_);
   if (elide_behavior != elide_behavior_) {
     elide_behavior_ = elide_behavior;
     ResetCachedSize();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
-void Label::SetTooltipText(const string16& tooltip_text) {
+void Label::SetTooltipText(const base::string16& tooltip_text) {
   tooltip_text_ = tooltip_text;
 }
 
 void Label::SizeToFit(int max_width) {
   DCHECK(is_multi_line_);
 
-  std::vector<string16> lines;
+  std::vector<base::string16> lines;
   base::SplitString(text_, '\n', &lines);
 
   int label_width = 0;
-  for (std::vector<string16>::const_iterator iter = lines.begin();
+  for (std::vector<base::string16>::const_iterator iter = lines.begin();
        iter != lines.end(); ++iter) {
     label_width = std::max(label_width, gfx::GetStringWidth(*iter, font_list_));
   }
 
   label_width += GetInsets().width();
 
   if (max_width > 0)
     label_width = std::min(label_width, max_width);
 
   SetBounds(x(), y(), label_width, 0);
@@ skipping 74 matching lines @@
   if (tooltip_text_.empty() && !ShouldShowDefaultTooltip())
     return NULL;
 
   return this;
 }
 
 bool Label::HitTestRect(const gfx::Rect& rect) const {
   return false;
 }
 
-bool Label::GetTooltipText(const gfx::Point& p, string16* tooltip) const {
+bool Label::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
   DCHECK(tooltip);
 
   // If a tooltip has been explicitly set, use it.
   if (!tooltip_text_.empty()) {
     tooltip->assign(tooltip_text_);
     return true;
   }
 
   // Show the full text if the text does not fit.
   if (ShouldShowDefaultTooltip()) {
     *tooltip = text_;
     return true;
   }
 
   return false;
 }
 
 void Label::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_STATICTEXT;
   state->state = ui::AccessibilityTypes::STATE_READONLY;
   state->name = text_;
 }
 
 void Label::PaintText(gfx::Canvas* canvas,
-                      const string16& text,
+                      const base::string16& text,
                       const gfx::Rect& text_bounds,
                       int flags) {
   gfx::ShadowValues shadows;
   if (has_shadow_)
     shadows.push_back(gfx::ShadowValue(shadow_offset_, 0,
         enabled() ? enabled_shadow_color_ : disabled_shadow_color_));
   canvas->DrawStringRectWithShadows(text, font_list_,
       enabled() ? actual_enabled_color_ : actual_disabled_color_,
       text_bounds, line_height_, flags, shadows);
 
@@ skipping 30 matching lines @@
   text_size_valid_ &= !is_multi_line_;
 }
 
 void Label::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   // We skip painting the focus border because it is being handled seperately by
   // some subclasses of Label. We do not want View's focus border painting to
   // interfere with that.
   OnPaintBorder(canvas);
 
-  string16 paint_text;
+  base::string16 paint_text;
   gfx::Rect text_bounds;
   int flags = 0;
   CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   PaintText(canvas, paint_text, text_bounds, flags);
 }
 
 void Label::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   UpdateColorsFromTheme(theme);
 }
 
-void Label::Init(const string16& text, const gfx::FontList& font_list) {
+void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
   font_list_ = font_list;
   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
   auto_color_readability_ = true;
   UpdateColorsFromTheme(ui::NativeTheme::instance());
   horizontal_alignment_ = gfx::ALIGN_CENTER;
   line_height_ = 0;
   is_multi_line_ = false;
   allow_character_break_ = false;
   elide_behavior_ = ELIDE_AT_END;
   collapse_when_hidden_ = false;
@@ skipping 95 matching lines @@
 
   return flags;
 }
 
 gfx::Rect Label::GetAvailableRect() const {
   gfx::Rect bounds(size());
   bounds.Inset(GetInsets());
   return bounds;
 }
 
-void Label::CalculateDrawStringParams(string16* paint_text,
+void Label::CalculateDrawStringParams(base::string16* paint_text,
                                       gfx::Rect* text_bounds,
                                       int* flags) const {
   DCHECK(paint_text && text_bounds && flags);
 
   // TODO(msw): Use ElideRectangleText to support eliding multi-line text.  Once
   // this is done, we can set NO_ELLIPSIS unconditionally at the bottom.
   if (is_multi_line_ || (elide_behavior_ == NO_ELIDE)) {
     *paint_text = text_;
   } else if (elide_behavior_ == ELIDE_IN_MIDDLE) {
     *paint_text = gfx::ElideText(text_, font_list_, GetAvailableRect().width(),
@@ skipping 35 matching lines @@
   for (int i = 0; i < kCachedSizeLimit; ++i)
     cached_heights_[i] = gfx::Size();
 }
 
 bool Label::ShouldShowDefaultTooltip() const {
   return !is_multi_line_ &&
       gfx::GetStringWidth(text_, font_list_) > GetAvailableRect().width();
 }
 
 }  // namespace views