Autoconnect policy for CrOS.

chromeos/network/onc/onc_utils.cc

 // Copyright (c) 2012 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/onc/onc_utils.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 332 matching lines @@
 
   return certs_by_guid;
 }
 
 }  // namespace
 
 bool ParseAndValidateOncForImport(const std::string& onc_blob,
                                   ONCSource onc_source,
                                   const std::string& passphrase,
                                   base::ListValue* network_configs,
+                                  base::DictionaryValue* global_network_config,
                                   base::ListValue* certificates) {
+  network_configs->Clear();
+  global_network_config->Clear();
   certificates->Clear();
-  network_configs->Clear();
   if (onc_blob.empty())
     return true;
 
   scoped_ptr<base::DictionaryValue> toplevel_onc =
       ReadDictionaryFromJson(onc_blob);
   if (toplevel_onc.get() == NULL) {
     LOG(ERROR) << "ONC loaded from " << GetSourceAsString(onc_source)
                << " is not a valid JSON dictionary.";
     return false;
   }
@@ skipping 60 matching lines @@
                                          validated_networks)) {
       LOG(ERROR) << "Some certificate references in the ONC policy for source "
                  << GetSourceAsString(onc_source) << " could not be resolved.";
       success = false;
     }
 
     ResolveServerCertRefsInNetworks(server_and_ca_certs, validated_networks);
     network_configs->Swap(validated_networks);
   }
 
+  base::DictionaryValue* validated_global_config = NULL;
+  if (toplevel_onc->GetDictionaryWithoutPathExpansion(
+          toplevel_config::kGlobalNetworkConfiguration,
+          &validated_global_config)) {
+    global_network_config->Swap(validated_global_config);
+  }
+
   return success;
 }
 
 scoped_refptr<net::X509Certificate> DecodePEMCertificate(
     const std::string& pem_encoded) {
   std::string decoded = DecodePEM(pem_encoded);
   scoped_refptr<net::X509Certificate> cert =
       net::X509Certificate::CreateFromBytes(decoded.data(), decoded.size());
   LOG_IF(ERROR, !cert.get()) << "Couldn't create certificate from X509 data: "
                              << decoded;
@@ skipping 158 matching lines @@
 
 bool ResolveServerCertRefsInNetwork(const CertPEMsByGUIDMap& certs_by_guid,
                                     base::DictionaryValue* network_config) {
   return ResolveServerCertRefsInObject(certs_by_guid,
                                        kNetworkConfigurationSignature,
                                        network_config);
 }
 
 }  // namespace onc
 }  // namespace chromeos