This moves the ONC parsing code into chromeos/network/onc

chrome/browser/chromeos/cros/network_library_impl_base.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 "chrome/browser/chromeos/cros/network_library_impl_base.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chromeos/cros/native_network_parser.h"
-#include "chrome/browser/chromeos/cros/onc_constants.h"
 #include "chrome/browser/chromeos/cros/onc_network_parser.h"
 #include "chrome/browser/chromeos/network_login_observer.h"
-#include "chrome/browser/chromeos/network_settings/onc_certificate_importer.h"
-#include "chrome/browser/chromeos/network_settings/onc_signature.h"
-#include "chrome/browser/chromeos/network_settings/onc_utils.h"
-#include "chrome/browser/chromeos/network_settings/onc_validator.h"
+#include "chromeos/network/onc/onc_certificate_importer.h"
+#include "chromeos/network/onc/onc_constants.h"
+#include "chromeos/network/onc/onc_signature.h"
+#include "chromeos/network/onc/onc_utils.h"
+#include "chromeos/network/onc/onc_validator.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/nss_util.h"  // crypto::GetTPMTokenInfo() for 802.1X and VPN.
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 // Only send network change notifications to observers once every 50ms.
 const int kNetworkNotifyDelayMs = 50;
 
 // How long we should remember that cellular plan payment was received.
 const int kRecentPlanPaymentHours = 6;
 
-NetworkProfileType GetProfileTypeForSource(NetworkUIData::ONCSource source) {
+NetworkProfileType GetProfileTypeForSource(onc::ONCSource source) {
   switch (source) {
-    case NetworkUIData::ONC_SOURCE_DEVICE_POLICY:
+    case onc::ONC_SOURCE_DEVICE_POLICY:
       return PROFILE_SHARED;
-    case NetworkUIData::ONC_SOURCE_USER_POLICY:
+    case onc::ONC_SOURCE_USER_POLICY:
       return PROFILE_USER;
-    case NetworkUIData::ONC_SOURCE_NONE:
-    case NetworkUIData::ONC_SOURCE_USER_IMPORT:
+    case onc::ONC_SOURCE_NONE:
+    case onc::ONC_SOURCE_USER_IMPORT:
       return PROFILE_NONE;
   }
   NOTREACHED() << "Unknown ONC source " << source;
   return PROFILE_NONE;
 }
 
+// For logging only: strings not user facing.
+std::string GetSourceAsString(onc::ONCSource source) {

[pneubeck (no reviews), 2012/12/10 09:33:10]

move to onc_utils.*

[Greg Spencer (Chromium), 2012/12/10 23:54:03]

Done.

+  switch (source) {
+    case onc::ONC_SOURCE_DEVICE_POLICY:
+      return "device policy";
+    case onc::ONC_SOURCE_USER_POLICY:
+      return "user policy";
+    case onc::ONC_SOURCE_NONE:
+      return "none";
+    case onc::ONC_SOURCE_USER_IMPORT:
+      return "user import";
+  }
+  NOTREACHED() << "unknown ONC source " << source;
+  return "unknown";
+}
+
 }  // namespace
 
 NetworkLibraryImplBase::NetworkLibraryImplBase()
     : ethernet_(NULL),
       active_wifi_(NULL),
       active_cellular_(NULL),
       active_wimax_(NULL),
       active_virtual_(NULL),
       available_devices_(0),
       enabled_devices_(0),
@@ skipping 296 matching lines @@
     result = ethernet_;
   if (active_wifi_ && active_wifi_->connected())
     result = highest_priority(result, active_wifi_);
   if (active_cellular_ && active_cellular_->connected())
     result = highest_priority(result, active_cellular_);
   if (active_wimax_ && active_wimax_->connected())
     result = highest_priority(result, active_wimax_);
   return result;
 }
 
-// Connecting order in logical prefernce.
+// Connecting order in logical preference.
 const Network* NetworkLibraryImplBase::connecting_network() const {
   if (ethernet_connecting())
     return ethernet_network();
   else if (wifi_connecting())
     return wifi_network();
   else if (cellular_connecting())
     return cellular_network();
   else if (wimax_connecting())
     return wimax_network();
   return NULL;
@@ skipping 638 matching lines @@
       break;
     if (wifi->auto_connect()) {
       ConnectToWifiNetwork(wifi);
       break;
     }
   }
 }
 
 bool NetworkLibraryImplBase::LoadOncNetworks(const std::string& onc_blob,
                                              const std::string& passphrase,
-                                             NetworkUIData::ONCSource source,
-                                             bool allow_web_trust_from_policy,
-                                             std::string* error) {
+                                             onc::ONCSource source,
+                                             bool allow_web_trust_from_policy) {
   NetworkProfile* profile = NULL;
-  bool from_policy = (source == NetworkUIData::ONC_SOURCE_USER_POLICY ||
-                      source == NetworkUIData::ONC_SOURCE_DEVICE_POLICY);
+  bool from_policy = (source == onc::ONC_SOURCE_USER_POLICY ||
+                      source == onc::ONC_SOURCE_DEVICE_POLICY);
 
   // Policies are applied to a specific Shill profile. User ONC import however
   // is applied to whatever profile Shill chooses. This should be the profile
   // that is already associated with a network and if no profile is associated
   // yet, it should be the user profile.
   if (from_policy) {
     profile = GetProfileForType(GetProfileTypeForSource(source));
     if (profile == NULL) {
-      DLOG(WARNING) << "Profile for ONC source " << source << " doesn't exist.";
+      DLOG(WARNING) << "Profile for ONC source " << GetSourceAsString(source)
+                    << " doesn't exist.";
       return false;
     }
   }
 
   VLOG(2) << __func__ << ": called on " << onc_blob;
-  std::string json_error;
   scoped_ptr<base::DictionaryValue> root_dict =
-      onc::ReadDictionaryFromJson(onc_blob, &json_error);
+      onc::ReadDictionaryFromJson(onc_blob);
   if (root_dict.get() == NULL) {
-    if (error != NULL)
-      *error = json_error;
-    LOG(WARNING) << "ONC loaded from ONC source " << source
-                 << " is not a valid json dictionary: " << json_error;
+    LOG(WARNING) << "ONC loaded from " << GetSourceAsString(source)
+                 << " is not a valid JSON dictionary.";
     return false;
   }
 
   // Check and see if this is an encrypted ONC file. If so, decrypt it.
   std::string onc_type;
   root_dict->GetStringWithoutPathExpansion(onc::kType, &onc_type);
   if (onc_type == onc::kEncryptedConfiguration) {
-    std::string decrypt_error;
-    root_dict = onc::Decrypt(passphrase, *root_dict, &decrypt_error);
+    root_dict = onc::Decrypt(passphrase, *root_dict);
     if (root_dict.get() == NULL) {
-      if (error != NULL)
-        *error = decrypt_error;
-      LOG(WARNING) << "Couldn't decrypt the ONC from source " << source
-                   << " with error: " << decrypt_error;
+      LOG(WARNING) << "Couldn't decrypt the ONC from "
+                   << GetSourceAsString(source);
       return false;
     }
   }
 
   // Validate the ONC dictionary. We are liberal and ignore unknown field
   // names and ignore invalid field names in kRecommended arrays.
   onc::Validator validator(false,  // Ignore unknown fields.
                            false,  // Ignore invalid recommended field names.
                            true,  // Fail on missing fields.
                            from_policy);
@@ skipping 20 matching lines @@
 
   // At least one of NetworkConfigurations or Certificates is required.
   LOG_IF(WARNING, (!has_network_configurations && !has_certificates))
       << "ONC from source " << source
       << " has neither NetworkConfigurations nor Certificates.";
 
   if (has_certificates) {
     VLOG(2) << "ONC file has " << certificates->GetSize() << " certificates";
 
     onc::CertificateImporter cert_importer(source, allow_web_trust_from_policy);
-    std::string cert_error;
-    if (!cert_importer.ParseAndStoreCertificates(*certificates, &cert_error)) {
-      if (error != NULL)
-        *error = cert_error;
+    if (cert_importer.ParseAndStoreCertificates(*certificates) !=
+        onc::CertificateImporter::IMPORT_OK) {
       LOG(WARNING) << "Cannot parse some of the certificates in the ONC from "
-                   << "source " << source << " with error: " << cert_error;
+                   << GetSourceAsString(source);
       return false;
     }
   }
 
   std::set<std::string> removal_ids;
   std::set<std::string>& network_ids(network_source_map_[source]);
   network_ids.clear();
   if (has_network_configurations) {
     VLOG(2) << "ONC file has " << network_configs->GetSize() << " networks";
     OncNetworkParser parser(*network_configs, source);
 
     // Parse all networks. Bail out if that fails.
     NetworkOncMap added_onc_map;
     ScopedVector<Network> networks;
     for (int i = 0; i < parser.GetNetworkConfigsSize(); i++) {
       // Parse Open Network Configuration blob into a temporary Network object.
       bool marked_for_removal = false;
       Network* network = parser.ParseNetwork(i, &marked_for_removal);
       if (!network) {
-        if (error != NULL)
-          *error = parser.parse_error();
         LOG(WARNING) << "Error during parsing network at index " << i
-                     << " from ONC source " << source
-                     << ": " << parser.parse_error();
+                     << " from ONC source " << GetSourceAsString(source);
         return false;
       }
 
       // Disallow anything but WiFi and Ethernet for device-level policy (which
       // corresponds to shared networks). See also http://crosbug.com/28741.
-      if (source == NetworkUIData::ONC_SOURCE_DEVICE_POLICY &&
+      if (source == onc::ONC_SOURCE_DEVICE_POLICY &&
           network->type() != TYPE_WIFI &&
           network->type() != TYPE_ETHERNET) {
         LOG(WARNING) << "Ignoring device-level policy-pushed network of type "
                      << network->type();
         delete network;
         continue;
       }
 
       networks.push_back(network);
-      if (!(source == NetworkUIData::ONC_SOURCE_USER_IMPORT &&
+      if (!(source == onc::ONC_SOURCE_USER_IMPORT &&
             marked_for_removal)) {
         added_onc_map[network->unique_id()] = parser.GetNetworkConfig(i);
       }
 
       if (marked_for_removal)
         removal_ids.insert(network->unique_id());
     }
 
     // Update the ONC map.
     for (NetworkOncMap::iterator iter(added_onc_map.begin());
          iter != added_onc_map.end(); ++iter) {
       const base::DictionaryValue*& entry = network_onc_map_[iter->first];
       delete entry;
       entry = iter->second->DeepCopy();
     }
 
     // Configure the networks. While doing so, collect unique identifiers of the
     // networks that are defined in the ONC blob in |network_ids|. They're later
     // used to clean out any previously-existing networks that had been
     // configured through policy but are no longer specified in the updated ONC
     // blob.
     for (std::vector<Network*>::iterator iter(networks.begin());
          iter != networks.end(); ++iter) {
       Network* network = *iter;
 
       // Don't configure a network that is supposed to be removed. For
       // policy-managed networks, the "remove" functionality of ONC is ignored.
-      if (source == NetworkUIData::ONC_SOURCE_USER_IMPORT &&
+      if (source == onc::ONC_SOURCE_USER_IMPORT &&
           removal_ids.find(network->unique_id()) != removal_ids.end()) {
         continue;
       }
 
       DictionaryValue dict;
       for (Network::PropertyMap::const_iterator props =
                network->property_map_.begin();
            props != network->property_map_.end(); ++props) {
         std::string key =
             NativeNetworkParser::property_mapper()->GetKey(props->first);
@@ skipping 23 matching lines @@
       network_ids.insert(network->unique_id());
     }
   }
 
   if (from_policy) {
     // For policy-managed networks, go through the list of existing remembered
     // networks and clean out the ones that no longer have a definition in the
     // ONC blob. We first collect the networks and do the actual deletion later
     // because ForgetNetwork() changes the remembered network vectors.
     ForgetNetworksById(source, network_ids, false);
-  } else if (source == NetworkUIData::ONC_SOURCE_USER_IMPORT) {
+  } else if (source == onc::ONC_SOURCE_USER_IMPORT) {
     if (removal_ids.empty())
       return true;
 
     ForgetNetworksById(source, removal_ids, true);
   }
 
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ skipping 125 matching lines @@
   // Do not set the active network here. Wait until we parse the network.
 }
 
 // Deletes a network. It must already be removed from any lists.
 void NetworkLibraryImplBase::DeleteNetwork(Network* network) {
   CHECK(network_map_.find(network->service_path()) == network_map_.end());
   delete network;
 }
 
 void NetworkLibraryImplBase::ForgetNetworksById(
-    NetworkUIData::ONCSource source,
+    onc::ONCSource source,
     std::set<std::string> ids,
     bool if_found) {
   std::vector<std::string> to_be_forgotten;
   for (WifiNetworkVector::iterator i = remembered_wifi_networks_.begin();
        i != remembered_wifi_networks_.end(); ++i) {
     WifiNetwork* wifi_network = *i;
     if (wifi_network->ui_data().onc_source() == source &&
         if_found == (ids.find(wifi_network->unique_id()) != ids.end()))
       to_be_forgotten.push_back(wifi_network->service_path());
   }
@@ skipping 16 matching lines @@
   std::pair<NetworkMap::iterator, bool> result =
       remembered_network_map_.insert(
           std::make_pair(network->service_path(), network));
   DCHECK(result.second);  // Should only get called with new network.
 
   // See if this is a policy-configured network that has meanwhile been removed.
   // This situation may arise when the full list of remembered networks is not
   // available to LoadOncNetworks(), which can happen due to the asynchronous
   // communication between shill and NetworkLibrary. Just tell shill to
   // delete the network now.
-  const NetworkUIData::ONCSource source = network->ui_data().onc_source();
-  if (source == NetworkUIData::ONC_SOURCE_USER_POLICY ||
-      source == NetworkUIData::ONC_SOURCE_DEVICE_POLICY) {
+  const onc::ONCSource source = network->ui_data().onc_source();
+  if (source == onc::ONC_SOURCE_USER_POLICY ||
+      source == onc::ONC_SOURCE_DEVICE_POLICY) {
     NetworkSourceMap::const_iterator network_id_set(
         network_source_map_.find(source));
     if (network_id_set != network_source_map_.end() &&
         network_id_set->second.find(network->unique_id()) ==
             network_id_set->second.end()) {
       DeleteRememberedNetwork(network->service_path());
       return false;
     }
   }
 
@@ skipping 325 matching lines @@
   GetTpmInfo();
   return tpm_slot_;
 }
 
 const std::string& NetworkLibraryImplBase::GetTpmPin() {
   GetTpmInfo();
   return tpm_pin_;
 }
 
 }  // namespace chromeos