chromeos: Move some network related UI in ui/chromeos/

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"
 #include "ash/system/chromeos/network/network_connect.h"
-#include "ash/system/chromeos/network/network_icon.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/chromeos/network/network_icon.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 
 namespace {
 
 // Offsets for views menu ids (main menu and submenu ids use the same
 // namespace).
 const int kMainIndexMask = 0x1000;
 const int kMoreIndexMask = 0x4000;
@@ skipping 311 matching lines @@
   } else {
     label = base::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);
+  const gfx::ImageSkia icon = ui::network_icon::GetImageForNetwork(
+      network, ui::network_icon::ICON_TYPE_LIST);
   menu_items_.push_back(
       MenuItem(ui::MenuModel::TYPE_COMMAND,
                label, icon, network->path(), flag));
 }
 
 void MainMenuModel::AddMessageItem(const base::string16& msg) {
   menu_items_.push_back(MenuItem(
       ui::MenuModel::TYPE_COMMAND, msg,
       gfx::ImageSkia(), std::string(), FLAG_DISABLED));
 }
@@ skipping 18 matching lines @@
       label = l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_STATUS,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
     } else {
       label = l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
     }
     int flag = FLAG_ETHERNET;
     if (ShouldHighlightNetwork(ethernet_network))
       flag |= FLAG_ASSOCIATED;
-    const gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
-        ethernet_network, ash::network_icon::ICON_TYPE_LIST);
+    const gfx::ImageSkia icon = ui::network_icon::GetImageForNetwork(
+        ethernet_network, ui::network_icon::ICON_TYPE_LIST);
     menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
                                    label, icon, std::string(), flag));
   }
 
   // Get the list of all networks.
   NetworkStateHandler::NetworkStateList network_list;
   handler->GetVisibleNetworkList(&network_list);
 
   // Cellular Networks
   if (handler->IsTechnologyEnabled(NetworkTypePattern::Cellular())) {
@@ skipping 19 matching lines @@
             base::UTF8ToUTF16(network_name),
             l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
       } else {
         label = base::UTF8ToUTF16(network_name);
       }
 
       int flag = FLAG_CELLULAR;
       bool isActive = ShouldHighlightNetwork(network);
       if (isActive)
         flag |= FLAG_ASSOCIATED;
-      const gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
-          network, ash::network_icon::ICON_TYPE_LIST);
+      const gfx::ImageSkia icon = ui::network_icon::GetImageForNetwork(
+          network, ui::network_icon::ICON_TYPE_LIST);
       menu_items_.push_back(
           MenuItem(ui::MenuModel::TYPE_COMMAND,
                    label, icon, network->path(), flag));
     }
 
     // For GSM add cellular network scan.
     const DeviceState* cellular_device =
         handler->GetDeviceStateByType(NetworkTypePattern::Cellular());
     if (cellular_device && cellular_device->support_network_scan()) {
       const gfx::ImageSkia icon =
-          ash::network_icon::GetImageForDisconnectedNetwork(
-              ash::network_icon::ICON_TYPE_LIST, shill::kTypeCellular);
+          ui::network_icon::GetImageForDisconnectedNetwork(
+              ui::network_icon::ICON_TYPE_LIST, shill::kTypeCellular);
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_COMMAND,
           l10n_util::GetStringUTF16(
               IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS),
           icon, std::string(), FLAG_ADD_CELLULAR));
     }
   } else {
     int initializing_message_id =
-        ash::network_icon::GetCellularUninitializedMsg();
+        ui::network_icon::GetCellularUninitializedMsg();
     if (initializing_message_id) {
       // Initializing cellular modem...
       AddMessageItem(l10n_util::GetStringUTF16(initializing_message_id));
     }
   }
 
   // Wimax Networks
   if (handler->IsTechnologyEnabled(NetworkTypePattern::Wimax())) {
     // List Wimax networks.
     for (NetworkStateHandler::NetworkStateList::const_iterator iter =
@@ skipping 18 matching lines @@
         continue;
       // Add 'Searching for Wi-Fi networks...' after connected networks.
       if (scanning_msg && !network->IsConnectedState()) {
         AddMessageItem(l10n_util::GetStringUTF16(scanning_msg));
         scanning_msg = 0;
       }
       AddWirelessNetworkMenuItem(network, FLAG_WIFI);
     }
     if (scanning_msg)
       AddMessageItem(l10n_util::GetStringUTF16(scanning_msg));
-    const gfx::ImageSkia icon =
-        ash::network_icon::GetImageForConnectedNetwork(
-            ash::network_icon::ICON_TYPE_LIST, shill::kTypeWifi);
+    const gfx::ImageSkia icon = ui::network_icon::GetImageForConnectedNetwork(
+        ui::network_icon::ICON_TYPE_LIST, shill::kTypeWifi);
     menu_items_.push_back(MenuItem(
         ui::MenuModel::TYPE_COMMAND,
         l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_OTHER_WIFI_NETWORKS),
         icon, std::string(), FLAG_ADD_WIFI));
   }
 
   if (menu_items_.empty()) {
     // No networks available (and not initializing cellular or wifi scanning)
     AddMessageItem(l10n_util::GetStringFUTF16(
         IDS_STATUSBAR_NETWORK_MENU_ITEM_INDENT,
@@ skipping 151 matching lines @@
   return main_menu_model_.get();
 }
 
 void NetworkMenu::UpdateMenu() {
   refreshing_menu_ = true;
   main_menu_model_->InitMenuItems(delegate_->ShouldOpenButtonOptions());
   refreshing_menu_ = false;
 }
 
 }  // namespace chromeos