Add test cases for NetworkScreenTest.

Refactor CrosInProcessBrowserTest - granular mocks and expectations.
Fix PowerMenuButtonTest.

Review URL: http://codereview.chromium.org/1405001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@42942 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 301 insertions, 94 deletions

diff --git a/chrome/browser/chromeos/cros/cros_in_process_browser_test.cc b/chrome/browser/chromeos/cros/cros_in_process_browser_test.cc
index 142a19e..a3f8b64 100644
--- a/chrome/browser/chromeos/cros/cros_in_process_browser_test.cc
+++ b/chrome/browser/chromeos/cros/cros_in_process_browser_test.cc
@@ -26,92 +26,164 @@ using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::_;
 
-CrosInProcessBrowserTest::CrosInProcessBrowserTest() {
-}
+CrosInProcessBrowserTest::CrosInProcessBrowserTest()
+    : loader_(NULL),
+      mock_language_library_(NULL),
+      mock_network_library_(NULL),
+      mock_power_library_(NULL),
+      mock_synaptics_library_(NULL) {}
 
 CrosInProcessBrowserTest::~CrosInProcessBrowserTest() {
 }
 
-void CrosInProcessBrowserTest::SetUpInProcessBrowserTestFixture() {
-  chromeos::CrosLibrary::TestApi* test_api =
-      chromeos::CrosLibrary::Get()->GetTestApi();
+chromeos::CrosLibrary::TestApi* CrosInProcessBrowserTest::test_api() {
+  return chromeos::CrosLibrary::Get()->GetTestApi();
+}
+
+void CrosInProcessBrowserTest::InitStatusAreaMocks() {
+  InitMockLanguageLibrary();
+  InitMockNetworkLibrary();
+  InitMockPowerLibrary();
+  InitMockSynapticsLibrary();
+}
 
+void CrosInProcessBrowserTest::InitMockLibraryLoader() {
+  if (loader_)
+    return;
   loader_ = new MockLibraryLoader();
   EXPECT_CALL(*loader_, Load(_))
       .Times(AnyNumber())
       .WillRepeatedly(Return(true));
+  test_api()->SetLibraryLoader(loader_);
+}
 
-  test_api->SetLibraryLoader(loader_);
-
-  // Create minimal mocks for status bar.
+void CrosInProcessBrowserTest::InitMockLanguageLibrary() {
+  InitMockLibraryLoader();
+  if (mock_language_library_)
+    return;
   mock_language_library_ = new MockLanguageLibrary();
-  test_api->SetLanguageLibrary(mock_language_library_);
+  test_api()->SetLanguageLibrary(mock_language_library_);
+}
+
+void CrosInProcessBrowserTest::InitMockNetworkLibrary() {
+  InitMockLibraryLoader();
+  if (mock_network_library_)
+    return;
+  mock_network_library_ = new MockNetworkLibrary();
+  test_api()->SetNetworkLibrary(mock_network_library_);
+}
+
+void CrosInProcessBrowserTest::InitMockPowerLibrary() {
+  InitMockLibraryLoader();
+  if (mock_power_library_)
+    return;
+  mock_power_library_ = new MockPowerLibrary();
+  test_api()->SetPowerLibrary(mock_power_library_);
+}
+
+void CrosInProcessBrowserTest::InitMockSynapticsLibrary() {
+  InitMockLibraryLoader();
+  if (mock_synaptics_library_)
+    return;
+  mock_synaptics_library_ = new MockSynapticsLibrary();
+  test_api()->SetSynapticsLibrary(mock_synaptics_library_);
+}
+
+void CrosInProcessBrowserTest::SetStatusAreaMocksExpectations() {
+  SetLanguageLibraryStatusAreaExpectations();
+  SetNetworkLibraryStatusAreaExpectations();
+  SetPowerLibraryStatusAreaExpectations();
+  SetSynapticsLibraryExpectations();
+}
+
+void CrosInProcessBrowserTest::SetLanguageLibraryStatusAreaExpectations() {
   EXPECT_CALL(*mock_language_library_, AddObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_language_library_, GetActiveLanguages())
-      .Times(AnyNumber())
-      .WillRepeatedly(Return(CreateFallbackInputLanguageList()));
+      .Times(1)
+      .WillOnce(Return(CreateFallbackInputLanguageList()))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_language_library_, current_ime_properties())
-      .Times(AnyNumber())
-      .WillRepeatedly((ReturnRef(ime_properties_)));
+      .Times(1)
+      .WillOnce((ReturnRef(ime_properties_)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_language_library_, current_language())
-      .Times(AnyNumber())
-      .WillRepeatedly((ReturnRef(language_)));
+      .Times(1)
+      .WillOnce((ReturnRef(language_)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_language_library_, RemoveObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
+}
 
-  mock_network_library_ = new MockNetworkLibrary();
-  test_api->SetNetworkLibrary(mock_network_library_);
+void CrosInProcessBrowserTest::SetNetworkLibraryStatusAreaExpectations() {
   EXPECT_CALL(*mock_network_library_, AddObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, wifi_connecting())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, wifi_connected())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, cellular_connecting())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, cellular_connected())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, ethernet_connected())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, Connected())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, Connecting())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(1)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, RemoveObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
+}
 
-  mock_power_library_ = new MockPowerLibrary();
-  test_api->SetPowerLibrary(mock_power_library_);
+void CrosInProcessBrowserTest::SetPowerLibraryStatusAreaExpectations() {
   EXPECT_CALL(*mock_power_library_, AddObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, battery_fully_charged())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(3)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, battery_is_present())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(true)));
+      .Times(1)
+      .WillOnce((Return(true)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, battery_percentage())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(42.0)));
+      .Times(2)
+      .WillRepeatedly((Return(42.0)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, line_power_on())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+      .Times(4)
+      .WillRepeatedly((Return(false)))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, battery_time_to_empty())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(base::TimeDelta::FromMinutes(42))));
+      .Times(1)
+      .WillOnce((Return(base::TimeDelta::FromMinutes(42))))
+      .RetiresOnSaturation();
   EXPECT_CALL(*mock_power_library_, RemoveObserver(_))
-      .Times(AnyNumber());
+      .Times(1)
+      .RetiresOnSaturation();
+}
 
-  mock_synaptics_library_ = new MockSynapticsLibrary();
-  test_api->SetSynapticsLibrary(mock_synaptics_library_);
+void CrosInProcessBrowserTest::SetSynapticsLibraryExpectations() {
   EXPECT_CALL(*mock_synaptics_library_, SetBoolParameter(_, _))
       .Times(AnyNumber());
   EXPECT_CALL(*mock_synaptics_library_, SetRangeParameter(_, _))
@@ -120,13 +192,16 @@ void CrosInProcessBrowserTest::SetUpInProcessBrowserTestFixture() {
 
 void CrosInProcessBrowserTest::TearDownInProcessBrowserTestFixture() {
   // Prevent bogus gMock leak check from firing.
-  chromeos::CrosLibrary::TestApi* test_api =
-      chromeos::CrosLibrary::Get()->GetTestApi();
-  test_api->SetLibraryLoader(NULL);
-  test_api->SetLanguageLibrary(NULL);
-  test_api->SetNetworkLibrary(NULL);
-  test_api->SetPowerLibrary(NULL);
-  test_api->SetSynapticsLibrary(NULL);
+  if (loader_)
+    test_api()->SetLibraryLoader(NULL);
+  if (mock_language_library_)
+    test_api()->SetLanguageLibrary(NULL);
+  if (mock_network_library_)
+    test_api()->SetNetworkLibrary(NULL);
+  if (mock_power_library_)
+    test_api()->SetPowerLibrary(NULL);
+  if (mock_synaptics_library_)
+    test_api()->SetSynapticsLibrary(NULL);
 }
 
 }  // namespace chromeos
diff --git a/chrome/browser/chromeos/cros/cros_in_process_browser_test.h b/chrome/browser/chromeos/cros/cros_in_process_browser_test.h
index 9c9daf8..cbc102a 100644
--- a/chrome/browser/chromeos/cros/cros_in_process_browser_test.h
+++ b/chrome/browser/chromeos/cros/cros_in_process_browser_test.h
@@ -21,8 +21,8 @@ namespace chromeos {
 // CrosLibrary it will be considered as successfully loaded and libraries
 // that compose CrosLibrary will be created. The issue here is that you do
 // need to specify minimum set of mocks for you test to succeed.
-// CrosInProcessBrowserTest creates minimum set of mocks that is used
-// by status bar elements (network, input language, power).
+// CrosInProcessBrowserTest defines minimum set of mocks that is used
+// by status area elements (network, input language, power).
 // See comments for InProcessBrowserTest base class too.
 class CrosInProcessBrowserTest : public InProcessBrowserTest {
  public:
@@ -30,22 +30,45 @@ class CrosInProcessBrowserTest : public InProcessBrowserTest {
   virtual ~CrosInProcessBrowserTest();
 
  protected:
-  // These functions are overriden from InProcessBrowserTest.
-  // Called before your individual test fixture method is run, but after most
-  // of the overhead initialization has occured.
-  // This method set ups basic mocks that are used by status bar items and
-  // setups corresponding expectations for method calls.
-  // If your test needs to initialize other mocks override this method
-  // and add call to base version. To change method calls expectations just
-  // provide new macros. Most recent expectation will be used.
-  virtual void SetUpInProcessBrowserTestFixture();
+  // This method setups basic mocks that are used by status area items:
+  // LibraryLoader, Language, Network, Power, Synaptics libraries.
+  // Add call to this method at the beginning of your
+  // SetUpInProcessBrowserTestFixture.
+  void InitStatusAreaMocks();
+
+  // Initialization of CrosLibrary mock loader. If you intend calling
+  // separate init methods for mocks call this one first.
+  void InitMockLibraryLoader();
+
+  // Initialization of mocks.
+  void InitMockLanguageLibrary();
+  void InitMockNetworkLibrary();
+  void InitMockPowerLibrary();
+  void InitMockSynapticsLibrary();
+
+  // This method setups corresponding expectations for basic mocks that
+  // are used by status area items.
+  // Make sure that InitStatusAreaMocks was called before.
+  // Add call to this method in your SetUpInProcessBrowserTestFixture.
+  // They are all configured with RetiresOnSaturation().
+  // Once such expectation is used it won't block expectations you've defined.
+  void SetStatusAreaMocksExpectations();
+
+  // Methods to setup minimal mocks expectations for status area.
+  void SetLanguageLibraryStatusAreaExpectations();
+  void SetNetworkLibraryStatusAreaExpectations();
+  void SetPowerLibraryStatusAreaExpectations();
+  void SetSynapticsLibraryExpectations();
 
   // Overriden for things you would normally override TearDown for.
   virtual void TearDownInProcessBrowserTestFixture();
 
+  // TestApi gives access to CrosLibrary private members.
+  chromeos::CrosLibrary::TestApi* test_api();
+
   // Mocks, destroyed by CrosLibrary class.
-  MockLanguageLibrary* mock_language_library_;
   MockLibraryLoader* loader_;
+  MockLanguageLibrary* mock_language_library_;
   MockNetworkLibrary* mock_network_library_;
   MockPowerLibrary* mock_power_library_;
   MockSynapticsLibrary* mock_synaptics_library_;
diff --git a/chrome/browser/chromeos/login/login_manager_view_browsertest.cc b/chrome/browser/chromeos/login/login_manager_view_browsertest.cc
index 05b15b8..8d20d21 100644
--- a/chrome/browser/chromeos/login/login_manager_view_browsertest.cc
+++ b/chrome/browser/chromeos/login/login_manager_view_browsertest.cc
@@ -91,29 +91,26 @@ class LoginManagerViewTest : public CrosInProcessBrowserTest {
   }
 
   virtual void SetUpInProcessBrowserTestFixture() {
-    CrosInProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+    InitStatusAreaMocks();
+    SetStatusAreaMocksExpectations();
 
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
     mock_login_library_ = new MockLoginLibrary();
     EXPECT_CALL(*mock_login_library_, EmitLoginPromptReady())
         .Times(1);
-    test_api->SetLoginLibrary(mock_login_library_);
+    test_api()->SetLoginLibrary(mock_login_library_);
 
     mock_cryptohome_library_ = new MockCryptohomeLibrary();
     EXPECT_CALL(*mock_cryptohome_library_, IsMounted())
         .Times(AnyNumber())
         .WillRepeatedly((Return(true)));
-    test_api->SetCryptohomeLibrary(mock_cryptohome_library_);
+    test_api()->SetCryptohomeLibrary(mock_cryptohome_library_);
 
     LoginUtils::Set(new MockLoginUtils(kUsername, kPassword));
   }
 
   virtual void TearDownInProcessBrowserTestFixture() {
     CrosInProcessBrowserTest::TearDownInProcessBrowserTestFixture();
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
-    test_api->SetLoginLibrary(NULL);
+    test_api()->SetLoginLibrary(NULL);
   }
 
  private:
diff --git a/chrome/browser/chromeos/login/network_screen_browsertest.cc b/chrome/browser/chromeos/login/network_screen_browsertest.cc
index 4d85198..42afe3e 100644
--- a/chrome/browser/chromeos/login/network_screen_browsertest.cc
+++ b/chrome/browser/chromeos/login/network_screen_browsertest.cc
@@ -2,15 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <string>
+
+#include "app/l10n_util.h"
 #include "base/message_loop.h"
+#include "base/string_util.h"
 #include "chrome/browser/chromeos/cros/cros_in_process_browser_test.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/mock_login_library.h"
 #include "chrome/browser/chromeos/cros/mock_network_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/login/network_selection_view.h"
 #include "chrome/browser/chromeos/login/network_screen.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/login/wizard_screen.h"
 #include "chrome/common/chrome_switches.h"
+#include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -33,37 +40,72 @@ class NetworkScreenTest : public CrosInProcessBrowserTest {
   }
 
   virtual void SetUpInProcessBrowserTestFixture() {
-    CrosInProcessBrowserTest::SetUpInProcessBrowserTestFixture();
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
+    InitStatusAreaMocks();
 
     mock_login_library_ = new MockLoginLibrary();
-    test_api->SetLoginLibrary(mock_login_library_);
+    test_api()->SetLoginLibrary(mock_login_library_);
     EXPECT_CALL(*mock_login_library_, EmitLoginPromptReady())
         .Times(1);
 
+    // Minimal set of expectations needed on NetworkScreen initialization.
+    // Status bar expectations are defined with RetiresOnSaturation() so
+    // these mocks will be active once status bar is initialized.
+    EXPECT_CALL(*mock_network_library_, ethernet_connected())
+        .Times(1)
+        .WillOnce((Return(false)));
     EXPECT_CALL(*mock_network_library_, ethernet_connecting())
-      .Times(AnyNumber())
-      .WillRepeatedly((Return(false)));
+        .Times(1)
+        .WillOnce((Return(false)));
     EXPECT_CALL(*mock_network_library_, wifi_networks())
-      .Times(AnyNumber())
-      .WillRepeatedly((ReturnRef(wifi_networks_)));
+        .Times(1)
+        .WillOnce((ReturnRef(wifi_networks_)));
     EXPECT_CALL(*mock_network_library_, cellular_networks())
-      .Times(AnyNumber())
-      .WillRepeatedly((ReturnRef(cellular_networks_)));
+        .Times(1)
+        .WillOnce((ReturnRef(cellular_networks_)));
+    EXPECT_CALL(*mock_network_library_, AddObserver(_))
+        .Times(1);
+    EXPECT_CALL(*mock_network_library_, RemoveObserver(_))
+        .Times(1);
+
+    SetStatusAreaMocksExpectations();
   }
 
   virtual void TearDownInProcessBrowserTestFixture() {
     CrosInProcessBrowserTest::TearDownInProcessBrowserTestFixture();
-    chromeos::CrosLibrary::TestApi* test_api =
-        chromeos::CrosLibrary::Get()->GetTestApi();
-    test_api-> SetLoginLibrary(NULL);
+    test_api()->SetLoginLibrary(NULL);
   }
 
   virtual Browser* CreateBrowser(Profile* profile) {
     return NULL;
   }
 
+  void EthernetExpectations(bool connected, bool connecting) {
+    EXPECT_CALL(*mock_network_library_, ethernet_connected())
+        .Times(connected ? 2 : 1)
+        .WillRepeatedly((Return(connected)));
+    EXPECT_CALL(*mock_network_library_, ethernet_connecting())
+        .Times(connecting ? 2 : 1)
+        .WillRepeatedly((Return(connecting)));
+  }
+
+  void WifiExpectations(bool connected, bool connecting) {
+    EXPECT_CALL(*mock_network_library_, wifi_connected())
+        .Times(1)
+        .WillRepeatedly((Return(connected)));
+    EXPECT_CALL(*mock_network_library_, wifi_connecting())
+        .Times(1)
+        .WillRepeatedly((Return(connecting)));
+  }
+
+  void WifiCellularNetworksExpectations() {
+    EXPECT_CALL(*mock_network_library_, wifi_networks())
+       .Times(1)
+       .WillOnce((ReturnRef(wifi_networks_)));
+   EXPECT_CALL(*mock_network_library_, cellular_networks())
+       .Times(1)
+       .WillOnce((ReturnRef(cellular_networks_)));
+  }
+
   MockLoginLibrary* mock_login_library_;
 
   CellularNetworkVector cellular_networks_;
@@ -73,14 +115,79 @@ class NetworkScreenTest : public CrosInProcessBrowserTest {
   DISALLOW_COPY_AND_ASSIGN(NetworkScreenTest);
 };
 
-IN_PROC_BROWSER_TEST_F(NetworkScreenTest, TestInit) {
+IN_PROC_BROWSER_TEST_F(NetworkScreenTest, TestBasic) {
   WizardController* controller = WizardController::default_controller();
   ASSERT_TRUE(controller != NULL);
-  ASSERT_EQ(controller->GetNetworkScreen(), controller->current_screen());
+  NetworkScreen* network_screen = controller->GetNetworkScreen();
+  ASSERT_TRUE(network_screen != NULL);
+  ASSERT_EQ(network_screen, controller->current_screen());
+
+  NetworkSelectionView* network_view = network_screen->view();
+  ASSERT_TRUE(network_view != NULL);
+  ASSERT_EQ(1, network_screen->GetItemCount());
+  EXPECT_EQ(l10n_util::GetString(IDS_STATUSBAR_NO_NETWORKS_MESSAGE),
+            network_screen->GetItemAt(0));
+
   // Close login manager windows.
-  MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
+  // TODO(nkostylev): Figure out how to close OOBE windows in base class.
+  MessageLoop::current()->DeleteSoon(FROM_HERE,
+                                     WizardController::default_controller());
   // End the message loop to quit the test.
   MessageLoop::current()->Quit();
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkScreenTest, TestOobeNetworksConnected) {
+  WizardController* controller = WizardController::default_controller();
+  NetworkLibrary* network_library =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+  NetworkScreen* network_screen = controller->GetNetworkScreen();
+  ASSERT_TRUE(network_screen != NULL);
+  NetworkSelectionView* network_view = network_screen->view();
+  ASSERT_TRUE(network_view != NULL);
+
+  EthernetExpectations(true, false);
+  WifiCellularNetworksExpectations();
+  network_screen->NetworkChanged(network_library);
+
+  // When OOBE flow is active network selection should be explicit.
+  ASSERT_EQ(network_screen, controller->current_screen());
+  ASSERT_EQ(2, network_screen->GetItemCount());
+  EXPECT_EQ(l10n_util::GetString(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
+            network_screen->GetItemAt(1));
+
+  std::string ip_address;
+  std::string wifi_ssid("WiFi network");
+  WifiNetwork wifi;
+  wifi.connected = true;
+  wifi.ssid = wifi_ssid;
+  wifi_networks_.push_back(wifi);
+
+  EthernetExpectations(false, false);
+  WifiExpectations(true, false);
+  WifiCellularNetworksExpectations();
+  EXPECT_CALL(*mock_network_library_, wifi_ssid())
+      .Times(1)
+      .WillOnce((ReturnRef(wifi_ssid)));
+  network_screen->NetworkChanged(network_library);
+  ASSERT_EQ(network_screen, controller->current_screen());
+  ASSERT_EQ(2, network_screen->GetItemCount());
+  EXPECT_EQ(ASCIIToWide(wifi_ssid), network_screen->GetItemAt(1));
+
+  EthernetExpectations(true, false);
+  WifiExpectations(true, false);
+  WifiCellularNetworksExpectations();
+  EXPECT_CALL(*mock_network_library_, wifi_ssid())
+      .Times(1)
+      .WillOnce((ReturnRef(wifi_ssid)));
+  network_screen->NetworkChanged(network_library);
+  ASSERT_EQ(network_screen, controller->current_screen());
+  ASSERT_EQ(3, network_screen->GetItemCount());
+  EXPECT_EQ(l10n_util::GetString(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
+            network_screen->GetItemAt(1));
+  EXPECT_EQ(ASCIIToWide(wifi_ssid), network_screen->GetItemAt(2));
+
+  MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
+  MessageLoop::current()->Quit();
+}
+
 }  // namespace chromeos
diff --git a/chrome/browser/chromeos/status/power_menu_button_browsertest.cc b/chrome/browser/chromeos/status/power_menu_button_browsertest.cc
index fe627df..02922f9 100644
--- a/chrome/browser/chromeos/status/power_menu_button_browsertest.cc
+++ b/chrome/browser/chromeos/status/power_menu_button_browsertest.cc
@@ -24,6 +24,11 @@ class PowerMenuButtonTest : public CrosInProcessBrowserTest {
  protected:
   PowerMenuButtonTest() : CrosInProcessBrowserTest() {}
 
+  virtual void SetUpInProcessBrowserTestFixture() {
+    InitStatusAreaMocks();
+    SetStatusAreaMocksExpectations();
+  }
+
   PowerMenuButton* GetPowerMenuButton() {
     BrowserView* view = static_cast<BrowserView*>(browser()->window());
     PowerMenuButton* power = static_cast<BrowserStatusAreaView*>(view->