Merge FavoriteState into NetworkState

chromeos/network/client_cert_resolver.cc

 // Copyright 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 "chromeos/network/client_cert_resolver.h"
 
 #include <cert.h>
 #include <certt.h>  // for (SECCertUsageEnum) certUsageAnyCA
 #include <pk11pub.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/certificate_pattern.h"
 #include "chromeos/network/client_cert_util.h"
-#include "chromeos/network/favorite_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
-#include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_state.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/tpm_token_loader.h"
 #include "components/onc/onc_constants.h"
 #include "dbus/object_path.h"
 #include "net/cert/scoped_nss_types.h"
 #include "net/cert/x509_certificate.h"
 
 namespace chromeos {
 
 // Describes a network |network_path| for which a matching certificate |cert_id|
@@ skipping 263 matching lines @@
 void ClientCertResolver::NetworkListChanged() {
   VLOG(2) << "NetworkListChanged.";
   if (!ClientCertificatesLoaded())
     return;
   // Configure only networks that were not configured before.
 
   // We'll drop networks from |resolved_networks_|, which are not known anymore.
   std::set<std::string> old_resolved_networks;
   old_resolved_networks.swap(resolved_networks_);
 
-  FavoriteStateList networks;
-  network_state_handler_->GetFavoriteList(&networks);
+  NetworkStateHandler::NetworkStateList networks;
+  network_state_handler_->GetNetworkListByType(
+      NetworkTypePattern::Default(),
+      true /* configured_only */,
+      false /* visible_only */,
+      0 /* no limit */,
+      &networks);
 
-  FavoriteStateList networks_to_check;
-  for (FavoriteStateList::const_iterator it = networks.begin();
-       it != networks.end(); ++it) {
+  NetworkStateHandler::NetworkStateList networks_to_check;
+  for (NetworkStateHandler::NetworkStateList::const_iterator it =
+           networks.begin(); it != networks.end(); ++it) {
     const std::string& service_path = (*it)->path();
     if (ContainsKey(old_resolved_networks, service_path)) {
       resolved_networks_.insert(service_path);
       continue;
     }
     networks_to_check.push_back(*it);
   }
 
   ResolveNetworks(networks_to_check);
 }
 
 void ClientCertResolver::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
   VLOG(2) << "OnCertificatesLoaded.";
   if (!ClientCertificatesLoaded())
     return;
   // Compare all networks with all certificates.
-  FavoriteStateList networks;
-  network_state_handler_->GetFavoriteList(&networks);
+  NetworkStateHandler::NetworkStateList networks;
+  network_state_handler_->GetNetworkListByType(
+      NetworkTypePattern::Default(),
+      true /* configured_only */,
+      false /* visible_only */,
+      0 /* no limit */,
+      &networks);
   ResolveNetworks(networks);
 }
 
 void ClientCertResolver::PolicyApplied(const std::string& service_path) {
   VLOG(2) << "PolicyApplied " << service_path;
   if (!ClientCertificatesLoaded())
     return;
   // Compare this network with all certificates.
-  const FavoriteState* network =
-      network_state_handler_->GetFavoriteStateFromServicePath(
+  const NetworkState* network =
+      network_state_handler_->GetNetworkStateFromServicePath(
           service_path, true /* configured_only */);
   if (!network) {
     LOG(ERROR) << "service path '" << service_path << "' unknown.";
     return;
   }
-  FavoriteStateList networks;
+  NetworkStateHandler::NetworkStateList networks;
   networks.push_back(network);
   ResolveNetworks(networks);
 }
 
-void ClientCertResolver::ResolveNetworks(const FavoriteStateList& networks) {
+void ClientCertResolver::ResolveNetworks(
+    const NetworkStateHandler::NetworkStateList& networks) {
   scoped_ptr<std::vector<NetworkAndCertPattern> > networks_with_pattern(
       new std::vector<NetworkAndCertPattern>);
 
   // Filter networks with ClientCertPattern. As ClientCertPatterns can only be
   // set by policy, we check there.
-  for (FavoriteStateList::const_iterator it = networks.begin();
-       it != networks.end(); ++it) {
-    const FavoriteState* network = *it;
+  for (NetworkStateHandler::NetworkStateList::const_iterator it =
+           networks.begin(); it != networks.end(); ++it) {
+    const NetworkState* network = *it;
 
     // In any case, don't check this network again in NetworkListChanged.
     resolved_networks_.insert(network->path());
 
     // If this network is not managed, it cannot have a ClientCertPattern.
     if (network->guid().empty())
       continue;
 
     if (network->profile_path().empty()) {
       LOG(ERROR) << "Network " << network->path()
@@ skipping 69 matching lines @@
     DBusThreadManager::Get()->GetShillServiceClient()->
         SetProperties(dbus::ObjectPath(it->service_path),
                         shill_properties,
                         base::Bind(&base::DoNothing),
                         base::Bind(&LogError, it->service_path));
     network_state_handler_->RequestUpdateForNetwork(it->service_path);
   }
 }
 
 }  // namespace chromeos