Handle prohibited technologies in device policy ONC

chromeos/network/managed_network_configuration_handler_impl.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/managed_network_configuration_handler_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
@@ skipping 16 matching lines @@
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_merger.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
 #include "chromeos/network/policy_util.h"
+#include "chromeos/network/prohibited_technologies_handler.h"
 #include "chromeos/network/shill_property_util.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 using GuidToPolicyMap = ManagedNetworkConfigurationHandler::GuidToPolicyMap;
 
@@ skipping 372 matching lines @@
   Policies* policies = NULL;
   if (ContainsKey(policies_by_user_, userhash)) {
     policies = policies_by_user_[userhash].get();
   } else {
     policies = new Policies;
     policies_by_user_[userhash] = make_linked_ptr(policies);
   }
 
   policies->global_network_config.MergeDictionary(&global_network_config);
 
+  // Update prohibited technologies.
+  const base::ListValue* prohibited_list = nullptr;
+  if (policies->global_network_config.GetListWithoutPathExpansion(
+          ::onc::global_network_config::kDisableNetworkTypes,
+          &prohibited_list) &&
+      prohibited_technologies_handler_) {
+    // Prohobited technologies are only allowed in user policy.
+    DCHECK_EQ(::onc::ONC_SOURCE_DEVICE_POLICY, onc_source);
+
+    // Build up prohibited network type list and update NetworkStateHandler.

[stevenjb, 2015/11/11 18:07:31]

Comment out of date.

[fqj, 2015/11/12 10:23:01]

Done.

+    std::vector<std::string> prohibited_technologies;
+    for (const base::Value* item : *prohibited_list) {
+      std::string prohibited_technology;
+      item->GetAsString(&prohibited_technology);
+      std::string translated_tech =
+          network_util::TranslateONCTypeToShill(prohibited_technology);
+      if (translated_tech.length())

[stevenjb, 2015/11/11 18:07:31]

!translated_tech.empty()

[fqj, 2015/11/12 10:23:01]

Done.

+        prohibited_technologies.push_back(translated_tech);
+    }
+    prohibited_technologies_handler_->SetProhibitedTechnologies(
+        prohibited_technologies);

[stevenjb, 2015/11/11 18:07:31]

Since we have a separate handler now we should move as much work as possible
there, i.e. pass a ListValue* to SetProhibitedTechnologies.

[fqj, 2015/11/12 10:23:01]

Done.

+  }
+
   GuidToPolicyMap old_per_network_config;
   policies->per_network_config.swap(old_per_network_config);
 
   // This stores all GUIDs of policies that have changed or are new.
   std::set<std::string> modified_policies;
 
   for (base::ListValue::const_iterator it = network_configs_onc.begin();
        it != network_configs_onc.end(); ++it) {
     const base::DictionaryValue* network = NULL;
     (*it)->GetAsDictionary(&network);
@@ skipping 263 matching lines @@
 ManagedNetworkConfigurationHandlerImpl::
     ~ManagedNetworkConfigurationHandlerImpl() {
   if (network_profile_handler_)
     network_profile_handler_->RemoveObserver(this);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::Init(
     NetworkStateHandler* network_state_handler,
     NetworkProfileHandler* network_profile_handler,
     NetworkConfigurationHandler* network_configuration_handler,
-    NetworkDeviceHandler* network_device_handler) {
+    NetworkDeviceHandler* network_device_handler,
+    ProhibitedTechnologiesHandler* prohibited_technologies_handler) {
   network_state_handler_ = network_state_handler;
   network_profile_handler_ = network_profile_handler;
   network_configuration_handler_ = network_configuration_handler;
   network_device_handler_ = network_device_handler;
   network_profile_handler_->AddObserver(this);
+  prohibited_technologies_handler_ = prohibited_technologies_handler;
 }
 
 void ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork(
     const std::string& service_path) {
   if (service_path.empty())
     return;
   FOR_EACH_OBSERVER(
       NetworkPolicyObserver, observers_, PolicyAppliedToNetwork(service_path));
 }
 
@@ skipping 115 matching lines @@
     scoped_ptr<base::DictionaryValue> network_properties,
     GetDevicePropertiesCallback send_callback,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Error getting device properties", service_path);
   send_callback.Run(service_path, network_properties.Pass());
 }
 
 
 }  // namespace chromeos