[cros, Aura] Make screen_mode static variable in StatusAreaViewChromeos

chrome/browser/chromeos/status/network_menu.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/cros/cros_library.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/status/network_menu_icon.h"
+#include "chrome/browser/chromeos/status/status_area_view_chromeos.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/views/window.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
@@ skipping 98 matching lines @@
   virtual ~NetworkMenuModel() {}
 
   // Connect or reconnect to the network at |index|.
   // If remember >= 0, set the favorite state of the network.
   void ConnectToNetworkAt(int index,
                           const std::string& passphrase,
                           const std::string& ssid,
                           int remember) const;
 
   // Called by NetworkMenu::RunMenu to initialize list of menu items.
-  virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options) = 0;
+  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 string16 GetLabelAt(int index) const OVERRIDE;
@@ skipping 58 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NetworkMenuModel);
 };
 
 
 class MoreMenuModel : public NetworkMenuModel {
  public:
   explicit MoreMenuModel(NetworkMenu* owner) : NetworkMenuModel(owner) {}
   virtual ~MoreMenuModel() {}
 
   // NetworkMenuModel implementation.
-  virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options) OVERRIDE;
+  virtual void InitMenuItems(bool should_open_button_options) OVERRIDE;
 
   // ui::MenuModel implementation
   virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MoreMenuModel);
 };
 
 class VPNMenuModel : public NetworkMenuModel {
  public:
   explicit VPNMenuModel(NetworkMenu* owner) : NetworkMenuModel(owner) {}
   virtual ~VPNMenuModel() {}
 
   // NetworkMenuModel implementation.
-  virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options) OVERRIDE;
+  virtual void InitMenuItems(bool should_open_button_options) OVERRIDE;
 
   // ui::MenuModel implementation
   virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VPNMenuModel);
 };
 
 class MainMenuModel : public NetworkMenuModel {
  public:
   explicit MainMenuModel(NetworkMenu* owner)
       : NetworkMenuModel(owner),
         vpn_menu_model_(new VPNMenuModel(owner)),
         more_menu_model_(new MoreMenuModel(owner)) {
   }
   virtual ~MainMenuModel() {}
 
   // NetworkMenuModel implementation.
-  virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options) OVERRIDE;
+  virtual void InitMenuItems(bool should_open_button_options) OVERRIDE;
 
   // ui::MenuModel implementation
   virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   scoped_ptr<NetworkMenuModel> vpn_menu_model_;
   scoped_ptr<MoreMenuModel> more_menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(MainMenuModel);
 };
@@ skipping 234 matching lines @@
     ChooseMobileNetworkDialog::ShowDialog(
         owner_->delegate()->GetNativeWindow());
   } else {
     ShowNetworkConfigView(new NetworkConfigView(type));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MainMenuModel
 
-void MainMenuModel::InitMenuItems(bool is_browser_mode,
-                                  bool should_open_button_options) {
+void MainMenuModel::InitMenuItems(bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
   menu_items_.clear();
 
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (cros->IsLocked()) {
     menu_items_.push_back(
         MenuItem(ui::MenuModel::TYPE_COMMAND,
                  l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_LOCKED),
@@ skipping 92 matching lines @@
     const CellularNetworkVector& cell_networks = cros->cellular_networks();
     const CellularNetwork* active_cellular = cros->cellular_network();
 
     bool separator_added = false;
     // List Cellular networks.
     for (size_t i = 0; i < cell_networks.size(); ++i) {
       chromeos::ActivationState activation_state =
           cell_networks[i]->activation_state();
 
       // If we are on the OOBE/login screen, do not show activating 3G option.
-      if (!is_browser_mode && activation_state != ACTIVATION_STATE_ACTIVATED)
+      if (!StatusAreaViewChromeos::IsBrowserMode() &&
+          activation_state != ACTIVATION_STATE_ACTIVATED)
         continue;
 
       // Ampersand is a valid character in a network name, but menu2 uses it
       // to mark "mnemonics" for keyboard shortcuts.  http://crosbug.com/14697
       std::string network_name = EscapeAmpersands(cell_networks[i]->name());
       if (activation_state == ACTIVATION_STATE_NOT_ACTIVATED ||
           activation_state == ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
         label = l10n_util::GetStringFUTF16(
             IDS_STATUSBAR_NETWORK_DEVICE_ACTIVATE,
             UTF8ToUTF16(network_name));
@@ skipping 46 matching lines @@
               MenuItem(ui::MenuModel::TYPE_COMMAND,
                        label, SkBitmap(),
                        std::string(), FLAG_DISABLED));
         }
       }
     }
     const NetworkDevice* cellular_device = cros->FindCellularDevice();
     if (cellular_device) {
       // Add "View Account" with top up URL if we know that.
       MobileConfig* config = MobileConfig::GetInstance();
-      if (is_browser_mode && config->IsReady()) {
+      if (StatusAreaViewChromeos::IsBrowserMode() && config->IsReady()) {
         std::string carrier_id = cros->GetCellularHomeCarrierId();
         // If we don't have top up URL cached.
         if (carrier_id != carrier_id_) {
           // Mark that we've checked this carrier ID.
           carrier_id_ = carrier_id;
           top_up_url_.clear();
           const MobileConfig::Carrier* carrier = config->GetCarrier(carrier_id);
           if (carrier && !carrier->top_up_url().empty())
             top_up_url_ = carrier->top_up_url();
         }
@@ skipping 24 matching lines @@
   // No networks available message.
   if (menu_items_.empty()) {
     label = l10n_util::GetStringFUTF16(IDS_STATUSBAR_NETWORK_MENU_ITEM_INDENT,
                 l10n_util::GetStringUTF16(IDS_STATUSBAR_NO_NETWORKS_MESSAGE));
     menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND, label,
         SkBitmap(), std::string(), FLAG_DISABLED));
   }
 
   // If we are logged in and there is a connected network or a connected VPN,
   // add submenu for Private Networks.
-  if (is_browser_mode) {
+  if (StatusAreaViewChromeos::IsBrowserMode()) {
     if (cros->connected_network() || cros->virtual_network_connected()) {
       menu_items_.push_back(MenuItem());  // Separator
       const SkBitmap icon = NetworkMenuIcon::GetVpnBitmap();
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_SUBMENU,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_PRIVATE_NETWORKS),
           icon, vpn_menu_model_.get(), FLAG_NONE));
-      vpn_menu_model_->InitMenuItems(
-          is_browser_mode, should_open_button_options);
+      vpn_menu_model_->InitMenuItems(should_open_button_options);
     }
   }
 
   bool show_wifi_scanning = wifi_available && cros->wifi_scanning();
   // Do not show disable wifi during oobe
   bool show_toggle_wifi = wifi_available &&
       (should_open_button_options || !wifi_enabled);
   // Do not show disable cellular during oobe
   bool show_toggle_cellular = cellular_available &&
       (should_open_button_options || !cellular_enabled);
@@ skipping 53 matching lines @@
   // TODO(chocobo): Uncomment once we figure out how to do offline mode.
   // menu_items_.push_back(MenuItem(cros->offline_mode() ?
   //     ui::MenuModel::TYPE_CHECK : ui::MenuModel::TYPE_COMMAND,
   //     l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_OFFLINE_MODE),
   //     SkBitmap(), std::string(), FLAG_TOGGLE_OFFLINE));
 
   // Additional links like:
   // * Network settings;
   // * IP Address on active interface;
   // * Hardware addresses for wifi and ethernet.
-  more_menu_model_->InitMenuItems(is_browser_mode, should_open_button_options);
+  more_menu_model_->InitMenuItems(should_open_button_options);
   if (!more_menu_model_->menu_items().empty()) {
     menu_items_.push_back(MenuItem());  // Separator
-    if (is_browser_mode) {
+    if (StatusAreaViewChromeos::IsBrowserMode()) {
       // In browser mode we do not want separate submenu, inline items.
       menu_items_.insert(
           menu_items_.end(),
           more_menu_model_->menu_items().begin(),
           more_menu_model_->menu_items().end());
     } else {
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_SUBMENU,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_MORE),
           SkBitmap(), more_menu_model_.get(), FLAG_NONE));
     }
   }
 }
 
 int MainMenuModel::GetCommandIdAt(int index) const {
   return index + kMainIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // VPNMenuModel
 
-void VPNMenuModel::InitMenuItems(bool is_browser_mode,
-                                 bool should_open_button_options) {
+void VPNMenuModel::InitMenuItems(bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
   menu_items_.clear();
 
   // Populate our MenuItems with the current list of virtual networks.
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   const VirtualNetworkVector& virtual_networks = cros->virtual_networks();
   const VirtualNetwork* active_vpn = cros->virtual_network();
 
@@ skipping 41 matching lines @@
   }
 }
 
 int VPNMenuModel::GetCommandIdAt(int index) const {
   return index + kVPNIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MoreMenuModel
 
-void MoreMenuModel::InitMenuItems(
-    bool is_browser_mode, bool should_open_button_options) {
+void MoreMenuModel::InitMenuItems(bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
   menu_items_.clear();
   MenuItemVector link_items;
   MenuItemVector address_items;
 
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   bool oobe = !should_open_button_options;  // we don't show options for OOBE.
   bool connected = cros->Connected();  // always call for test expectations.
   if (!oobe) {
     int message_id = -1;
-    if (is_browser_mode)
+    if (StatusAreaViewChromeos::IsBrowserMode())
       message_id = IDS_STATUSBAR_NETWORK_OPEN_OPTIONS_DIALOG;
     else if (connected)
       message_id = IDS_STATUSBAR_NETWORK_OPEN_PROXY_SETTINGS_DIALOG;
     if (message_id != -1) {
       link_items.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
                                     l10n_util::GetStringUTF16(message_id),
                                     SkBitmap(), std::string(), FLAG_OPTIONS));
     }
   }
 
   if (connected) {
     std::string ip_address = cros->IPAddress();
     if (!ip_address.empty()) {
       address_items.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
           ASCIIToUTF16(cros->IPAddress()), SkBitmap(), std::string(),
                        FLAG_DISABLED));
     }
   }
 
-  if (!is_browser_mode) {
+  if (!StatusAreaViewChromeos::IsBrowserMode()) {
     const NetworkDevice* ether = cros->FindEthernetDevice();
     if (ether) {
       std::string hardware_address;
       cros->GetIPConfigs(ether->device_path(), &hardware_address,
           NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
       if (!hardware_address.empty()) {
         std::string label = l10n_util::GetStringUTF8(
             IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET) + " " + hardware_address;
         address_items.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
             UTF8ToUTF16(label), SkBitmap(), std::string(), FLAG_DISABLED));
@@ skipping 23 matching lines @@
       address_items.begin(), address_items.end());
 }
 
 int MoreMenuModel::GetCommandIdAt(int index) const {
   return index + kMoreIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu
 
-NetworkMenu::NetworkMenu(Delegate* delegate, bool is_browser_mode)
+NetworkMenu::NetworkMenu(Delegate* delegate)
     : delegate_(delegate),
-      is_browser_mode_(is_browser_mode),
       refreshing_menu_(false),
       menu_item_view_(NULL),
       min_width_(kDefaultMinimumWidth) {
   main_menu_model_.reset(new MainMenuModel(this));
   menu_model_adapter_.reset(
       new views::MenuModelAdapter(main_menu_model_.get()));
   menu_item_view_ = new views::MenuItemView(menu_model_adapter_.get());
   menu_item_view_->set_has_icons(true);
 #if !defined(USE_AURA)
   menu_item_view_->set_menu_position(
@@ skipping 10 matching lines @@
 }
 
 void NetworkMenu::CancelMenu() {
   menu_runner_->Cancel();
 }
 
 void NetworkMenu::UpdateMenu() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   refreshing_menu_ = true;
-  main_menu_model_->InitMenuItems(
-      is_browser_mode(), delegate_->ShouldOpenButtonOptions());
+  main_menu_model_->InitMenuItems(delegate_->ShouldOpenButtonOptions());
 
   menu_model_adapter_->BuildMenu(menu_item_view_);
   SetMenuMargins(menu_item_view_, kTopMargin, kBottomMargin);
   menu_item_view_->ChildrenChanged();
 
   refreshing_menu_ = false;
 }
 
 void NetworkMenu::RunMenu(views::View* source) {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
@@ skipping 24 matching lines @@
   std::string page = StringPrintf(
       "%s?servicePath=%s&networkType=%d&networkName=%s",
       chrome::kInternetOptionsSubPage,
       net::EscapeUrlEncodedData(network->service_path(), true).c_str(),
       network->type(),
       net::EscapeUrlEncodedData(network_name, false).c_str());
   browser->ShowOptionsTab(page);
 }
 
 }  // namespace chromeos