Handle prohibited technologies in device policy ONC

chromeos/network/network_handler.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/network_handler.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/auto_connect_handler.h"
 #include "chromeos/network/client_cert_resolver.h"
 #include "chromeos/network/geolocation_handler.h"
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
 #include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_cert_migrator.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler_impl.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_profile_observer.h"
 #include "chromeos/network/network_sms_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
+#include "chromeos/network/prohibited_technologies_handler.h"
 
 namespace chromeos {
 
 static NetworkHandler* g_network_handler = NULL;
 
 NetworkHandler::NetworkHandler()
     : task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   CHECK(DBusThreadManager::IsInitialized());
 
   network_state_handler_.reset(new NetworkStateHandler());
   network_device_handler_.reset(new NetworkDeviceHandlerImpl());
   network_profile_handler_.reset(new NetworkProfileHandler());
   network_configuration_handler_.reset(new NetworkConfigurationHandler());
   managed_network_configuration_handler_.reset(
       new ManagedNetworkConfigurationHandlerImpl());
+  prohibited_technologies_handler_.reset(new ProhibitedTechnologiesHandler());
   if (CertLoader::IsInitialized()) {
     auto_connect_handler_.reset(new AutoConnectHandler());
     network_cert_migrator_.reset(new NetworkCertMigrator());
     client_cert_resolver_.reset(new ClientCertResolver());
   }
   network_activation_handler_.reset(new NetworkActivationHandler());
   network_connection_handler_.reset(new NetworkConnectionHandler());
   network_sms_handler_.reset(new NetworkSmsHandler());
   geolocation_handler_.reset(new GeolocationHandler());
 }
 
 NetworkHandler::~NetworkHandler() {
 }
 
 void NetworkHandler::Init() {
   network_state_handler_->InitShillPropertyHandler();
   network_device_handler_->Init(network_state_handler_.get());
   network_profile_handler_->Init();
   network_configuration_handler_->Init(network_state_handler_.get(),
                                        network_device_handler_.get());
   managed_network_configuration_handler_->Init(
-      network_state_handler_.get(),
-      network_profile_handler_.get(),
-      network_configuration_handler_.get(),
-      network_device_handler_.get());
+      network_state_handler_.get(), network_profile_handler_.get(),
+      network_configuration_handler_.get(), network_device_handler_.get(),
+      prohibited_technologies_handler_.get());
   network_connection_handler_->Init(
       network_state_handler_.get(),
       network_configuration_handler_.get(),
       managed_network_configuration_handler_.get());
   if (network_cert_migrator_)
     network_cert_migrator_->Init(network_state_handler_.get());
   if (client_cert_resolver_) {
     client_cert_resolver_->Init(network_state_handler_.get(),
                                 managed_network_configuration_handler_.get());
   }
   if (auto_connect_handler_) {
     auto_connect_handler_->Init(client_cert_resolver_.get(),
                                 network_connection_handler_.get(),
                                 network_state_handler_.get(),
                                 managed_network_configuration_handler_.get());
   }
+  prohibited_technologies_handler_->Init(
+      managed_network_configuration_handler_.get(),
+      network_state_handler_.get());
   network_sms_handler_->Init();
   geolocation_handler_->Init();
 }
 
 // static
 void NetworkHandler::Initialize() {
   CHECK(!g_network_handler);
   g_network_handler = new NetworkHandler();
   g_network_handler->Init();
 }
@@ skipping 47 matching lines @@
 }
 
 NetworkSmsHandler* NetworkHandler::network_sms_handler() {
   return network_sms_handler_.get();
 }
 
 GeolocationHandler* NetworkHandler::geolocation_handler() {
   return geolocation_handler_.get();
 }
 
+ProhibitedTechnologiesHandler*
+NetworkHandler::prohibited_technologies_handler() {
+  return prohibited_technologies_handler_.get();
+}
+
 }  // namespace chromeos