Tether: Display a 'setup required' notification when appropriate.

chromeos/components/tether/tether_connector.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 "chromeos/components/tether/tether_connector.h"
 
 #include "base/bind.h"
 #include "chromeos/components/tether/active_host.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
+#include "chromeos/components/tether/host_scan_cache.h"
+#include "chromeos/components/tether/notification_presenter.h"
 #include "chromeos/components/tether/tether_host_fetcher.h"
 #include "chromeos/components/tether/wifi_hotspot_connector.h"
 #include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace chromeos {
 
 namespace tether {
 
 TetherConnector::TetherConnector(
     NetworkStateHandler* network_state_handler,
     WifiHotspotConnector* wifi_hotspot_connector,
     ActiveHost* active_host,
     TetherHostFetcher* tether_host_fetcher,
     BleConnectionManager* connection_manager,
     TetherHostResponseRecorder* tether_host_response_recorder,
-    DeviceIdTetherNetworkGuidMap* device_id_tether_network_guid_map)
+    DeviceIdTetherNetworkGuidMap* device_id_tether_network_guid_map,
+    HostScanCache* host_scan_cache,
+    NotificationPresenter* notification_presenter)
     : network_state_handler_(network_state_handler),
       wifi_hotspot_connector_(wifi_hotspot_connector),
       active_host_(active_host),
       tether_host_fetcher_(tether_host_fetcher),
       connection_manager_(connection_manager),
       tether_host_response_recorder_(tether_host_response_recorder),
       device_id_tether_network_guid_map_(device_id_tether_network_guid_map),
+      host_scan_cache_(host_scan_cache),
+      notification_presenter_(notification_presenter),
       weak_ptr_factory_(this) {}
 
 TetherConnector::~TetherConnector() {
   if (connect_tethering_operation_) {
     connect_tethering_operation_->RemoveObserver(this);
   }
 }
 
 void TetherConnector::ConnectToNetwork(
     const std::string& tether_network_guid,
@@ skipping 19 matching lines @@
 
   if (!device_id_pending_connection_.empty()) {
     PA_LOG(INFO) << "A connection attempt was already in progress to device "
                  << "with ID " << device_id_pending_connection_ << ". "
                  << "Canceling that connection attempt before continuing.";
     CancelConnectionAttempt(
         device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId(
             device_id_pending_connection_));
   }
 
+  if (host_scan_cache_->DoesHostRequireSetup(tether_network_guid)) {
+    const std::string& device_name =
+        network_state_handler_->GetNetworkStateFromGuid(tether_network_guid)
+            ->name();
+    notification_presenter_->NotifySetupRequired(device_name);
+  }
+
   device_id_pending_connection_ = device_id;
   success_callback_ = success_callback;
   error_callback_ = error_callback;
   active_host_->SetActiveHostConnecting(device_id, tether_network_guid);
 
   tether_host_fetcher_->FetchTetherHost(
       device_id_pending_connection_,
       base::Bind(&TetherConnector::OnTetherHostToConnectFetched,
                  weak_ptr_factory_.GetWeakPtr(),
                  device_id_pending_connection_));
@@ skipping 94 matching lines @@
   if (!tether_host_to_connect) {
     PA_LOG(ERROR) << "Could not fetch tether host with device ID "
                   << cryptauth::RemoteDevice::TruncateDeviceIdForLogs(device_id)
                   << ". Cannot connect.";
     SetConnectionFailed(NetworkConnectionHandler::kErrorConnectFailed);
     return;
   }
 
   DCHECK(device_id == tether_host_to_connect->GetDeviceId());
 
+  // TODO (hansberry): Indicate to ConnectTetheringOperation if first-time setup
+  // is required, so that it can adjust its timeout duration.
   connect_tethering_operation_ =
       ConnectTetheringOperation::Factory::NewInstance(
           *tether_host_to_connect, connection_manager_,
           tether_host_response_recorder_);
   connect_tethering_operation_->AddObserver(this);
   connect_tethering_operation_->Initialize();
 }
 
 void TetherConnector::SetConnectionFailed(const std::string& error_name) {
   DCHECK(!device_id_pending_connection_.empty());
   DCHECK(!error_callback_.is_null());
 
+  notification_presenter_->RemoveSetupRequiredNotification();
+
   // Save a copy of the callback before resetting it below.
   network_handler::StringResultCallback error_callback = error_callback_;
 
   device_id_pending_connection_.clear();
   success_callback_.Reset();
   error_callback_.Reset();
 
   error_callback.Run(error_name);
   active_host_->SetActiveHostDisconnected();
 }
 
 void TetherConnector::SetConnectionSucceeded(
     const std::string& device_id,
     const std::string& wifi_network_guid) {
   DCHECK(!device_id_pending_connection_.empty());
   DCHECK(device_id_pending_connection_ == device_id);
   DCHECK(!success_callback_.is_null());
 
+  notification_presenter_->RemoveSetupRequiredNotification();
+
   // Save a copy of the callback before resetting it below.
   base::Closure success_callback = success_callback_;
 
   device_id_pending_connection_.clear();
   success_callback_.Reset();
   error_callback_.Reset();
 
   success_callback.Run();
   active_host_->SetActiveHostConnected(
       device_id,
@@ skipping 26 matching lines @@
     SetConnectionFailed(NetworkConnectionHandler::kErrorConnectFailed);
     return;
   }
 
   SetConnectionSucceeded(device_id, wifi_network_guid);
 }
 
 }  // namespace tether
 
 }  // namespace chromeos