Prefix string16 with base:: in ui/.

ui/views/controls/menu/menu_item_view.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 114 matching lines @@
     // The height of the menu item.
     int height;
   };
 
   // Constructor for use with the top level menu item. This menu is never
   // shown to the user, rather its use as the parent for all menu items.
   explicit MenuItemView(MenuDelegate* delegate);
 
   // Overridden from View:
   virtual bool GetTooltipText(const gfx::Point& p,
-                              string16* tooltip) const OVERRIDE;
+                              base::string16* tooltip) const OVERRIDE;
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
 
   // Returns the preferred height of menu items. This is only valid when the
   // menu is about to be shown.
   static int pref_menu_height() { return pref_menu_height_; }
 
   // X-coordinate of where the label starts.
   static int label_start() { return label_start_; }
 
   // Returns if a given |anchor| is a bubble or not.
   static bool IsBubble(MenuItemView::AnchorPosition anchor);
 
   // Returns the accessible name to be used with screen readers. Mnemonics are
   // removed and the menu item accelerator text is appended.
-  static string16 GetAccessibleNameForMenuItem(
-      const string16& item_text, const string16& accelerator_text);
+  static base::string16 GetAccessibleNameForMenuItem(
+      const base::string16& item_text, const base::string16& accelerator_text);
 
   // Hides and cancels the menu. This does nothing if the menu is not open.
   void Cancel();
 
   // Add an item to the menu at a specified index.  ChildrenChanged() should
   // called after adding menu items if the menu may be active.
   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);
 
   // Remove an item from the menu at a specified index. The removed MenuItemView
   // is deleted when ChildrenChanged() is invoked.
   void RemoveMenuItemAt(int index);
 
   // Appends an item to this menu.
   // item_id    The id of the item, used to identify it in delegate callbacks
   //            or (if delegate is NULL) to identify the command associated
   //            with this item with the controller specified in the ctor. Note
   //            that this value should not be 0 as this has a special meaning
   //            ("NULL command, no item selected")
   // label      The text label shown.
   // type       The type of item.
   MenuItemView* AppendMenuItem(int item_id,
-                               const string16& label,
+                               const base::string16& label,
                                Type type);
 
   // Append a submenu to this menu.
   // The returned pointer is owned by this menu.
   MenuItemView* AppendSubMenu(int item_id,
-                              const string16& label);
+                              const base::string16& label);
 
   // Append a submenu with an icon to this menu.
   // The returned pointer is owned by this menu.
   MenuItemView* AppendSubMenuWithIcon(int item_id,
-                                      const string16& label,
+                                      const base::string16& label,
                                       const gfx::ImageSkia& icon);
 
   // This is a convenience for standard text label menu items where the label
   // is provided with this call.
   MenuItemView* AppendMenuItemWithLabel(int item_id,
-                                        const string16& label);
+                                        const base::string16& label);
 
   // This is a convenience for text label menu items where the label is
   // provided by the delegate.
   MenuItemView* AppendDelegateMenuItem(int item_id);
 
   // Adds a separator to this menu
   void AppendSeparator();
 
   // Appends a menu item with an icon. This is for the menu item which
   // needs an icon. Calling this function forces the Menu class to draw
   // the menu, instead of relying on Windows.
   MenuItemView* AppendMenuItemWithIcon(int item_id,
-                                       const string16& label,
+                                       const base::string16& label,
                                        const gfx::ImageSkia& icon);
 
   // All the AppendXXX methods funnel into this.
   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);
 
   // Returns the view that contains child menu items. If the submenu has
   // not been creates, this creates it.
   virtual SubmenuView* CreateSubmenu();
 
   // Returns true if this menu item has a submenu.
   virtual bool HasSubmenu() const;
 
   // Returns the view containing child menu items.
   virtual SubmenuView* GetSubmenu() const;
 
   // Returns the parent menu item.
   MenuItemView* GetParentMenuItem() { return parent_menu_item_; }
   const MenuItemView* GetParentMenuItem() const { return parent_menu_item_; }
 
   // Sets/Gets the title.
-  void SetTitle(const string16& title);
-  const string16& title() const { return title_; }
+  void SetTitle(const base::string16& title);
+  const base::string16& title() const { return title_; }
 
   // Sets the subtitle.
-  void SetSubtitle(const string16& subtitle);
+  void SetSubtitle(const base::string16& subtitle);
 
   // Sets the minor text.
-  void SetMinorText(const string16& minor_text);
+  void SetMinorText(const base::string16& minor_text);
 
   // Returns the type of this menu.
   const Type& GetType() const { return type_; }
 
   // Sets whether this item is selected. This is invoked as the user moves
   // the mouse around the menu while open.
   void SetSelected(bool selected);
 
   // Returns true if the item is selected.
   bool IsSelected() const { return selected_; }
 
   // Sets the |tooltip| for a menu item view with |item_id| identifier.
-  void SetTooltip(const string16& tooltip, int item_id);
+  void SetTooltip(const base::string16& tooltip, int item_id);
 
   // Sets the icon for the descendant identified by item_id.
   void SetIcon(const gfx::ImageSkia& icon, int item_id);
 
   // Sets the icon of this menu item.
   void SetIcon(const gfx::ImageSkia& icon);
 
   // Sets the view used to render the icon. This clobbers any icon set via
   // SetIcon(). MenuItemView takes ownership of |icon_view|.
   void SetIconView(View* icon_view);
@@ skipping 128 matching lines @@
 
   // Paints the right-side text.
   void PaintMinorText(gfx::Canvas* canvas, bool render_selection);
 
   // Destroys the window used to display this menu and recursively destroys
   // the windows used to display all descendants.
   void DestroyAllMenuHosts();
 
   // Returns the text that should be displayed on the end (right) of the menu
   // item. This will be the accelerator (if one exists), otherwise |subtitle_|.
-  string16 GetMinorText();
+  base::string16 GetMinorText();
 
   // Calculates and returns the MenuItemDimensions.
   MenuItemDimensions CalculateDimensions();
 
   // Get the horizontal position at which to draw the menu item's label.
   int GetLabelStartForThisItem();
 
   // Used by MenuController to cache the menu position in use by the
   // active menu.
   MenuPosition actual_menu_position() const { return actual_menu_position_; }
@@ skipping 40 matching lines @@
   // Whether we're selected.
   bool selected_;
 
   // Command id.
   int command_;
 
   // Submenu, created via CreateSubmenu.
   SubmenuView* submenu_;
 
   // Title.
-  string16 title_;
+  base::string16 title_;
 
   // Subtitle/sublabel.
-  string16 subtitle_;
+  base::string16 subtitle_;
 
   // Minor text.
-  string16 minor_text_;
+  base::string16 minor_text_;
 
   // Does the title have a mnemonic? Only useful on the root menu item.
   bool has_mnemonics_;
 
   // Should we show the mnemonic? Mnemonics are shown if this is true or
   // MenuConfig says mnemonics should be shown. Only used on the root menu item.
   bool show_mnemonics_;
 
   // Set if menu has icons or icon_views (applies to root menu item only).
   bool has_icons_;
 
   // Pointer to a view with a menu icon.
   View* icon_view_;
 
   // The tooltip to show on hover for this menu item.
-  string16 tooltip_;
+  base::string16 tooltip_;
 
   // Width of a menu icon area.
   static int icon_area_width_;
 
   // X-coordinate of where the label starts.
   static int label_start_;
 
   // Margins between the right of the item and the label.
   static int item_right_margin_;
 
@@ skipping 25 matching lines @@
   // If set to false, the right margin will be removed for menu lines
   // containing other elements.
   bool use_right_margin_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuItemView);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_