Prefix string16 with base:: in ui/.

ui/views/controls/menu/menu_item_view.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/menu/menu_item_view.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ui_resources.h"
@@ skipping 29 matching lines @@
  public:
   explicit EmptyMenuMenuItem(MenuItemView* parent)
       : MenuItemView(parent, 0, EMPTY) {
     // Set this so that we're not identified as a normal menu item.
     set_id(kEmptyMenuItemViewID);
     SetTitle(l10n_util::GetStringUTF16(IDS_APP_MENU_EMPTY_SUBMENU));
     SetEnabled(false);
   }
 
   virtual bool GetTooltipText(const gfx::Point& p,
-                              string16* tooltip) const OVERRIDE {
+                              base::string16* tooltip) const OVERRIDE {
     // Empty menu items shouldn't have a tooltip.
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EmptyMenuMenuItem);
 };
 
 }  // namespace
 
@@ skipping 48 matching lines @@
   // NULL delegate.
   Init(NULL, 0, SUBMENU, delegate);
 }
 
 void MenuItemView::ChildPreferredSizeChanged(View* child) {
   invalidate_dimensions();
   PreferredSizeChanged();
 }
 
 bool MenuItemView::GetTooltipText(const gfx::Point& p,
-                                  string16* tooltip) const {
+                                  base::string16* tooltip) const {
   *tooltip = tooltip_;
   if (!tooltip->empty())
     return true;
 
   if (GetType() == SEPARATOR)
     return false;
 
   const MenuController* controller = GetMenuController();
   if (!controller || controller->exit_type() != MenuController::EXIT_NONE) {
     // Either the menu has been closed or we're in the process of closing the
@@ skipping 13 matching lines @@
   CHECK(delegate);
   gfx::Point location(p);
   ConvertPointToScreen(this, &location);
   *tooltip = delegate->GetTooltipText(command_, location);
   return !tooltip->empty();
 }
 
 void MenuItemView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_MENUITEM;
 
-  string16 item_text;
+  base::string16 item_text;
   if (IsContainer()) {
     // The first child is taking over, just use its accessible name instead of
     // |title_|.
     View* child = child_at(0);
     ui::AccessibleViewState state;
     child->GetAccessibleState(&state);
     item_text = state.name;
   } else {
     item_text = title_;
   }
@@ skipping 18 matching lines @@
 
 // static
 bool MenuItemView::IsBubble(MenuItemView::AnchorPosition anchor) {
   return anchor == MenuItemView::BUBBLE_LEFT ||
          anchor == MenuItemView::BUBBLE_RIGHT ||
          anchor == MenuItemView::BUBBLE_ABOVE ||
          anchor == MenuItemView::BUBBLE_BELOW;
 }
 
 // static
-string16 MenuItemView::GetAccessibleNameForMenuItem(
-      const string16& item_text, const string16& minor_text) {
-  string16 accessible_name = item_text;
+base::string16 MenuItemView::GetAccessibleNameForMenuItem(
+      const base::string16& item_text, const base::string16& minor_text) {
+  base::string16 accessible_name = item_text;
 
   // Filter out the "&" for accessibility clients.
   size_t index = 0;
   const char16 amp = '&';
-  while ((index = accessible_name.find(amp, index)) != string16::npos &&
+  while ((index = accessible_name.find(amp, index)) != base::string16::npos &&
          index + 1 < accessible_name.length()) {
     accessible_name.replace(index, accessible_name.length() - index,
                             accessible_name.substr(index + 1));
 
     // Special case for "&&" (escaped for "&").
     if (accessible_name[index] == '&')
       ++index;
   }
 
   // Append subtext.
   if (!minor_text.empty()) {
     accessible_name.push_back(' ');
     accessible_name.append(minor_text);
   }
 
   return accessible_name;
 }
 
 void MenuItemView::Cancel() {
   if (controller_ && !canceled_) {
     canceled_ = true;
     controller_->Cancel(MenuController::EXIT_ALL);
   }
 }
 
 MenuItemView* MenuItemView::AddMenuItemAt(
     int index,
     int item_id,
-    const string16& label,
-    const string16& sublabel,
-    const string16& minor_text,
+    const base::string16& label,
+    const base::string16& sublabel,
+    const base::string16& minor_text,
     const gfx::ImageSkia& icon,
     Type type,
     ui::MenuSeparatorType separator_style) {
   DCHECK_NE(type, EMPTY);
   DCHECK_LE(0, index);
   if (!submenu_)
     CreateSubmenu();
   DCHECK_GE(submenu_->child_count(), index);
   if (type == SEPARATOR) {
     submenu_->AddChildViewAt(new MenuSeparator(this, separator_style), index);
@@ skipping 23 matching lines @@
   DCHECK(item);
   submenu_->RemoveChildView(item);
 
   // RemoveChildView() does not delete the item, which is a good thing
   // in case a submenu is being displayed while items are being removed.
   // Deletion will be done by ChildrenChanged() or at destruction.
   removed_items_.push_back(item);
 }
 
 MenuItemView* MenuItemView::AppendMenuItem(int item_id,
-                                           const string16& label,
+                                           const base::string16& label,
                                            Type type) {
-  return AppendMenuItemImpl(item_id, label, string16(), string16(),
+  return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
       gfx::ImageSkia(), type, ui::NORMAL_SEPARATOR);
 }
 
 MenuItemView* MenuItemView::AppendSubMenu(int item_id,
-                                          const string16& label) {
-  return AppendMenuItemImpl(item_id, label, string16(), string16(),
+                                          const base::string16& label) {
+  return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
       gfx::ImageSkia(), SUBMENU, ui::NORMAL_SEPARATOR);
 }
 
 MenuItemView* MenuItemView::AppendSubMenuWithIcon(int item_id,
-                                                  const string16& label,
+                                                  const base::string16& label,
                                                   const gfx::ImageSkia& icon) {
-  return AppendMenuItemImpl(item_id, label, string16(), string16(), icon,
-      SUBMENU, ui::NORMAL_SEPARATOR);
+  return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
+                            icon, SUBMENU, ui::NORMAL_SEPARATOR);
 }
 
-MenuItemView* MenuItemView::AppendMenuItemWithLabel(int item_id,
-                                                    const string16& label) {
+MenuItemView* MenuItemView::AppendMenuItemWithLabel(
+    int item_id,
+    const base::string16& label) {
   return AppendMenuItem(item_id, label, NORMAL);
 }
 
 MenuItemView* MenuItemView::AppendDelegateMenuItem(int item_id) {
-  return AppendMenuItem(item_id, string16(), NORMAL);
+  return AppendMenuItem(item_id, base::string16(), NORMAL);
 }
 
 void MenuItemView::AppendSeparator() {
-  AppendMenuItemImpl(0, string16(), string16(), string16(), gfx::ImageSkia(),
-                     SEPARATOR, ui::NORMAL_SEPARATOR);
+  AppendMenuItemImpl(0, base::string16(), base::string16(), base::string16(),
+                     gfx::ImageSkia(), SEPARATOR, ui::NORMAL_SEPARATOR);
 }
 
 MenuItemView* MenuItemView::AppendMenuItemWithIcon(int item_id,
-                                                   const string16& label,
+                                                   const base::string16& label,
                                                    const gfx::ImageSkia& icon) {
-  return AppendMenuItemImpl(item_id, label, string16(), string16(), icon,
-      NORMAL, ui::NORMAL_SEPARATOR);
+  return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
+                            icon, NORMAL, ui::NORMAL_SEPARATOR);
 }
 
 MenuItemView* MenuItemView::AppendMenuItemImpl(
     int item_id,
-    const string16& label,
-    const string16& sublabel,
-    const string16& minor_text,
+    const base::string16& label,
+    const base::string16& sublabel,
+    const base::string16& minor_text,
     const gfx::ImageSkia& icon,
     Type type,
     ui::MenuSeparatorType separator_style) {
   const int index = submenu_ ? submenu_->child_count() : 0;
   return AddMenuItemAt(index, item_id, label, sublabel, minor_text, icon, type,
                        separator_style);
 }
 
 SubmenuView* MenuItemView::CreateSubmenu() {
   if (!submenu_)
     submenu_ = new SubmenuView(this);
   return submenu_;
 }
 
 bool MenuItemView::HasSubmenu() const {
   return (submenu_ != NULL);
 }
 
 SubmenuView* MenuItemView::GetSubmenu() const {
   return submenu_;
 }
 
-void MenuItemView::SetTitle(const string16& title) {
+void MenuItemView::SetTitle(const base::string16& title) {
   title_ = title;
   invalidate_dimensions();  // Triggers preferred size recalculation.
 }
 
-void MenuItemView::SetSubtitle(const string16& subtitle) {
+void MenuItemView::SetSubtitle(const base::string16& subtitle) {
   subtitle_ = subtitle;
   invalidate_dimensions();  // Triggers preferred size recalculation.
 }
 
-void MenuItemView::SetMinorText(const string16& minor_text) {
+void MenuItemView::SetMinorText(const base::string16& minor_text) {
   minor_text_ = minor_text;
   invalidate_dimensions();  // Triggers preferred size recalculation.
 }
 
 void MenuItemView::SetSelected(bool selected) {
   selected_ = selected;
   SchedulePaint();
 }
 
-void MenuItemView::SetTooltip(const string16& tooltip, int item_id) {
+void MenuItemView::SetTooltip(const base::string16& tooltip, int item_id) {
   MenuItemView* item = GetMenuItemByID(item_id);
   DCHECK(item);
   item->tooltip_ = tooltip;
 }
 
 void MenuItemView::SetIcon(const gfx::ImageSkia& icon, int item_id) {
   MenuItemView* item = GetMenuItemByID(item_id);
   DCHECK(item);
   item->SetIcon(icon);
 }
@@ skipping 69 matching lines @@
   return item;
 }
 
 char16 MenuItemView::GetMnemonic() {
   if (!GetRootMenuItem()->has_mnemonics_)
     return 0;
 
   size_t index = 0;
   do {
     index = title_.find('&', index);
-    if (index != string16::npos) {
+    if (index != base::string16::npos) {
       if (index + 1 != title_.size() && title_[index + 1] != '&') {
         char16 char_array[] = { title_[index + 1], 0 };
         // TODO(jshin): What about Turkish locale? See http://crbug.com/81719.
         // If the mnemonic is capital I and the UI language is Turkish,
         // lowercasing it results in 'small dotless i', which is different
         // from a 'dotted i'. Similar issues may exist for az and lt locales.
         return base::i18n::ToLower(char_array)[0];
       }
       index++;
     }
-  } while (index != string16::npos);
+  } while (index != base::string16::npos);
   return 0;
 }
 
 MenuItemView* MenuItemView::GetMenuItemByID(int id) {
   if (GetCommand() == id)
     return this;
   if (!HasSubmenu())
     return NULL;
   for (int i = 0; i < GetSubmenu()->child_count(); ++i) {
     View* child = GetSubmenu()->child_at(i);
@@ skipping 370 matching lines @@
                                          config.arrow_width) / 2,
                            config.arrow_width, height());
     AdjustBoundsForRTLUI(&arrow_bounds);
     canvas->DrawImageInt(GetSubmenuArrowImage(IsSelected()),
                          arrow_bounds.x(), arrow_bounds.y());
   }
 }
 
 void MenuItemView::PaintMinorText(gfx::Canvas* canvas,
                                   bool render_selection) {
-  string16 minor_text = GetMinorText();
+  base::string16 minor_text = GetMinorText();
   if (minor_text.empty())
     return;
 
   const gfx::Font& font = GetFont();
   int available_height = height() - GetTopMargin() - GetBottomMargin();
   int max_accel_width =
       parent_menu_item_->GetSubmenu()->max_minor_text_width();
   const MenuConfig& config = GetMenuConfig();
   int accel_right_margin = config.align_arrow_and_shortcut ?
                            config.arrow_to_edge_padding :  item_right_margin_;
@@ skipping 112 matching lines @@
   }
   int label_start = GetLabelStartForThisItem();
 
   int string_width = font.GetStringWidth(title_);
   if (!subtitle_.empty())
     string_width = std::max(string_width, font.GetStringWidth(subtitle_));
 
   dimensions.standard_width = string_width + label_start +
       item_right_margin_;
   // Determine the length of the right-side text.
-  string16 minor_text = GetMinorText();
+  base::string16 minor_text = GetMinorText();
   dimensions.minor_text_width =
       minor_text.empty() ? 0 : GetFont().GetStringWidth(minor_text);
 
   // Determine the height to use.
   dimensions.height = std::max(dimensions.height,
       (subtitle_.empty() ? 0 : font.GetHeight()) +
       font.GetHeight() + GetBottomMargin() + GetTopMargin());
   dimensions.height = std::max(dimensions.height,
       GetMenuConfig().item_min_height);
   return dimensions;
 }
 
 int MenuItemView::GetLabelStartForThisItem() {
   int label_start = label_start_ + left_icon_margin_ + right_icon_margin_;
   if ((type_ == CHECKBOX || type_ == RADIO) && icon_view_) {
     label_start += icon_view_->size().width() +
         GetMenuConfig().icon_to_label_padding;
   }
   return label_start;
 }
 
-string16 MenuItemView::GetMinorText() {
+base::string16 MenuItemView::GetMinorText() {
   if (id() == kEmptyMenuItemViewID) {
     // Don't query the delegate for menus that represent no children.
-    return string16();
+    return base::string16();
   }
 
   ui::Accelerator accelerator;
   if (GetMenuConfig().show_accelerators && GetDelegate() && GetCommand() &&
           GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) {
     return accelerator.GetShortcutText();
   }
 
   return minor_text_;
 }
@@ skipping 39 matching lines @@
     } else {
       const Type& type = menu_item->GetType();
       if (type == CHECKBOX || type == RADIO)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace views