Prefix string16 with base:: in ui/.

ui/views/controls/menu/menu.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_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 27 matching lines @@
     virtual ~Delegate() {}
 
     // Whether or not an item should be shown as checked.
     virtual bool IsItemChecked(int id) const;
 
     // Whether or not an item should be shown as the default (using bold).
     // There can only be one default menu item.
     virtual bool IsItemDefault(int id) const;
 
     // The string shown for the menu item.
-    virtual string16 GetLabel(int id) const;
+    virtual base::string16 GetLabel(int id) const;
 
     // The delegate needs to implement this function if it wants to display
     // the shortcut text next to each menu item. If there is an accelerator
     // for a given item id, the implementor must return it.
     virtual bool GetAcceleratorInfo(int id, ui::Accelerator* accel);
 
     // The icon shown for the menu item.
     virtual const gfx::ImageSkia& GetIcon(int id) const;
 
     // The number of items to show in the menu
@@ skipping 28 matching lines @@
     // since there is no reason to show left-to-right menus for right-to-left
     // locales. However, subclasses can override this behavior so that the menu
     // is a right-to-left menu only if the view's layout is right-to-left
     // (since the view can use a different layout than the locale's language
     // layout).
     virtual bool IsRightToLeftUILayout() const;
 
     // Controller
     virtual bool SupportsCommand(int id) const;
     virtual bool IsCommandEnabled(int id) const;
-    virtual bool GetContextualLabel(int id, string16* out) const;
+    virtual bool GetContextualLabel(int id, base::string16* out) const;
     virtual void ExecuteCommand(int id) {
     }
 
    protected:
     // Returns an empty icon.
     const gfx::ImageSkia& GetEmptyIcon() const;
   };
 
   // How this popup should align itself relative to the point it is run at.
   enum AnchorPoint {
@@ skipping 36 matching lines @@
 
   // Adds 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.
   void AppendMenuItem(int item_id,
-                      const string16& label,
+                      const base::string16& label,
                       MenuItemType type);
   void AddMenuItem(int index,
                    int item_id,
-                   const string16& label,
+                   const base::string16& label,
                    MenuItemType type);
 
   // Append a submenu to this menu.
   // The returned pointer is owned by this menu.
   Menu* AppendSubMenu(int item_id,
-                      const string16& label);
-  Menu* AddSubMenu(int index, int item_id, const string16& label);
+                      const base::string16& label);
+  Menu* AddSubMenu(int index, int item_id, const base::string16& label);
 
   // Append a submenu with an icon to this menu
   // The returned pointer is owned by this menu.
   // Unless the icon is empty, calling this function forces the Menu class
   // to draw the menu, instead of relying on Windows.
   Menu* AppendSubMenuWithIcon(int item_id,
-                              const string16& label,
+                              const base::string16& label,
                               const gfx::ImageSkia& icon);
   virtual Menu* AddSubMenuWithIcon(int index,
                                    int item_id,
-                                   const string16& label,
+                                   const base::string16& label,
                                    const gfx::ImageSkia& icon) = 0;
 
   // This is a convenience for standard text label menu items where the label
   // is provided with this call.
-  void AppendMenuItemWithLabel(int item_id, const string16& label);
-  void AddMenuItemWithLabel(int index, int item_id, const string16& label);
+  void AppendMenuItemWithLabel(int item_id, const base::string16& label);
+  void AddMenuItemWithLabel(int index,
+                            int item_id,
+                            const base::string16& label);
 
   // This is a convenience for text label menu items where the label is
   // provided by the delegate.
   void AppendDelegateMenuItem(int item_id);
   void AddDelegateMenuItem(int index, int item_id);
 
   // Adds a separator to this menu
   void AppendSeparator();
   virtual void AddSeparator(int index) = 0;
 
   // 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.
   void AppendMenuItemWithIcon(int item_id,
-                              const string16& label,
+                              const base::string16& label,
                               const gfx::ImageSkia& icon);
   virtual void AddMenuItemWithIcon(int index,
                                    int item_id,
-                                   const string16& label,
+                                   const base::string16& label,
                                    const gfx::ImageSkia& icon);
 
   // Enables or disables the item with the specified id.
   virtual void EnableMenuItemByID(int item_id, bool enabled) = 0;
   virtual void EnableMenuItemAt(int index, bool enabled) = 0;
 
   // Sets menu label at specified index.
-  virtual void SetMenuLabel(int item_id, const string16& label) = 0;
+  virtual void SetMenuLabel(int item_id, const base::string16& label) = 0;
 
   // Sets an icon for an item with a given item_id. Calling this function
   // also forces the Menu class to draw the menu, instead of relying on Windows.
   // Returns false if the item with |item_id| is not found.
   virtual bool SetIcon(const gfx::ImageSkia& icon, int item_id) = 0;
 
   // Shows the menu, blocks until the user dismisses the menu or selects an
   // item, and executes the command for the selected item (if any).
   // Warning: Blocking call. Will implicitly run a message loop.
   virtual void RunMenuAt(int x, int y) = 0;
 
   // Cancels the menu.
   virtual void Cancel() = 0;
 
   // Returns the number of menu items.
   virtual int ItemCount() = 0;
 
 #if defined(OS_WIN)
   // Returns the underlying menu handle
   virtual HMENU GetMenuHandle() const = 0;
 #endif  // defined(OS_WIN)
 
  protected:
   explicit Menu(Menu* parent);
 
   virtual void AddMenuItemInternal(int index,
                                    int item_id,
-                                   const string16& label,
+                                   const base::string16& label,
                                    const gfx::ImageSkia& icon,
                                    MenuItemType type) = 0;
 
  private:
   // The delegate that is being used to get information about the presentation.
   Delegate* delegate_;
 
   // How this popup menu should be aligned relative to the point it is run at.
   AnchorPoint anchor_;
 
   DISALLOW_COPY_AND_ASSIGN(Menu);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_H_