Add a unified observer to replace NetworkManagerObserver

chrome/browser/chromeos/mobile/mobile_activator_unittest.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 "chrome/browser/chromeos/mobile/mobile_activator.h"
 
 #include "chrome/browser/chromeos/cros/mock_network_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/net/connectivity_state_helper.h"
+#include "chrome/browser/chromeos/net/mock_connectivity_state_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 
 using content::BrowserThread;
 using testing::_;
 using testing::Eq;
 using testing::Return;
@@ skipping 38 matching lines @@
 
   void InvokeChangeState(CellularNetwork* network,
                          MobileActivator::PlanActivationState new_state,
                          const std::string& error_description) {
     MobileActivator::ChangeState(network, new_state, error_description);
   }
 
  private:
   MOCK_CONST_METHOD0(GetNetworkLibrary, NetworkLibrary*(void));
   MOCK_CONST_METHOD1(DCheckOnThread, void(const BrowserThread::ID id));
-
   MockNetworkLibrary* mock_network_library_;
   CellularNetwork* cellular_network_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMobileActivator);
 };
 
 class MobileActivatorTest : public testing::Test {
  public:
   MobileActivatorTest()
       : network_library_(),
         cellular_network_(string(kTestServicePath)),
         mobile_activator_(&network_library_, &cellular_network_) {}
   virtual ~MobileActivatorTest() {}
 
  protected:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  virtual void SetUp() {
+    mock_connectivity_state_helper_ = new MockConnectivityStateHelper();
+    ConnectivityStateHelper::InitializeForTesting(
+        mock_connectivity_state_helper_);
+  }
+  virtual void TearDown() {
+    ConnectivityStateHelper::Shutdown();
+  }
 
   void set_activator_state(const MobileActivator::PlanActivationState state) {
     mobile_activator_.state_ = state;
   }
   void set_network_activation_state(ActivationState state) {
     cellular_network_.activation_state_ = state;
   }
   void set_connection_state(ConnectionState state) {
     cellular_network_.state_ = state;
   }
 
   MockNetworkLibrary network_library_;

[stevenjb, 2013/03/11 23:11:05]

Here too - I'd prefer to convert this all at once.

[stevenjb, 2013/03/12 15:53:34]

And this.

   MockCellularNetwork cellular_network_;
   TestMobileActivator mobile_activator_;
+  MockConnectivityStateHelper* mock_connectivity_state_helper_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MobileActivatorTest);
 };
 
 TEST_F(MobileActivatorTest, BasicFlowForNewDevices) {
   // In a new device, we aren't connected to Verizon, we start at START
   // because we haven't paid Verizon (ever), and the modem isn't even partially
   // activated.
   std::string error_description;
   set_activator_state(MobileActivator::PLAN_ACTIVATION_START);
@@ skipping 118 matching lines @@
   EXPECT_EQ(MobileActivator::PLAN_ACTIVATION_RECONNECTING,
             mobile_activator_.PickNextState(&cellular_network_,
                                             &error_description));
   set_activator_state(MobileActivator::PLAN_ACTIVATION_SHOWING_PAYMENT);
   EXPECT_EQ(MobileActivator::PLAN_ACTIVATION_RECONNECTING,
             mobile_activator_.PickNextState(&cellular_network_,
                                             &error_description));
 }
 
 TEST_F(MobileActivatorTest, StartAtStart) {
-  EXPECT_CALL(network_library_,
+  EXPECT_CALL(*mock_connectivity_state_helper_,
               AddNetworkManagerObserver(Eq(&mobile_activator_)));
   EXPECT_CALL(network_library_, HasRecentCellularPlanPayment()).
       WillOnce(Return(false));
   EXPECT_CALL(mobile_activator_,
               EvaluateCellularNetwork(Eq(&cellular_network_)));
   mobile_activator_.StartActivation();
   EXPECT_EQ(mobile_activator_.state(), MobileActivator::PLAN_ACTIVATION_START);
 }
 
 }  // namespace chromeos