[CrOS Tether] Remove spammy log from Initializer.

chrome/browser/chromeos/tether/tether_service_unittest.cc

 // Copyright 2017 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/tether/tether_service.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 72 matching lines @@
  protected:
   void UpdateTetherTechnologyState() override {
     updated_technology_state_count_++;
     TetherService::UpdateTetherTechnologyState();
   }
 
  private:
   int updated_technology_state_count_ = 0;
 };
 
+class TestInitializerDelegate : public TetherService::InitializerDelegate {
+ public:
+  bool is_tether_running() { return is_tether_running_; }
+
+  // TetherService::InitializerDelegate:
+  void InitializeTether(
+      cryptauth::CryptAuthService* cryptauth_service,
+      std::unique_ptr<chromeos::tether::NotificationPresenter>
+          notification_presenter,
+      PrefService* pref_service,
+      ProfileOAuth2TokenService* token_service,
+      chromeos::NetworkStateHandler* network_state_handler,
+      chromeos::ManagedNetworkConfigurationHandler*
+          managed_network_configuration_handler,
+      chromeos::NetworkConnect* network_connect,
+      chromeos::NetworkConnectionHandler* network_connection_handler) override {
+    is_tether_running_ = true;
+  }
+
+  void ShutdownTether() override { is_tether_running_ = false; }
+
+ private:
+  bool is_tether_running_ = false;
+};
+
 }  // namespace
 
 class TetherServiceTest : public chromeos::NetworkStateTest {
  protected:
   TetherServiceTest() : NetworkStateTest() {}
   ~TetherServiceTest() override {}
 
   void SetUp() override {
     chromeos::DBusThreadManager::Initialize();
     chromeos::NetworkStateTest::SetUp();
@@ skipping 35 matching lines @@
     message_center::MessageCenter::Shutdown();
     chromeos::NetworkConnect::Shutdown();
     chromeos::NetworkHandler::Shutdown();
 
     ShutdownNetworkState();
     chromeos::NetworkStateTest::TearDown();
     chromeos::DBusThreadManager::Shutdown();
   }
 
   void CreateTetherService() {
+    test_initializer_delegate_ = new TestInitializerDelegate();
+
     tether_service_ = base::WrapUnique(new TestTetherService(
         profile_.get(), fake_power_manager_client_.get(),
         fake_session_manager_client_.get(), fake_cryptauth_service_.get(),
         network_state_handler()));
+    tether_service_->SetInitializerDelegateForTest(
+        base::WrapUnique(test_initializer_delegate_));
     base::RunLoop().RunUntilIdle();
   }
 
   void ShutdownTetherService() {
     if (tether_service_)
       tether_service_->Shutdown();
   }
 
   void SetIsScreenLocked(bool is_screen_locked) {
     fake_session_manager_client_->set_is_screen_locked(is_screen_locked);
@@ skipping 20 matching lines @@
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<chromeos::FakePowerManagerClient> fake_power_manager_client_;
   std::unique_ptr<ExtendedFakeSessionManagerClient>
       fake_session_manager_client_;
   std::unique_ptr<TestingPrefServiceSimple> test_pref_service_;
   std::unique_ptr<NiceMock<MockCryptAuthDeviceManager>>
       mock_cryptauth_device_manager_;
+  TestInitializerDelegate* test_initializer_delegate_;
   std::unique_ptr<cryptauth::FakeCryptAuthService> fake_cryptauth_service_;
   scoped_refptr<device::MockBluetoothAdapter> mock_adapter_;
   std::unique_ptr<TestTetherService> tether_service_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherServiceTest);
 };
 
 TEST_F(TetherServiceTest, TestShutdown) {
   CreateTetherService();
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 
   ShutdownTetherService();
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNAVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestSuspend) {
   CreateTetherService();
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 
   fake_power_manager_client_->SendSuspendImminent();
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNAVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   fake_power_manager_client_->SendSuspendDone();
 
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestScreenLock) {
   CreateTetherService();
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 
   SetIsScreenLocked(true);
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNAVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetIsScreenLocked(false);
 
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestFeatureFlagDisabled) {
   EXPECT_FALSE(TetherService::Get(profile_.get()));
 }
 
 TEST_F(TetherServiceTest, TestFeatureFlagEnabled) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(features::kInstantTethering);
 
   TetherService* tether_service = TetherService::Get(profile_.get());
   ASSERT_TRUE(tether_service);
   base::RunLoop().RunUntilIdle();
   tether_service->Shutdown();
 }
 
 TEST_F(TetherServiceTest, TestNoTetherHosts) {
   ON_CALL(*mock_cryptauth_device_manager_, GetTetherHosts())
       .WillByDefault(Return(std::vector<cryptauth::ExternalDeviceInfo>()));
 
   CreateTetherService();
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNAVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestProhibitedByPolicy) {
   profile_->GetPrefs()->SetBoolean(prefs::kInstantTetheringAllowed, false);
 
   CreateTetherService();
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_PROHIBITED,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestBluetoothIsNotPowered) {
   ON_CALL(*mock_adapter_, IsPowered()).WillByDefault(Return(false));
 
   CreateTetherService();
 
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNINITIALIZED,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestCellularIsUnavailable) {
   test_manager_client()->RemoveTechnology(shill::kTypeCellular);
   ASSERT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNAVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Cellular()));
 
   CreateTetherService();
 
   SetTetherTechnologyStateEnabled(false);
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_AVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(true);
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestCellularIsAvailable) {
   // TODO (lesliewatkins): Investigate why cellular needs to be removed and
   // re-added for NetworkStateHandler to return the correct TechnologyState.
   test_manager_client()->RemoveTechnology(shill::kTypeCellular);
   test_manager_client()->AddTechnology(shill::kTypeCellular, false);
 
   CreateTetherService();
 
   // Cellular disabled
   SetCellularTechnologyStateEnabled(false);
   ASSERT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_AVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Cellular()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(false);
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNINITIALIZED,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(true);
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_UNINITIALIZED,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   // Cellular enabled
   SetCellularTechnologyStateEnabled(true);
   ASSERT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Cellular()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(false);
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_AVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(true);
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 }
 
 TEST_F(TetherServiceTest, TestEnabled) {
   CreateTetherService();
 
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(false);
   EXPECT_EQ(
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_AVAILABLE,
       network_state_handler()->GetTechnologyState(
           chromeos::NetworkTypePattern::Tether()));
   EXPECT_FALSE(
       profile_->GetPrefs()->GetBoolean(prefs::kInstantTetheringEnabled));
+  EXPECT_FALSE(test_initializer_delegate_->is_tether_running());
 
   SetTetherTechnologyStateEnabled(true);
   EXPECT_EQ(chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED,
             network_state_handler()->GetTechnologyState(
                 chromeos::NetworkTypePattern::Tether()));
   EXPECT_TRUE(
       profile_->GetPrefs()->GetBoolean(prefs::kInstantTetheringEnabled));
+  EXPECT_TRUE(test_initializer_delegate_->is_tether_running());
 }
 
 // Test against a past defect that made TetherService and NetworkStateHandler
 // repeatly update technology state after the other did so. TetherService should
 // only update technology state if NetworkStateHandler has provided a different
 // state than the user preference.
 TEST_F(TetherServiceTest, TestEnabledMultipleChanges) {
   CreateTetherService();
   // CreateTetherService calls RunUntilIdle() so  UpdateTetherTechnologyState()
   // may be called multiple times in the initialization process.
   int updated_technology_state_count =
       tether_service_->updated_technology_state_count();
 
   SetTetherTechnologyStateEnabled(false);
   SetTetherTechnologyStateEnabled(false);
   SetTetherTechnologyStateEnabled(false);
 
   updated_technology_state_count++;
   EXPECT_EQ(updated_technology_state_count,
             tether_service_->updated_technology_state_count());
 
   SetTetherTechnologyStateEnabled(true);
   SetTetherTechnologyStateEnabled(true);
   SetTetherTechnologyStateEnabled(true);
 
   updated_technology_state_count++;
   EXPECT_EQ(updated_technology_state_count,
             tether_service_->updated_technology_state_count());
 }