Allow networkingPrivate to request configure UI

ui/chromeos/network/network_connect.cc

 // Copyright (c) 2013 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 "ui/chromeos/network/network_connect.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 45 matching lines @@
       service_path);
 }
 
 class NetworkConnectImpl : public NetworkConnect {
  public:
   explicit NetworkConnectImpl(Delegate* delegate);
   ~NetworkConnectImpl() override;
 
   // NetworkConnect
   void ConnectToNetwork(const std::string& service_path) override;
+  bool MaybeShowConfigureUI(const std::string& service_path,
+                            const std::string& connect_error) override;
   void SetTechnologyEnabled(const chromeos::NetworkTypePattern& technology,
                             bool enabled_state) override;
   void ActivateCellular(const std::string& service_path) override;
   void ShowMobileSetup(const std::string& service_path) override;
   void ConfigureNetworkAndConnect(const std::string& service_path,
                                   const base::DictionaryValue& shill_properties,
                                   bool shared) override;
   void CreateConfigurationAndConnect(base::DictionaryValue* shill_properties,
                                      bool shared) override;
   void CreateConfiguration(base::DictionaryValue* shill_properties,
                            bool shared) override;
   base::string16 GetShillErrorString(const std::string& error,
                                      const std::string& service_path) override;
   void ShowNetworkSettingsForPath(const std::string& service_path) override;
 
  private:
   void HandleUnconfiguredNetwork(const std::string& service_path);
   void OnConnectFailed(const std::string& service_path,
                        const std::string& error_name,
                        scoped_ptr<base::DictionaryValue> error_data);
+  bool MaybeShowConfigureUIImpl(const std::string& service_path,
+                                const std::string& connect_error);
   bool GetNetworkProfilePath(bool shared, std::string* profile_path);
   void OnConnectSucceeded(const std::string& service_path);
   void CallConnectToNetwork(const std::string& service_path,
                             bool check_error_state);
   void OnActivateFailed(const std::string& service_path,
                         const std::string& error_name,
                         scoped_ptr<base::DictionaryValue> error_data);
   void OnActivateSucceeded(const std::string& service_path);
   void OnConfigureFailed(const std::string& error_name,
                          scoped_ptr<base::DictionaryValue> error_data);
@@ skipping 95 matching lines @@
       NetworkHandler::Get()->network_profile_handler()->GetDefaultUserProfile();
   if (!profile) {
     NET_LOG_ERROR("No user profile for unshared network configuration", "");
     return false;
   }
 
   *profile_path = profile->path;
   return true;
 }
 
+void NetworkConnectImpl::OnConnectFailed(
+    const std::string& service_path,
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  MaybeShowConfigureUIImpl(service_path, error_name);
+}
+
 // This handles connect failures that are a direct result of a user initiated
 // connect request and result in a new UI being shown. Note: notifications are
 // handled by NetworkStateNotifier.
-void NetworkConnectImpl::OnConnectFailed(
+bool NetworkConnectImpl::MaybeShowConfigureUIImpl(
     const std::string& service_path,
-    const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
-  NET_LOG_ERROR("Connect Failed: " + error_name, service_path);
+    const std::string& connect_error) {
+  NET_LOG_ERROR("Connect Failed: " + connect_error, service_path);
 
-  if (error_name == NetworkConnectionHandler::kErrorBadPassphrase ||
-      error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
-      error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
-      error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
+  if (connect_error == NetworkConnectionHandler::kErrorBadPassphrase ||
+      connect_error == NetworkConnectionHandler::kErrorPassphraseRequired ||
+      connect_error == NetworkConnectionHandler::kErrorConfigurationRequired ||
+      connect_error == NetworkConnectionHandler::kErrorAuthenticationRequired) {
     HandleUnconfiguredNetwork(service_path);
-    return;
+    return true;
   }
 
-  if (error_name == NetworkConnectionHandler::kErrorCertificateRequired) {
+  if (connect_error == NetworkConnectionHandler::kErrorCertificateRequired) {
     if (!delegate_->ShowEnrollNetwork(service_path))
       HandleUnconfiguredNetwork(service_path);
-    return;
+    return true;
   }
 
   // Only show a configure dialog if there was a ConnectFailed error. The dialog
   // allows the user to request a new connect attempt or cancel. Note: a
   // notification may also be displayed by NetworkStateNotifier in this case.
-  if (error_name == NetworkConnectionHandler::kErrorConnectFailed)
+  if (connect_error == NetworkConnectionHandler::kErrorConnectFailed) {
     HandleUnconfiguredNetwork(service_path);
+    return true;
+  }
 
   // Notifications for other connect failures are handled by
   // NetworkStateNotifier, so no need to do anything else here.
+  return false;
 }
 
 void NetworkConnectImpl::OnConnectSucceeded(const std::string& service_path) {
   NET_LOG_USER("Connect Succeeded", service_path);
 }
 
 // If |check_error_state| is true, error state for the network is checked,
 // otherwise any current error state is ignored (e.g. for recently configured
 // networks or repeat connect attempts).
 void NetworkConnectImpl::CallConnectToNetwork(const std::string& service_path,
@@ skipping 128 matching lines @@
       return;
     } else if (network->RequiresActivation()) {
       ActivateCellular(service_path);
       return;
     }
   }
   const bool check_error_state = true;
   CallConnectToNetwork(service_path, check_error_state);
 }
 
+bool NetworkConnectImpl::MaybeShowConfigureUI(
+    const std::string& service_path,
+    const std::string& connect_error) {
+  return MaybeShowConfigureUIImpl(service_path, connect_error);
+}
+
 void NetworkConnectImpl::SetTechnologyEnabled(
     const NetworkTypePattern& technology,
     bool enabled_state) {
   std::string log_string = base::StringPrintf(
       "technology %s, target state: %s", technology.ToDebugString().c_str(),
       (enabled_state ? "ENABLED" : "DISABLED"));
   NET_LOG_USER("SetTechnologyEnabled", log_string);
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   bool enabled = handler->IsTechnologyEnabled(technology);
   if (enabled_state == enabled) {
@@ skipping 239 matching lines @@
   return g_network_connect;
 }
 
 NetworkConnect::NetworkConnect() {
 }
 
 NetworkConnect::~NetworkConnect() {
 }
 
 }  // namespace ui