[CrOS Tether] Add tether network properties (battery percentage, carrier, and signal strength) to t…

chromeos/network/onc/onc_validator.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_validator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 111 matching lines @@
     } else if (&signature == &kGlobalNetworkConfigurationSignature) {
       valid = ValidateGlobalNetworkConfiguration(repaired.get());
     } else if (&signature == &kProxySettingsSignature) {
       valid = ValidateProxySettings(repaired.get());
     } else if (&signature == &kProxyLocationSignature) {
       valid = ValidateProxyLocation(repaired.get());
     } else if (&signature == &kEAPSignature) {
       valid = ValidateEAP(repaired.get());
     } else if (&signature == &kCertificateSignature) {
       valid = ValidateCertificate(repaired.get());
+    } else if (&signature == &kTetherSignature) {
+      valid = ValidateTether(repaired.get());
     }
   }
 
   if (valid)
     return repaired;
 
   DCHECK(error_or_warning_found_);
   error_or_warning_found_ = *error = true;
   return std::unique_ptr<base::DictionaryValue>();
 }
@@ skipping 398 matching lines @@
 
   if (IsGlobalNetworkConfigInUserImport(*result))
     return false;
 
   return true;
 }
 
 bool Validator::ValidateNetworkConfiguration(base::DictionaryValue* result) {
   using namespace ::onc::network_config;
 
-  const char* const kValidTypes[] = {::onc::network_type::kEthernet,
-                                     ::onc::network_type::kVPN,
-                                     ::onc::network_type::kWiFi,
-                                     ::onc::network_type::kCellular,
-                                     ::onc::network_type::kWimax};
+  const char* const kValidTypes[] = {
+      ::onc::network_type::kEthernet, ::onc::network_type::kVPN,
+      ::onc::network_type::kWiFi,     ::onc::network_type::kCellular,
+      ::onc::network_type::kWimax,    ::onc::network_type::kTether};
   const std::vector<const char*> valid_types(toVector(kValidTypes));
   const char* const kValidIPConfigTypes[] = {kIPConfigTypeDHCP,
                                              kIPConfigTypeStatic};
   const std::vector<const char*> valid_ipconfig_types(
       toVector(kValidIPConfigTypes));
   if (FieldExistsAndHasNoValidValue(*result, kType, valid_types) ||
       FieldExistsAndHasNoValidValue(*result, kIPAddressConfigType,
                                     valid_ipconfig_types) ||
       FieldExistsAndHasNoValidValue(*result, kNameServersConfigType,
                                     valid_ipconfig_types) ||
@@ skipping 44 matching lines @@
       all_required_exist &=
           RequireField(*result, ::onc::network_config::kEthernet);
     } else if (type == ::onc::network_type::kCellular) {
       all_required_exist &=
           RequireField(*result, ::onc::network_config::kCellular);
     } else if (type == ::onc::network_type::kWimax) {
       all_required_exist &=
           RequireField(*result, ::onc::network_config::kWimax);
     } else if (type == ::onc::network_type::kVPN) {
       all_required_exist &= RequireField(*result, ::onc::network_config::kVPN);
+    } else if (type == ::onc::network_type::kTether) {
+      all_required_exist &=
+          RequireField(*result, ::onc::network_config::kTether);
     }
   }
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 bool Validator::ValidateEthernet(base::DictionaryValue* result) {
   using namespace ::onc::ethernet;
 
   const char* const kValidAuthentications[] = {kAuthenticationNone, k8021X};
@@ skipping 262 matching lines @@
     if (onc_source_ != ::onc::ONC_SOURCE_DEVICE_POLICY) {
       error_or_warning_found_ = true;
       LOG(ERROR)
           << "AllowOnlyPolicyNetworksToConnect only allowed in device policy.";
       return false;
     }
   }
 
   // Ensure the list contains only legitimate network type identifiers.
   const char* const kValidNetworkTypeValues[] = {kCellular, kEthernet, kWiFi,
-                                                 kWimax};
+                                                 kWimax, kTether};
   const std::vector<const char*> valid_network_type_values(
       toVector(kValidNetworkTypeValues));
   if (!ListFieldContainsValidValues(*result, kDisableNetworkTypes,
                                     valid_network_type_values)) {
     return false;
   }
   return true;
 }
 
 bool Validator::ValidateProxySettings(base::DictionaryValue* result) {
@@ skipping 96 matching lines @@
   all_required_exist &= RequireField(*result, kType);
 
   if (type == kClient)
     all_required_exist &= RequireField(*result, kPKCS12);
   else if (type == kServer || type == kAuthority)
     all_required_exist &= RequireField(*result, kX509);
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
+bool Validator::ValidateTether(base::DictionaryValue* result) {
+  using namespace ::onc::tether;
+
+  int batteryPercentage;
+  if (!result->GetIntegerWithoutPathExpansion(kBatteryPercentage,
+                                              &batteryPercentage) ||
+      batteryPercentage < 0 || batteryPercentage > 100) {
+    // Battery percentage must be present and within [0, 100].
+    error_or_warning_found_ = true;
+    return false;
+  }

[stevenjb, 2017/04/18 22:23:06]

This pattern is for optional parameters. Personally I think making these
optional is fine, but we should be consistent.

[Kyle Horimoto, 2017/04/18 23:25:21]

Done.

+
+  int signalStrength;
+  if (!result->GetIntegerWithoutPathExpansion(kSignalStrength,
+                                              &signalStrength) ||
+      signalStrength < 0 || signalStrength > 100) {
+    // Signal strength must be present and within [0, 100].
+    error_or_warning_found_ = true;
+    return false;
+  }
+
+  bool all_required_exist = RequireField(*result, kCarrier);
+  if (!all_required_exist) {
+    error_or_warning_found_ = true;
+    return false;
+  }
+
+  return !error_on_missing_field_ || all_required_exist;
+}
+
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : base::JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos