Mocks for all libcros elements

chrome/browser/chromeos/status/network_menu_button.cc

 // Copyright (c) 2009 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_button.h"
 
 #include <limits>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/string_util.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/status/status_area_host.h"
 #include "gfx/canvas.h"
 #include "gfx/skbitmap_operations.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/widget/widget.h"
 #include "views/window/window.h"
 
 namespace chromeos {
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuButton
 
 // static
 const int NetworkMenuButton::kNumWifiImages = 9;
 const int NetworkMenuButton::kThrobDuration = 1000;
 
 NetworkMenuButton::NetworkMenuButton(StatusAreaHost* host)
     : StatusAreaButton(this),
       host_(host),
       ALLOW_THIS_IN_INITIALIZER_LIST(network_menu_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(animation_connecting_(this)) {
   animation_connecting_.SetThrobDuration(kThrobDuration);
   animation_connecting_.SetTweenType(SlideAnimation::NONE);
-  NetworkChanged(NetworkLibrary::Get());
-  NetworkLibrary::Get()->AddObserver(this);
+  NetworkChanged(CrosLibrary::Get()->GetNetworkLibrary());
+  CrosLibrary::Get()->GetNetworkLibrary()->AddObserver(this);
 }
 
 NetworkMenuButton::~NetworkMenuButton() {
-  NetworkLibrary::Get()->RemoveObserver(this);
+  CrosLibrary::Get()->GetNetworkLibrary()->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuButton, menus::MenuModel implementation:
 
 int NetworkMenuButton::GetItemCount() const {
   return static_cast<int>(menu_items_.size());
 }
 
 menus::MenuModel::ItemType NetworkMenuButton::GetTypeAt(int index) const {
@@ skipping 25 matching lines @@
 
 bool NetworkMenuButton::IsEnabledAt(int index) const {
   return !(menu_items_[index].flags & FLAG_DISABLED);
 }
 
 void NetworkMenuButton::ActivatedAt(int index) {
   // When we are refreshing the menu, ignore menu item activation.
   if (refreshing_menu_)
     return;
 
-  NetworkLibrary* cros = NetworkLibrary::Get();
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   int flags = menu_items_[index].flags;
   if (flags & FLAG_OPTIONS) {
     host_->OpenButtonOptions(this);
   } else if (flags & FLAG_TOGGLE_ETHERNET) {
     cros->EnableEthernetNetworkDevice(!cros->ethernet_enabled());
   } else if (flags & FLAG_TOGGLE_WIFI) {
     cros->EnableWifiNetworkDevice(!cros->wifi_enabled());
   } else if (flags & FLAG_TOGGLE_CELLULAR) {
     cros->EnableCellularNetworkDevice(!cros->cellular_enabled());
   } else if (flags & FLAG_TOGGLE_OFFLINE) {
@@ skipping 77 matching lines @@
     MenuButton::AnimationProgressed(animation);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuButton, StatusAreaButton implementation:
 
 void NetworkMenuButton::DrawPressed(gfx::Canvas* canvas) {
   // If ethernet connected and not current connecting, then show ethernet
   // pressed icon. Otherwise, show the bars pressed icon.
-  if (NetworkLibrary::Get()->ethernet_connected() &&
+  if (CrosLibrary::Get()->GetNetworkLibrary()->ethernet_connected() &&
       !animation_connecting_.IsAnimating())
     canvas->DrawBitmapInt(IconForDisplay(
         *ResourceBundle::GetSharedInstance().
             GetBitmapNamed(IDR_STATUSBAR_NETWORK_WIRED_PRESSED), SkBitmap()),
         0, 0);
   else
     canvas->DrawBitmapInt(IconForDisplay(
         *ResourceBundle::GetSharedInstance().
             GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS_PRESSED), SkBitmap()),
         0, 0);
 }
 
 void NetworkMenuButton::DrawIcon(gfx::Canvas* canvas) {
   canvas->DrawBitmapInt(IconForDisplay(icon(), badge()), 0, 0);
 }
 
 // Override the DrawIcon method to draw the wifi icon.
 // The wifi icon is composed of 1 or more alpha-blended icons to show the
 // network strength. We also draw an animation for when there's upload/download
 // traffic.
 /* TODO(chocobo): Add this code back in when UI is finalized.
 void NetworkMenuButton::DrawIcon(gfx::Canvas* canvas) {
 
   // First draw the base icon.
   canvas->DrawBitmapInt(icon(), 0, 0);
 
   // If wifi, we draw the wifi signal bars.
-  NetworkLibrary* cros = NetworkLibrary::Get();
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (cros->wifi_connecting() ||
       (!cros->ethernet_connected() && cros->wifi_connected())) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     // We want a value between 0-1.
     // 0 reperesents no signal and 1 represents full signal strength.
     double value = cros->wifi_connecting() ?
         animation_connecting_.GetCurrentValue() :
         cros->wifi_strength() / 100.0;
     if (value < 0)
       value = 0;
@@ skipping 63 matching lines @@
                               0, 0, paint);
     }
   }
 }
 */
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuButton, NetworkLibrary::Observer implementation:
 
 void NetworkMenuButton::NetworkChanged(NetworkLibrary* cros) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  if (CrosLibrary::EnsureLoaded()) {
+  if (CrosLibrary::Get()->EnsureLoaded()) {
     if (cros->wifi_connecting() || cros->cellular_connecting()) {
       // Start the connecting animation if not running.
       if (!animation_connecting_.IsAnimating()) {
         animation_connecting_.Reset();
         animation_connecting_.StartThrobbing(std::numeric_limits<int>::max());
         SetIcon(*rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS1));
       }
     } else {
       // Stop connecting animation since we are not connecting.
       animation_connecting_.Stop();
@@ skipping 78 matching lines @@
   if (!badge.empty())
     canvas.DrawBitmapInt(badge, kBadgeX, kBadgeY);
   return canvas.ExtractBitmap();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuButton, views::ViewMenuDelegate implementation:
 
 void NetworkMenuButton::RunMenu(views::View* source, const gfx::Point& pt) {
   refreshing_menu_ = true;
-  NetworkLibrary::Get()->RequestWifiScan();
+  CrosLibrary::Get()->GetNetworkLibrary()->RequestWifiScan();
   InitMenuItems();
   network_menu_.Rebuild();
   network_menu_.UpdateStates();
   refreshing_menu_ = false;
   network_menu_.RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
 }
 
 void NetworkMenuButton::InitMenuItems() {
   menu_items_.clear();
   // Populate our MenuItems with the current list of wifi networks.
-  NetworkLibrary* cros = NetworkLibrary::Get();
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   // Ethernet
   string16 label = l10n_util::GetStringUTF16(
                        IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
   SkBitmap icon = *rb.GetBitmapNamed(IDR_STATUSBAR_WIRED_BLACK);
   SkBitmap badge = cros->ethernet_connecting() || cros->ethernet_connected() ?
       SkBitmap() : *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_DISCONNECTED);
   int flag = (cros->ethernet_connecting() || cros->ethernet_connected()) ?
       FLAG_ETHERNET | FLAG_ASSOCIATED : FLAG_ETHERNET;
@@ skipping 92 matching lines @@
     if (host_->ShouldOpenButtonOptions(this)) {
       label =
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_OPEN_OPTIONS_DIALOG);
       menu_items_.push_back(MenuItem(menus::MenuModel::TYPE_COMMAND, label,
           SkBitmap(), WifiNetwork(), CellularNetwork(), FLAG_OPTIONS));
     }
   }
 }
 
 }  // namespace chromeos