NOT FOR REVIEW

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 231 matching lines @@
 void NetworkConnectImpl::OnConnectSucceeded(const std::string& service_path) {
   NET_LOG_USER("Connect Succeeded", service_path);
   network_state_notifier_->RemoveConnectNotification();
 }
 
 // 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,
                                               bool check_error_state) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   network_state_notifier_->RemoveConnectNotification();
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       service_path, base::Bind(&NetworkConnectImpl::OnConnectSucceeded,
                                weak_factory_.GetWeakPtr(), service_path),
       base::Bind(&NetworkConnectImpl::OnConnectFailed,
                  weak_factory_.GetWeakPtr(), service_path),
       check_error_state);
 }
 
 void NetworkConnectImpl::OnActivateFailed(
@@ skipping 12 matching lines @@
 void NetworkConnectImpl::OnConfigureFailed(
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to configure network", "");
   network_state_notifier_->ShowNetworkConnectError(
       NetworkConnectionHandler::kErrorConfigureFailed, "");
 }
 
 void NetworkConnectImpl::OnConfigureSucceeded(bool connect_on_configure,
                                               const std::string& service_path) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("Configure Succeeded", service_path);
   if (!connect_on_configure)
     return;
   // After configuring a network, ignore any (possibly stale) error state.
   const bool check_error_state = false;
   CallConnectToNetwork(service_path, check_error_state);
 }
 
 void NetworkConnectImpl::CallCreateConfiguration(
     base::DictionaryValue* shill_properties,
     bool shared,
     bool connect_on_configure) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   std::string profile_path;
   if (!GetNetworkProfilePath(shared, &profile_path)) {
     network_state_notifier_->ShowNetworkConnectError(
         NetworkConnectionHandler::kErrorConfigureFailed, "");
     return;
   }
   shill_properties->SetStringWithoutPathExpansion(shill::kProfileProperty,
                                                   profile_path);
   NetworkHandler::Get()
       ->network_configuration_handler()
@@ skipping 28 matching lines @@
   // Remove cleared properties from properties_to_set.
   for (std::vector<std::string>::iterator iter = properties_to_clear->begin();
        iter != properties_to_clear->end(); ++iter) {
     properties_to_set->RemoveWithoutPathExpansion(*iter, NULL);
   }
 }
 
 void NetworkConnectImpl::ClearPropertiesAndConnect(
     const std::string& service_path,
     const std::vector<std::string>& properties_to_clear) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("ClearPropertiesAndConnect", service_path);
   // After configuring a network, ignore any (possibly stale) error state.
   const bool check_error_state = false;
   NetworkHandler::Get()->network_configuration_handler()->ClearShillProperties(
       service_path, properties_to_clear,
       base::Bind(&NetworkConnectImpl::CallConnectToNetwork,
                  weak_factory_.GetWeakPtr(), service_path, check_error_state),
       base::Bind(&NetworkConnectImpl::SetPropertiesFailed,
                  weak_factory_.GetWeakPtr(), "ClearProperties", service_path));
 }
 
 void NetworkConnectImpl::ConfigureSetProfileSucceeded(
     const std::string& service_path,
     scoped_ptr<base::DictionaryValue> properties_to_set) {
   std::vector<std::string> properties_to_clear;
   SetPropertiesToClear(properties_to_set.get(), &properties_to_clear);
   NetworkHandler::Get()->network_configuration_handler()->SetShillProperties(
       service_path, *properties_to_set,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&NetworkConnectImpl::ClearPropertiesAndConnect,
                  weak_factory_.GetWeakPtr(), service_path, properties_to_clear),
       base::Bind(&NetworkConnectImpl::SetPropertiesFailed,
                  weak_factory_.GetWeakPtr(), "SetProperties", service_path));
 }
 
 // Public methods
 
 void NetworkConnectImpl::ConnectToNetwork(const std::string& service_path) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("ConnectToNetwork", service_path);
   const NetworkState* network = GetNetworkState(service_path);
   if (network) {
     if (!network->error().empty() && !network->security_class().empty()) {
       NET_LOG_USER("Configure: " + network->error(), service_path);
       // If the network is in an error state, show the configuration UI
       // directly to avoid a spurious notification.
       HandleUnconfiguredNetwork(service_path);
       return;
     } else if (network->RequiresActivation()) {
@@ skipping 102 matching lines @@
     network_state_notifier_->ShowMobileActivationError(service_path);
     return;
   }
   delegate_->ShowMobileSetupDialog(service_path);
 }
 
 void NetworkConnectImpl::ConfigureNetworkAndConnect(
     const std::string& service_path,
     const base::DictionaryValue& properties,
     bool shared) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("ConfigureNetworkAndConnect", service_path);
 
   scoped_ptr<base::DictionaryValue> properties_to_set(properties.DeepCopy());
 
   std::string profile_path;
   if (!GetNetworkProfilePath(shared, &profile_path)) {
     network_state_notifier_->ShowNetworkConnectError(
         NetworkConnectionHandler::kErrorConfigureFailed, service_path);
     return;
   }
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NetworkHandler::Get()->network_configuration_handler()->SetNetworkProfile(
       service_path, profile_path,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&NetworkConnectImpl::ConfigureSetProfileSucceeded,
                  weak_factory_.GetWeakPtr(), service_path,
                  base::Passed(&properties_to_set)),
       base::Bind(&NetworkConnectImpl::SetPropertiesFailed,
                  weak_factory_.GetWeakPtr(), "SetProfile: " + profile_path,
                  service_path));
 }
 
 void NetworkConnectImpl::CreateConfigurationAndConnect(
     base::DictionaryValue* properties,
     bool shared) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("CreateConfigurationAndConnect", "");
   CallCreateConfiguration(properties, shared, true /* connect_on_configure */);
 }
 
 void NetworkConnectImpl::CreateConfiguration(base::DictionaryValue* properties,
                                              bool shared) {
+  LOG(ERROR) << "*** QUICHE: " << __func__;
   NET_LOG_USER("CreateConfiguration", "");
   CallCreateConfiguration(properties, shared, false /* connect_on_configure */);
 }
 
 base::string16 NetworkConnectImpl::GetShillErrorString(
     const std::string& error,
     const std::string& service_path) {
   if (error.empty())
     return base::string16();
   if (error == shill::kErrorOutOfRange)
@@ skipping 103 matching lines @@
   return g_network_connect;
 }
 
 NetworkConnect::NetworkConnect() {
 }
 
 NetworkConnect::~NetworkConnect() {
 }
 
 }  // namespace ui