[CrOS Tether] Remove spammy log from Initializer.

chrome/browser/chromeos/tether/tether_service.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 28 matching lines @@
   registry->RegisterBooleanPref(prefs::kInstantTetheringAllowed, true);
   registry->RegisterBooleanPref(prefs::kInstantTetheringEnabled, true);
   chromeos::tether::Initializer::RegisterProfilePrefs(registry);
 }
 
 // static
 bool TetherService::IsFeatureFlagEnabled() {
   return base::FeatureList::IsEnabled(features::kInstantTethering);
 }
 
+void TetherService::TetherService::InitializerDelegate::InitializeTether(

[Ryan Hansberry, 2017/06/28 17:02:40]

Sorry for the noob question here: why is the double TetherService scoping
necessary? ("TetherService::TetherService::")

[Kyle Horimoto, 2017/06/28 21:57:48]

Whoa, good catch. I didn't intend for this, and I didn't actually know this
would compile this way. Fixed.

+    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) {
+  chromeos::tether::Initializer::Init(
+      cryptauth_service, std::move(notification_presenter), pref_service,
+      token_service, network_state_handler,
+      managed_network_configuration_handler, network_connect,
+      network_connection_handler);
+}
+
+void TetherService::TetherService::InitializerDelegate::ShutdownTether() {
+  chromeos::tether::Initializer::Shutdown();
+}
+
 TetherService::TetherService(
     Profile* profile,
     chromeos::PowerManagerClient* power_manager_client,
     chromeos::SessionManagerClient* session_manager_client,
     cryptauth::CryptAuthService* cryptauth_service,
     chromeos::NetworkStateHandler* network_state_handler)
     : profile_(profile),
       power_manager_client_(power_manager_client),
       session_manager_client_(session_manager_client),
       cryptauth_service_(cryptauth_service),
       network_state_handler_(network_state_handler),
+      initializer_delegate_(base::MakeUnique<InitializerDelegate>()),
       weak_ptr_factory_(this) {
   power_manager_client_->AddObserver(this);
   session_manager_client_->AddObserver(this);
 
   cryptauth_service_->GetCryptAuthDeviceManager()->AddObserver(this);
 
   network_state_handler_->AddObserver(this, FROM_HERE);
 
   registrar_.Init(profile_->GetPrefs());
   registrar_.Add(prefs::kInstantTetheringAllowed,
@@ skipping 15 matching lines @@
 void TetherService::StartTetherIfEnabled() {
   if (GetTetherTechnologyState() !=
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED) {
     return;
   }
 
   auto notification_presenter =
       base::MakeUnique<chromeos::tether::TetherNotificationPresenter>(
           profile_, message_center::MessageCenter::Get(),
           chromeos::NetworkConnect::Get());
-  chromeos::tether::Initializer::Init(
+  initializer_delegate_->InitializeTether(
       cryptauth_service_, std::move(notification_presenter),
       profile_->GetPrefs(),
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
       network_state_handler_,
       chromeos::NetworkHandler::Get()->managed_network_configuration_handler(),
       chromeos::NetworkConnect::Get(),
       chromeos::NetworkHandler::Get()->network_connection_handler());
 }
 
 void TetherService::StopTether() {
-  chromeos::tether::Initializer::Shutdown();
+  initializer_delegate_->ShutdownTether();
 }
 
 void TetherService::Shutdown() {
   if (shut_down_)
     return;
 
   shut_down_ = true;
 
   power_manager_client_->RemoveObserver(this);
   session_manager_client_->RemoveObserver(this);
@@ skipping 74 matching lines @@
   UpdateTetherTechnologyState();
 }
 
 bool TetherService::HasSyncedTetherHosts() const {
   return !cryptauth_service_->GetCryptAuthDeviceManager()
               ->GetTetherHosts()
               .empty();
 }
 
 void TetherService::UpdateTetherTechnologyState() {
-  chromeos::NetworkStateHandler::TechnologyState tether_technology_state =
+  chromeos::NetworkStateHandler::TechnologyState new_tether_technology_state =
       GetTetherTechnologyState();
 
-  network_state_handler_->SetTetherTechnologyState(tether_technology_state);
+  network_state_handler_->SetTetherTechnologyState(new_tether_technology_state);
 
-  if (tether_technology_state ==
+  if (new_tether_technology_state ==
       chromeos::NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED) {
     StartTetherIfEnabled();
   } else {
     StopTether();
   }
 }
 
 chromeos::NetworkStateHandler::TechnologyState
 TetherService::GetTetherTechnologyState() {
   if (shut_down_ || suspended_ || session_manager_client_->IsScreenLocked() ||
@@ skipping 40 matching lines @@
               chromeos::NetworkTypePattern::Cellular()));
 }
 
 bool TetherService::IsAllowedByPolicy() const {
   return profile_->GetPrefs()->GetBoolean(prefs::kInstantTetheringAllowed);
 }
 
 bool TetherService::IsEnabledbyPreference() const {
   return profile_->GetPrefs()->GetBoolean(prefs::kInstantTetheringEnabled);
 }
+
+void TetherService::SetInitializerDelegateForTest(
+    std::unique_ptr<InitializerDelegate> initializer_delegate) {
+  initializer_delegate_ = std::move(initializer_delegate);
+}