Move tray code from ui/chromeos/network/

ash/common/system/chromeos/network/network_icon.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/chromeos/network/network_icon.h"
+#include "ash/common/system/chromeos/network/network_icon.h"
 
+#include "ash/common/material_design/material_design_controller.h"
+#include "ash/common/system/chromeos/network/network_icon_animation.h"
+#include "ash/common/system/chromeos/network/network_icon_animation_observer.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
-#include "grit/ui_chromeos_resources.h"
-#include "grit/ui_chromeos_strings.h"
+#include "grit/ash_resources.h"
+#include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
-#include "ui/chromeos/material_design_icon_controller.h"
-#include "ui/chromeos/network/network_icon_animation.h"
-#include "ui/chromeos/network/network_icon_animation_observer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/vector_icons_public.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkPortalDetector;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 
-namespace ui {
+namespace ash {
 namespace network_icon {
 
 namespace {
 
 // Constants for offseting the badge displayed on top of the signal strength
 // icon. The badge will extend outside of the base icon bounds by these amounts.
 // Only used for MD. All values are in dp.
 
 // The badge offsets are different depending on whether the icon is in the tray
 // or menu.
 const int kTrayIconBadgeOffset = 3;
 const int kMenuIconBadgeOffset = 2;
 
 // TODO(estade): use kTrayIconSize. See crbug.com/623987
 const int kTrayIconSide = 16;
 
 bool UseMd() {
-  return md_icon_controller::UseMaterialDesignNetworkIcons();
+  return MaterialDesignController::UseMaterialDesignSystemIcons();
 }
 
 //------------------------------------------------------------------------------
 // Struct to pass icon badges to NetworkIconImageSource.
 struct Badges {
   gfx::ImageSkia top_left;
   gfx::ImageSkia top_right;
   gfx::ImageSkia bottom_left;
   gfx::ImageSkia bottom_right;
 };
@@ skipping 85 matching lines @@
 NetworkIconMap* GetIconMap(IconType icon_type) {
   return GetIconMapInstance(icon_type, true);
 }
 
 void PurgeIconMap(IconType icon_type,
                   const std::set<std::string>& network_paths) {
   NetworkIconMap* icon_map = GetIconMapInstance(icon_type, false);
   if (!icon_map)
     return;
   for (NetworkIconMap::iterator loop_iter = icon_map->begin();
-       loop_iter != icon_map->end(); ) {
+       loop_iter != icon_map->end();) {
     NetworkIconMap::iterator cur_iter = loop_iter++;
     if (network_paths.count(cur_iter->first) == 0) {
       delete cur_iter->second;
       icon_map->erase(cur_iter);
     }
   }
 }
 
 //------------------------------------------------------------------------------
 // Utilities for generating icon images.
 
 // 'NONE' will default to ARCS behavior where appropriate (e.g. no network or
 // if a new type gets added).
-enum ImageType {
-  ARCS,
-  BARS,
-  NONE
-};
+enum ImageType { ARCS, BARS, NONE };
 
 // Amount to fade icons while connecting.
 const double kConnectingImageAlpha = 0.5;
 
 // Images for strength arcs for wireless networks or strength bars for cellular
 // networks.
 const int kNumNetworkImages = 5;
 
 // Number of discrete images to use for alpha fade animation
 const int kNumFadeImages = 10;
@@ skipping 131 matching lines @@
   void set_color(SkColor color) { color_ = color; }
 
   // gfx::CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
     if (image_type_ == ARCS)
       DrawArcs(canvas);
     else
       DrawBars(canvas);
   }
 
-  bool HasRepresentationAtAllScales() const override {
-    return true;
-  }
+  bool HasRepresentationAtAllScales() const override { return true; }
 
  private:
   static gfx::Size GetSizeForIconType(IconType icon_type) {
     return icon_type == ICON_TYPE_TRAY
                ? gfx::Size(kTrayIconSide, kTrayIconSide)
                // TODO(estade): use kMenuIconSize instead of 20.
                : gfx::Size(20, 20);
   }
 
   void DrawArcs(gfx::Canvas* canvas) {
@@ skipping 125 matching lines @@
     gfx::CanvasImageSource* source =
         new SignalStrengthImageSource(image_type, icon_type, index);
     return gfx::ImageSkia(source, source->size());
   }
 
   if (index < 0 || index >= kNumNetworkImages)
     return gfx::ImageSkia();
   gfx::ImageSkia* images = BaseImageForType(image_type, icon_type);
   int width = images->width();
   int height = images->height() / kNumNetworkImages;
-  return gfx::ImageSkiaOperations::ExtractSubset(*images,
-      gfx::Rect(0, index * height, width, height));
+  return gfx::ImageSkiaOperations::ExtractSubset(
+      *images, gfx::Rect(0, index * height, width, height));
 }
 
 const gfx::ImageSkia GetDisconnectedImage(IconType icon_type,
                                           const std::string& network_type) {
   DCHECK_NE(shill::kTypeVPN, network_type);
   ImageType image_type = ImageTypeForNetworkType(network_type);
   const int disconnected_index = 0;
   return GetImageForIndex(image_type, icon_type, disconnected_index);
 }
 
@@ skipping 178 matching lines @@
 }
 
 gfx::ImageSkia GetConnectingImage(IconType icon_type,
                                   const std::string& network_type) {
   if (network_type == shill::kTypeVPN)
     return GetConnectingVpnImage(icon_type);
 
   ImageType image_type = ImageTypeForNetworkType(network_type);
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
-  gfx::ImageSkia* icon = ConnectingWirelessImage(
-      image_type, icon_type, animation);
+  gfx::ImageSkia* icon =
+      ConnectingWirelessImage(image_type, icon_type, animation);
   return UseMd() ? NetworkIconImageSourceMd::CreateImage(*icon, Badges())
                  : gfx::ImageSkia(new NetworkIconImageSource(*icon, Badges()),
                                   icon->size());
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // NetworkIconImpl
 
@@ skipping 72 matching lines @@
         state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
   }
 
   if (behind_captive_portal == behind_captive_portal_)
     return false;
   behind_captive_portal_ = behind_captive_portal;
   return true;
 }
 
 bool NetworkIconImpl::UpdateVPNBadge() {
-  const NetworkState* vpn = NetworkHandler::Get()->network_state_handler()->
-      ConnectedNetworkByType(NetworkTypePattern::VPN());
+  const NetworkState* vpn =
+      NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
+          NetworkTypePattern::VPN());
   if (vpn && vpn_badge_.isNull()) {
     vpn_badge_ =
         UseMd() ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_VPN,
                                         GetDefaultColorForIconType(icon_type_))
                 : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
                       IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
     return true;
   }
   if (!vpn && !vpn_badge_.isNull()) {
     vpn_badge_ = gfx::ImageSkia();
@@ skipping 197 matching lines @@
   } else {
     return base::UTF8ToUTF16(network->name());
   }
 }
 
 int GetCellularUninitializedMsg() {
   static base::Time s_uninitialized_state_time;
   static int s_uninitialized_msg(0);
 
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
-  if (handler->GetTechnologyState(NetworkTypePattern::Mobile())
-      == NetworkStateHandler::TECHNOLOGY_UNINITIALIZED) {
+  if (handler->GetTechnologyState(NetworkTypePattern::Mobile()) ==
+      NetworkStateHandler::TECHNOLOGY_UNINITIALIZED) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
   } else if (handler->GetScanningByType(NetworkTypePattern::Mobile())) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_CELLULAR_SCANNING;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
   }
   // There can be a delay between leaving the Initializing state and when
   // a Cellular device shows up, so keep showing the initializing
@@ skipping 85 matching lines @@
   for (NetworkStateHandler::NetworkStateList::iterator iter = networks.begin();
        iter != networks.end(); ++iter) {
     network_paths.insert((*iter)->path());
   }
   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
   PurgeIconMap(ICON_TYPE_LIST, network_paths);
 }
 
 }  // namespace network_icon
-}  // namespace ui
+}  // namespace ash