This updates the StaticIP configuration UI to match new mocks.

chrome/browser/chromeos/cros/cros_network_functions.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/cros_network_functions.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/string_tokenizer.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/sms_watcher.h"
 #include "chromeos/dbus/cashew_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/flimflam_device_client.h"
 #include "chromeos/dbus/flimflam_ipconfig_client.h"
 #include "chromeos/dbus/flimflam_manager_client.h"
 #include "chromeos/dbus/flimflam_network_client.h"
 #include "chromeos/dbus/flimflam_profile_client.h"
@@ skipping 205 matching lines @@
     return IPCONFIG_TYPE_BOOTP;
   if (type == flimflam::kTypeZeroConf)
     return IPCONFIG_TYPE_ZEROCONF;
   if (type == flimflam::kTypeDHCP6)
     return IPCONFIG_TYPE_DHCP6;
   if (type == flimflam::kTypePPP)
     return IPCONFIG_TYPE_PPP;
   return IPCONFIG_TYPE_UNKNOWN;
 }
 
-// Converts a prefix length to a netmask. (for ipv4)
-// e.g. a netmask of 255.255.255.0 has a prefixlen of 24
-std::string PrefixlenToNetmask(int32 prefixlen) {
-  std::string netmask;
-  for (int i = 0; i < 4; i++) {
-    int len = 8;
-    if (prefixlen >= 8) {
-      prefixlen -= 8;
-    } else {
-      len = prefixlen;
-      prefixlen = 0;
-    }
-    if (i > 0)
-      netmask += ".";
-    int num = len == 0 ? 0 : ((2L << (len - 1)) - 1) << (8 - len);
-    netmask += StringPrintf("%d", num);
-  }
-  return netmask;
-}
-
 // Converts a list of name servers to a string.
 std::string ConvertNameSerersListToString(const base::ListValue& name_servers) {
   std::string result;
   for (size_t i = 0; i != name_servers.GetSize(); ++i) {
     std::string name_server;
     if (!name_servers.GetString(i, &name_server)) {
       LOG(ERROR) << "name_servers[" << i << "] is not a string.";
       continue;
     }
     if (!result.empty())
@@ skipping 34 matching lines @@
   base::ListValue* name_servers = NULL;
   std::string name_servers_string;
   // store nameservers as a comma delimited list
   if (properties->GetListWithoutPathExpansion(flimflam::kNameServersProperty,
                                               &name_servers)) {
     name_servers_string = ConvertNameSerersListToString(*name_servers);
   } else {
     LOG(ERROR) << "Cannot get name servers.";
   }
   ipconfig_vector->push_back(
-      NetworkIPConfig(device_path, ParseIPConfigType(type_string), address,
-                      PrefixlenToNetmask(prefix_len), gateway,
+      NetworkIPConfig(device_path,
+                      ParseIPConfigType(type_string),
+                      address,
+                      CrosPrefixLengthToNetmask(prefix_len),
+                      gateway,
                       name_servers_string));
   return true;
 }
 
 }  // namespace
 
 SMS::SMS()
     : validity(0),
       msgclass(0) {
 }
@@ skipping 450 matching lines @@
   if (!found_at_least_one_device)
     return false;  // No powered device found that has a 'Networks' array.
   return true;
 }
 
 void CrosConfigureService(const base::DictionaryValue& properties) {
   DBusThreadManager::Get()->GetFlimflamManagerClient()->ConfigureService(
       properties, base::Bind(&DoNothing));
 }
 
+std::string CrosPrefixLengthToNetmask(int32 prefix_length) {
+  std::string netmask;
+  // Return the empty string for invalid inputs.
+  if (prefix_length < 0 || prefix_length > 32)
+    return netmask;
+  for (int i = 0; i < 4; i++) {
+    int remainder = 8;
+    if (prefix_length >= 8) {
+      prefix_length -= 8;
+    } else {
+      remainder = prefix_length;
+      prefix_length = 0;
+    }
+    if (i > 0)
+      netmask += ".";
+    int value = remainder == 0 ? 0 :
+        ((2L << (remainder - 1)) - 1) << (8 - remainder);
+    netmask += StringPrintf("%d", value);
+  }
+  return netmask;
+}
+
+int32 CrosNetmaskToPrefixLength(const std::string& netmask) {
+  int count = 0;
+  int prefix_length = 0;
+  StringTokenizer t(netmask, ".");
+  while (t.GetNext()) {
+    // If there are more than 4 numbers, then it's invalid.
+    if (count == 4) {
+      return -1;
+    }

[stevenjb, 2012/08/13 17:43:44]

Nit: this check might make a little more sense where count is incremented.

[Greg Spencer (Chromium), 2012/08/13 23:53:44]

Done.

+    std::string token = t.token();
+    // If we already found the last mask and the current one is not
+    // "0" then the netmask is invalid. For example, 255.224.255.0
+    if (prefix_length / 8 != count) {
+      if (token != "0") {
+        return -1;
+      }
+    } else if (token == "255") {
+      prefix_length += 8;
+    } else if (token == "254") {
+      prefix_length += 7;
+    } else if (token == "252") {
+      prefix_length += 6;
+    } else if (token == "248") {
+      prefix_length += 5;
+    } else if (token == "240") {
+      prefix_length += 4;
+    } else if (token == "224") {
+      prefix_length += 3;
+    } else if (token == "192") {
+      prefix_length += 2;
+    } else if (token == "128") {
+      prefix_length += 1;
+    } else if (token == "0") {
+      prefix_length += 0;
+    } else {
+      // mask is not a valid number.
+      return -1;
+    }
+    count++;
+  }
+  if (count < 4)
+    return -1;
+  return prefix_length;
+}
+
 }  // namespace chromeos