Replace string16 with base::string16.

chrome/browser/chromeos/status/network_menu.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 "chrome/browser/chromeos/status/network_menu.h"
 
 #include <algorithm>
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
@@ skipping 58 matching lines @@
 }  // namespace
 
 class NetworkMenuModel : public ui::MenuModel {
  public:
   struct MenuItem {
     MenuItem()
         : type(ui::MenuModel::TYPE_SEPARATOR),
           sub_menu_model(NULL),
           flags(0) {
     }
-    MenuItem(ui::MenuModel::ItemType type, string16 label, gfx::ImageSkia icon,
+    MenuItem(ui::MenuModel::ItemType type, base::string16 label, gfx::ImageSkia icon,
              const std::string& service_path, int flags)
         : type(type),
           label(label),
           icon(icon),
           service_path(service_path),
           sub_menu_model(NULL),
           flags(flags) {
     }
-    MenuItem(ui::MenuModel::ItemType type, string16 label, gfx::ImageSkia icon,
+    MenuItem(ui::MenuModel::ItemType type, base::string16 label, gfx::ImageSkia icon,
              NetworkMenuModel* sub_menu_model, int flags)
         : type(type),
           label(label),
           icon(icon),
           sub_menu_model(sub_menu_model),
           flags(flags) {
     }
 
     ui::MenuModel::ItemType type;
-    string16 label;
+    base::string16 label;
     gfx::ImageSkia icon;
     std::string service_path;
     NetworkMenuModel* sub_menu_model;  // Weak ptr.
     int flags;
   };
   typedef std::vector<MenuItem> MenuItemVector;
 
   explicit NetworkMenuModel(const base::WeakPtr<NetworkMenu>& owner)
     : owner_(owner) {}
   virtual ~NetworkMenuModel() {}
 
   // Connect or reconnect to the network at |index|.
   void ConnectToNetworkAt(int index);
 
   // Called by NetworkMenu::UpdateMenu to initialize menu items.
   virtual void InitMenuItems(bool should_open_button_options) = 0;
 
   // Menu item field accessors.
   const MenuItemVector& menu_items() const { return menu_items_; }
 
   // ui::MenuModel implementation
   // GetCommandIdAt() must be implemented by subclasses.
   virtual bool HasIcons() const OVERRIDE;
   virtual int GetItemCount() const OVERRIDE;
   virtual ui::MenuModel::ItemType GetTypeAt(int index) const OVERRIDE;
   virtual ui::MenuSeparatorType GetSeparatorTypeAt(int index) const OVERRIDE;
-  virtual string16 GetLabelAt(int index) const OVERRIDE;
+  virtual base::string16 GetLabelAt(int index) const OVERRIDE;
   virtual bool IsItemDynamicAt(int index) const OVERRIDE;
   virtual const gfx::Font* GetLabelFontAt(int index) const OVERRIDE;
   virtual bool GetAcceleratorAt(int index,
                                 ui::Accelerator* accelerator) const OVERRIDE;
   virtual bool IsItemCheckedAt(int index) const OVERRIDE;
   virtual int GetGroupIdAt(int index) const OVERRIDE;
   virtual bool GetIconAt(int index, gfx::Image* icon) OVERRIDE;
   virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt(
       int index) const OVERRIDE;
   virtual bool IsEnabledAt(int index) const OVERRIDE;
@@ skipping 58 matching lines @@
   virtual ~MainMenuModel() {}
 
   // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool should_open_button_options) OVERRIDE;
 
   // ui::MenuModel implementation
   virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   void AddWirelessNetworkMenuItem(const NetworkState* wifi_network, int flag);
-  void AddMessageItem(const string16& msg);
+  void AddMessageItem(const base::string16& msg);
 
   scoped_ptr<MoreMenuModel> more_menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(MainMenuModel);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, public methods:
 
 void NetworkMenuModel::ConnectToNetworkAt(int index) {
@@ skipping 124 matching lines @@
     ChooseMobileNetworkDialog::ShowDialog(native_window);
   else
     NetworkConfigView::ShowForType(shill::kTypeWifi, native_window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MainMenuModel
 
 void MainMenuModel::AddWirelessNetworkMenuItem(const NetworkState* network,
                                                int flag) {
-  string16 label;
+  base::string16 label;
   // Ampersand is a valid character in an SSID, but menu2 uses it to mark
   // "mnemonics" for keyboard shortcuts.
   std::string wifi_name = EscapeAmpersands(network->name());
   if (network->IsConnectingState()) {
     label = l10n_util::GetStringFUTF16(
         IDS_STATUSBAR_NETWORK_DEVICE_STATUS,
         UTF8ToUTF16(wifi_name),
         l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
   } else {
     label = UTF8ToUTF16(wifi_name);
   }
 
   // We do not have convenient access to whether or not it might be possible
   // to connect to a wireless network (e.g. whether certs are required), so all
   // entries are enabled.
 
   if (ShouldHighlightNetwork(network))
     flag |= FLAG_ASSOCIATED;
   const gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
       network, ash::network_icon::ICON_TYPE_LIST);
   menu_items_.push_back(
       MenuItem(ui::MenuModel::TYPE_COMMAND,
                label, icon, network->path(), flag));
 }
 
-void MainMenuModel::AddMessageItem(const string16& msg) {
+void MainMenuModel::AddMessageItem(const base::string16& msg) {
   menu_items_.push_back(MenuItem(
       ui::MenuModel::TYPE_COMMAND, msg,
       gfx::ImageSkia(), std::string(), FLAG_DISABLED));
 }
 
 void MainMenuModel::InitMenuItems(bool should_open_button_options) {
   menu_items_.clear();
 
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   // Populate our MenuItems with the current list of networks.
-  string16 label;
+  base::string16 label;
 
   // Ethernet
   // Only display an ethernet icon if enabled, and an ethernet network exists.
   bool ethernet_enabled =
       handler->IsTechnologyEnabled(NetworkTypePattern::Ethernet());
   const NetworkState* ethernet_network =
       handler->FirstNetworkByType(NetworkTypePattern::Ethernet());
   if (ethernet_enabled && ethernet_network) {
     bool ethernet_connecting = ethernet_network->IsConnectingState();
     if (ethernet_connecting) {
@@ skipping 276 matching lines @@
   return main_menu_model_.get();
 }
 
 void NetworkMenu::UpdateMenu() {
   refreshing_menu_ = true;
   main_menu_model_->InitMenuItems(delegate_->ShouldOpenButtonOptions());
   refreshing_menu_ = false;
 }
 
 }  // namespace chromeos