Remove pre-MD code/assets for network iconography.

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 "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 "ash/common/system/tray/tray_constants.h"
 #include "ash/resources/vector_icons/vector_icons.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/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/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_icon_types.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkPortalDetector;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 
 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.
+// 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;
 
-bool UseMd() {
-  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 124 matching lines @@
   return (icon_type != ICON_TYPE_TRAY);
 }
 
 bool IconTypeHasVPNBadge(IconType icon_type) {
   return (icon_type != ICON_TYPE_LIST && icon_type != ICON_TYPE_MENU_LIST);
 }
 
 // This defines how we assemble a network icon.
 class NetworkIconImageSource : public gfx::CanvasImageSource {
  public:
-  NetworkIconImageSource(const gfx::ImageSkia& icon, const Badges& badges)
-      : CanvasImageSource(icon.size(), false), icon_(icon), badges_(badges) {}
-  ~NetworkIconImageSource() override {}
-
-  // TODO(pkotwicz): Figure out what to do when a new image resolution becomes
-  // available.
-  void Draw(gfx::Canvas* canvas) override {
-    canvas->DrawImageInt(icon_, 0, 0);
-
-    if (!badges_.top_left.isNull())
-      canvas->DrawImageInt(badges_.top_left, 0, 0);
-    if (!badges_.top_right.isNull())
-      canvas->DrawImageInt(badges_.top_right,
-                           icon_.width() - badges_.top_right.width(), 0);
-    if (!badges_.bottom_left.isNull()) {
-      canvas->DrawImageInt(badges_.bottom_left, 0,
-                           icon_.height() - badges_.bottom_left.height());
-    }
-    if (!badges_.bottom_right.isNull()) {
-      canvas->DrawImageInt(badges_.bottom_right,
-                           icon_.width() - badges_.bottom_right.width(),
-                           icon_.height() - badges_.bottom_right.height());
-    }
-  }
-
- private:
-  const gfx::ImageSkia icon_;
-  const Badges badges_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSource);
-};
-
-// This defines how we assemble a network icon.
-class NetworkIconImageSourceMd : public gfx::CanvasImageSource {
- public:
   static gfx::ImageSkia CreateImage(const gfx::ImageSkia& icon,
                                     const Badges& badges) {
-    auto source = new NetworkIconImageSourceMd(icon, badges);
+    auto source = new NetworkIconImageSource(icon, badges);
     return gfx::ImageSkia(source, source->size());
   }
 
   // gfx::CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
     const int width = size().width();
     const int height = size().height();
 
     // The base icon is centered in both dimensions.
     const int icon_y = (height - icon_.height()) / 2;
@@ skipping 15 matching lines @@
     if (!badges_.bottom_right.isNull()) {
       canvas->DrawImageInt(badges_.bottom_right,
                            width - badges_.bottom_right.width(),
                            height - badges_.bottom_right.height());
     }
   }
 
   bool HasRepresentationAtAllScales() const override { return true; }
 
  private:
-  NetworkIconImageSourceMd(const gfx::ImageSkia& icon, const Badges& badges)
+  NetworkIconImageSource(const gfx::ImageSkia& icon, const Badges& badges)
       : CanvasImageSource(GetSizeForBaseIconSize(icon.size()), false),
         icon_(icon),
         badges_(badges) {}
-  ~NetworkIconImageSourceMd() override {}
+  ~NetworkIconImageSource() override {}
 
   static gfx::Size GetSizeForBaseIconSize(const gfx::Size& base_icon_size) {
     gfx::Size size = base_icon_size;
     const int badge_offset = base_icon_size.width() == kTrayIconSize
                                  ? kTrayIconBadgeOffset
                                  : kMenuIconBadgeOffset;
     size.Enlarge(badge_offset * 2, badge_offset * 2);
     return size;
   }
 
   const gfx::ImageSkia icon_;
   const Badges badges_;
 
-  DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSourceMd);
+  DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSource);
 };
 
 // Depicts a given signal strength using arcs (e.g. for WiFi connections) or
 // bars (e.g. for cell connections).
 class SignalStrengthImageSource : public gfx::CanvasImageSource {
  public:
   SignalStrengthImageSource(ImageType image_type,
                             IconType icon_type,
                             int signal_strength)
       : CanvasImageSource(GetSizeForIconType(icon_type), false),
@@ skipping 120 matching lines @@
   // TODO(estade): share this alpha with other things in ash (battery, etc.).
   // See crbug.com/623987 and crbug.com/632827
   static constexpr int kBgAlpha = 0x4D;
 
   DISALLOW_COPY_AND_ASSIGN(SignalStrengthImageSource);
 };
 
 //------------------------------------------------------------------------------
 // Utilities for extracting icon images.
 
-gfx::ImageSkia* BaseImageForType(ImageType image_type, IconType icon_type) {
-  gfx::ImageSkia* image;
-  if (image_type == BARS) {
-    image = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK
-                                  : IDR_AURA_UBER_TRAY_NETWORK_BARS_LIGHT);
-  } else {
-    image = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK
-                                  : IDR_AURA_UBER_TRAY_NETWORK_ARCS_LIGHT);
-  }
-  return image;
-}
-
 ImageType ImageTypeForNetworkType(const std::string& type) {
   if (type == shill::kTypeWifi)
     return ARCS;
   else if (type == shill::kTypeCellular || type == shill::kTypeWimax)
     return BARS;
   return NONE;
 }
 
 gfx::ImageSkia GetImageForIndex(ImageType image_type,
                                 IconType icon_type,
                                 int index) {
-  if (UseMd()) {
-    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));
+  gfx::CanvasImageSource* source =
+      new SignalStrengthImageSource(image_type, icon_type, index);
+  return gfx::ImageSkia(source, source->size());
 }
 
 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 23 matching lines @@
   }
   return images[index];
 }
 
 gfx::ImageSkia ConnectingVpnImage(double animation) {
   int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
   static gfx::ImageSkia* s_vpn_images[kNumFadeImages];
   if (!s_vpn_images[index]) {
     // Lazily cache images.
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+    // TODO(estade): update this icon to MD. See crbug.com/690176

[tdanderson, 2017/02/09 18:23:47]

Thanks for catching + filing

     gfx::ImageSkia* icon = rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN);
     s_vpn_images[index] = new gfx::ImageSkia(
         gfx::ImageSkiaOperations::CreateTransparentImage(*icon, animation));
   }
   return *s_vpn_images[index];
 }
 
 gfx::ImageSkia ConnectingVpnBadge(double animation, IconType icon_type) {
   int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
   static gfx::ImageSkia* s_vpn_badges[kNumFadeImages];
   if (!s_vpn_badges[index]) {
     // Lazily cache images.
-    gfx::ImageSkia badge =
-        UseMd() ? gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
-                                        GetDefaultColorForIconType(icon_type))
-                : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-                      IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
+    gfx::ImageSkia badge = gfx::CreateVectorIcon(
+        kNetworkBadgeVpnIcon, GetDefaultColorForIconType(icon_type));
     s_vpn_badges[index] = new gfx::ImageSkia(
         gfx::ImageSkiaOperations::CreateTransparentImage(badge, animation));
   }
   return *s_vpn_badges[index];
 }
 
 int StrengthIndex(int strength) {
   // Return an index in the range [1, kNumNetworkImages - 1].
   const float findex = (static_cast<float>(strength) / 100.0f) *
                        nextafter(static_cast<float>(kNumNetworkImages - 1), 0);
   int index = 1 + static_cast<int>(findex);
   index = std::max(std::min(index, kNumNetworkImages - 1), 1);
   return index;
 }
 
 gfx::ImageSkia BadgeForNetworkTechnology(const NetworkState* network,
                                          IconType icon_type) {
   const std::string& technology = network->network_technology();
-  if (UseMd()) {
-    const gfx::VectorIcon* icon = &gfx::kNoneIcon;
-    if (technology == shill::kNetworkTechnologyEvdo) {
-      icon = &kNetworkBadgeTechnologyEvdoIcon;
-    } else if (technology == shill::kNetworkTechnology1Xrtt) {
-      icon = &kNetworkBadgeTechnology1xIcon;
-    } else if (technology == shill::kNetworkTechnologyGprs ||
-               technology == shill::kNetworkTechnologyGsm) {
-      icon = &kNetworkBadgeTechnologyGprsIcon;
-    } else if (technology == shill::kNetworkTechnologyEdge) {
-      icon = &kNetworkBadgeTechnologyEdgeIcon;
-    } else if (technology == shill::kNetworkTechnologyUmts) {
-      icon = &kNetworkBadgeTechnology3gIcon;
-    } else if (technology == shill::kNetworkTechnologyHspa) {
-      icon = &kNetworkBadgeTechnologyHspaIcon;
-    } else if (technology == shill::kNetworkTechnologyHspaPlus) {
-      icon = &kNetworkBadgeTechnologyHspaPlusIcon;
-    } else if (technology == shill::kNetworkTechnologyLte) {
-      icon = &kNetworkBadgeTechnologyLteIcon;
-    } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
-      icon = &kNetworkBadgeTechnologyLteAdvancedIcon;
-    } else {
-      return gfx::ImageSkia();
-    }
-    return gfx::CreateVectorIcon(*icon, GetDefaultColorForIconType(icon_type));
-  }
-
-  int id = -1;
+  const gfx::VectorIcon* icon = &gfx::kNoneIcon;
   if (technology == shill::kNetworkTechnologyEvdo) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_EVDO_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_EVDO_LIGHT;
+    icon = &kNetworkBadgeTechnologyEvdoIcon;
   } else if (technology == shill::kNetworkTechnology1Xrtt) {
-    id = IDR_AURA_UBER_TRAY_NETWORK_1X;
-  } else if (technology == shill::kNetworkTechnologyGprs) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_GPRS_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_GPRS_LIGHT;
+    icon = &kNetworkBadgeTechnology1xIcon;
+  } else if (technology == shill::kNetworkTechnologyGprs ||
+             technology == shill::kNetworkTechnologyGsm) {
+    icon = &kNetworkBadgeTechnologyGprsIcon;
   } else if (technology == shill::kNetworkTechnologyEdge) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_EDGE_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_EDGE_LIGHT;
+    icon = &kNetworkBadgeTechnologyEdgeIcon;
   } else if (technology == shill::kNetworkTechnologyUmts) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_3G_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_3G_LIGHT;
+    icon = &kNetworkBadgeTechnology3gIcon;
   } else if (technology == shill::kNetworkTechnologyHspa) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_HSPA_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_HSPA_LIGHT;
+    icon = &kNetworkBadgeTechnologyHspaIcon;
   } else if (technology == shill::kNetworkTechnologyHspaPlus) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_HSPA_PLUS_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_HSPA_PLUS_LIGHT;
+    icon = &kNetworkBadgeTechnologyHspaPlusIcon;
   } else if (technology == shill::kNetworkTechnologyLte) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_LTE_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_LTE_LIGHT;
+    icon = &kNetworkBadgeTechnologyLteIcon;
   } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
-    id = IconTypeIsDark(icon_type)
-             ? IDR_AURA_UBER_TRAY_NETWORK_LTE_ADVANCED_DARK
-             : IDR_AURA_UBER_TRAY_NETWORK_LTE_ADVANCED_LIGHT;
-  } else if (technology == shill::kNetworkTechnologyGsm) {
-    id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_GPRS_DARK
-                                   : IDR_AURA_UBER_TRAY_NETWORK_GPRS_LIGHT;
+    icon = &kNetworkBadgeTechnologyLteAdvancedIcon;
   } else {
     return gfx::ImageSkia();
   }
-  return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
+  return gfx::CreateVectorIcon(*icon, GetDefaultColorForIconType(icon_type));
 }
 
 gfx::ImageSkia GetIcon(const NetworkState* network,
                        IconType icon_type,
                        int strength_index) {
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (network->Matches(NetworkTypePattern::Ethernet())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
-    return UseMd() ? gfx::CreateVectorIcon(
-                         kNetworkEthernetIcon,
-                         GetDefaultColorForIconType(ICON_TYPE_LIST))
-                   : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
+    return gfx::CreateVectorIcon(kNetworkEthernetIcon,
+                                 GetDefaultColorForIconType(ICON_TYPE_LIST));
   } else if (network->Matches(NetworkTypePattern::Wireless())) {
     DCHECK(strength_index > 0);
     return GetImageForIndex(ImageTypeForNetworkType(network->type()), icon_type,
                             strength_index);
   } else if (network->Matches(NetworkTypePattern::VPN())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return GetVpnImage();
   }
 
   NOTREACHED() << "Request for icon for unsupported type: " << network->type();
@@ skipping 13 matching lines @@
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
   gfx::ImageSkia icon;
   Badges badges;
   if (connected_network) {
     icon = GetImageForNetwork(connected_network, icon_type);
     badges.bottom_left = ConnectingVpnBadge(animation, icon_type);
   } else {
     icon = ConnectingVpnImage(animation);
   }
-  return UseMd() ? NetworkIconImageSourceMd::CreateImage(icon, badges)
-                 : gfx::ImageSkia(new NetworkIconImageSource(icon, badges),
-                                  icon.size());
+  return NetworkIconImageSource::CreateImage(icon, badges);
 }
 
 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);
-  return UseMd() ? NetworkIconImageSourceMd::CreateImage(*icon, Badges())
-                 : gfx::ImageSkia(new NetworkIconImageSource(*icon, Badges()),
-                                  icon->size());
+  return NetworkIconImageSource::CreateImage(
+      *ConnectingWirelessImage(image_type, icon_type, animation), Badges());
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // NetworkIconImpl
 
 NetworkIconImpl::NetworkIconImpl(const std::string& path, IconType icon_type)
     : network_path_(path),
       icon_type_(icon_type),
@@ skipping 73 matching lines @@
     return false;
   behind_captive_portal_ = behind_captive_portal;
   return true;
 }
 
 bool NetworkIconImpl::UpdateVPNBadge() {
   const NetworkState* vpn =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
           NetworkTypePattern::VPN());
   if (vpn && vpn_badge_.isNull()) {
-    vpn_badge_ =
-        UseMd() ? gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
-                                        GetDefaultColorForIconType(icon_type_))
-                : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-                      IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
+    vpn_badge_ = gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
+                                       GetDefaultColorForIconType(icon_type_));
     return true;
   }
   if (!vpn && !vpn_badge_.isNull()) {
     vpn_badge_ = gfx::ImageSkia();
     return true;
   }
   return false;
 }
 
 void NetworkIconImpl::GetBadges(const NetworkState* network, Badges* badges) {
   DCHECK(network);
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   const std::string& type = network->type();
   const SkColor icon_color = GetDefaultColorForIconType(icon_type_);
   if (type == shill::kTypeWifi) {
     if (network->security_class() != shill::kSecurityNone &&
         IconTypeIsDark(icon_type_)) {
       badges->bottom_right =
-          UseMd()
-              ? gfx::CreateVectorIcon(kNetworkBadgeSecureIcon, icon_color)
-              : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_SECURE_DARK);
+          gfx::CreateVectorIcon(kNetworkBadgeSecureIcon, icon_color);
     }
   } else if (type == shill::kTypeWimax) {
     technology_badge_ =
-        UseMd()
-            ? gfx::CreateVectorIcon(kNetworkBadgeTechnology4gIcon, icon_color)
-            : *rb.GetImageSkiaNamed(IconTypeIsDark(icon_type_)
-                                        ? IDR_AURA_UBER_TRAY_NETWORK_4G_DARK
-                                        : IDR_AURA_UBER_TRAY_NETWORK_4G_LIGHT);
+        gfx::CreateVectorIcon(kNetworkBadgeTechnology4gIcon, icon_color);
   } else if (type == shill::kTypeCellular) {
     if (network->roaming() == shill::kRoamingStateRoaming) {
       // For networks that are always in roaming don't show roaming badge.
       const DeviceState* device =
-          handler->GetDeviceState(network->device_path());
+          NetworkHandler::Get()->network_state_handler()->GetDeviceState(
+              network->device_path());
       LOG_IF(WARNING, !device) << "Could not find device state for "
                                << network->device_path();
       if (!device || !device->provider_requires_roaming()) {
         badges->bottom_right =
-            UseMd()
-                ? gfx::CreateVectorIcon(kNetworkBadgeRoamingIcon, icon_color)
-                : *rb.GetImageSkiaNamed(
-                      IconTypeIsDark(icon_type_)
-                          ? IDR_AURA_UBER_TRAY_NETWORK_ROAMING_DARK
-                          : IDR_AURA_UBER_TRAY_NETWORK_ROAMING_LIGHT);
+            gfx::CreateVectorIcon(kNetworkBadgeRoamingIcon, icon_color);
       }
     }
   }
   if (!network->IsConnectingState()) {
     badges->top_left = technology_badge_;
     badges->bottom_left = vpn_badge_;
   }
 
   if (behind_captive_portal_) {
     badges->bottom_right =
-        UseMd()
-            ? gfx::CreateVectorIcon(kNetworkBadgeCaptivePortalIcon, icon_color)
-            : *rb.GetImageSkiaNamed(
-                  IconTypeIsDark(icon_type_)
-                      ? IDR_AURA_UBER_TRAY_NETWORK_PORTAL_DARK
-                      : IDR_AURA_UBER_TRAY_NETWORK_PORTAL_LIGHT);
+        gfx::CreateVectorIcon(kNetworkBadgeCaptivePortalIcon, icon_color);
   }
 }
 
 void NetworkIconImpl::GenerateImage(const NetworkState* network) {
   DCHECK(network);
   gfx::ImageSkia icon = GetIcon(network, icon_type_, strength_index_);
   Badges badges;
   GetBadges(network, &badges);
-  image_ = UseMd() ? NetworkIconImageSourceMd::CreateImage(icon, badges)
-                   : gfx::ImageSkia(new NetworkIconImageSource(icon, badges),
-                                    icon.size());
+  image_ = NetworkIconImageSource::CreateImage(icon, badges);
 }
 
 namespace {
 
 NetworkIconImpl* FindAndUpdateImageImpl(const NetworkState* network,
                                         IconType icon_type) {
   // Find or add the icon.
   NetworkIconMap* icon_map = GetIconMap(icon_type);
   NetworkIconImpl* icon;
   NetworkIconMap::iterator iter = icon_map->find(network->path());
@@ skipping 41 matching lines @@
 gfx::ImageSkia GetImageForNewWifiNetwork(SkColor icon_color,
                                          SkColor badge_color) {
   SignalStrengthImageSource* source =
       new SignalStrengthImageSource(ImageTypeForNetworkType(shill::kTypeWifi),
                                     ICON_TYPE_LIST, kNumNetworkImages - 1);
   source->set_color(icon_color);
   gfx::ImageSkia icon = gfx::ImageSkia(source, source->size());
   Badges badges;
   badges.bottom_right =
       gfx::CreateVectorIcon(kNetworkBadgeAddOtherIcon, badge_color);
-  return NetworkIconImageSourceMd::CreateImage(icon, badges);
+  return NetworkIconImageSource::CreateImage(icon, badges);
 }
 
 gfx::ImageSkia GetVpnImage() {
-  return UseMd()
-             ? gfx::CreateVectorIcon(kNetworkVpnIcon,
-                                     GetDefaultColorForIconType(ICON_TYPE_LIST))
-             : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-                   IDR_AURA_UBER_TRAY_NETWORK_VPN);
+  return gfx::CreateVectorIcon(kNetworkVpnIcon,
+                               GetDefaultColorForIconType(ICON_TYPE_LIST));
 }
 
 base::string16 GetLabelForNetwork(const chromeos::NetworkState* network,
                                   IconType icon_type) {
   DCHECK(network);
   std::string activation_state = network->activation_state();
   if (icon_type == ICON_TYPE_LIST || icon_type == ICON_TYPE_MENU_LIST) {
     // Show "<network>: [Connecting|Activating|Reconnecting]..."
     // TODO(varkha): Remaining states should migrate to secondary status in the
     // network item and no longer be part of the label.
@@ skipping 157 matching lines @@
     network_paths.insert((*iter)->path());
   }
   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
   PurgeIconMap(ICON_TYPE_LIST, network_paths);
   PurgeIconMap(ICON_TYPE_MENU_LIST, network_paths);
 }
 
 }  // namespace network_icon
 }  // namespace ash