Add CreateFromIPv[46]Address() in PPB_NetAddress_Private.

ppapi/cpp/private/net_address_private.cc

Index: ppapi/cpp/private/net_address_private.cc
diff --git a/ppapi/cpp/private/net_address_private.cc b/ppapi/cpp/private/net_address_private.cc
index 1da2115cecf8cbfedb67e0bfd7a4f43ba2f5ebbd..79268326599ba5a1ebbd4ffca181138637b74b29 100644
--- a/ppapi/cpp/private/net_address_private.cc
+++ b/ppapi/cpp/private/net_address_private.cc
@@ -13,6 +13,10 @@ namespace pp {
 
 namespace {
 
+template <> const char* interface_name<PPB_NetAddress_Private_1_1>() {
+  return PPB_NETADDRESS_PRIVATE_INTERFACE_1_1;
+}
+
 template <> const char* interface_name<PPB_NetAddress_Private_1_0>() {
   return PPB_NETADDRESS_PRIVATE_INTERFACE_1_0;
 }
@@ -25,13 +29,18 @@ template <> const char* interface_name<PPB_NetAddress_Private_0_1>() {
 
 // static
 bool NetAddressPrivate::IsAvailable() {
-  return has_interface<PPB_NetAddress_Private_1_0>() ||
-         has_interface<PPB_NetAddress_Private_0_1>();
+  return has_interface<PPB_NetAddress_Private_1_1>() ||
+      has_interface<PPB_NetAddress_Private_1_0>() ||
+      has_interface<PPB_NetAddress_Private_0_1>();
 }
 
 // static
 bool NetAddressPrivate::AreEqual(const PP_NetAddress_Private& addr1,
                                  const PP_NetAddress_Private& addr2) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    return !!get_interface<PPB_NetAddress_Private_1_1>()->AreEqual(&addr1,
+                                                                   &addr2);
+  }

[dmichael (off chromium), 2012/03/21 19:33:17]

Is it really necessary to do the fallback here (and elsewhere in the file)?
Can't you just call the oldest 1 that we know is supported?

[viettrungluu, 2012/03/22 04:54:34]

I like the explicit fallback. It makes maintenance and eventual removal of the
fallbacks much easier: Once M19 ships to stable, we can go through and do a pile
of mass-deletes.

[dmichael (off chromium), 2012/03/22 17:19:38]

For what it's worth, for stable/public interfaces, we should not do fallback
like this except when the more recent interface provides more or better
functionality. Since we have to maintain stable/public interfaces anyway,
there's no need to come back and remove usage of the old interface. In that
case, the fallback stuff is just unnecessary code.

But I agree with your assessment for a private interface if you don't plan to
support the older versions in the future.

   if (has_interface<PPB_NetAddress_Private_1_0>()) {
     return !!get_interface<PPB_NetAddress_Private_1_0>()->AreEqual(&addr1,
                                                                    &addr2);
@@ -46,6 +55,10 @@ bool NetAddressPrivate::AreEqual(const PP_NetAddress_Private& addr1,
 // static
 bool NetAddressPrivate::AreHostsEqual(const PP_NetAddress_Private& addr1,
                                       const PP_NetAddress_Private& addr2) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    return !!get_interface<PPB_NetAddress_Private_1_1>()->AreHostsEqual(&addr1,
+                                                                        &addr2);
+  }
   if (has_interface<PPB_NetAddress_Private_1_0>()) {
     return !!get_interface<PPB_NetAddress_Private_1_0>()->AreHostsEqual(&addr1,
                                                                         &addr2);
@@ -65,7 +78,12 @@ std::string NetAddressPrivate::Describe(const PP_NetAddress_Private& addr,
     return std::string();
 
   PP_Var result_pp_var = PP_MakeUndefined();
-  if (has_interface<PPB_NetAddress_Private_1_0>()) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    result_pp_var = get_interface<PPB_NetAddress_Private_1_1>()->Describe(
+        module->pp_module(),
+        &addr,
+        PP_FromBool(include_port));
+  } else if (has_interface<PPB_NetAddress_Private_1_0>()) {
     result_pp_var = get_interface<PPB_NetAddress_Private_1_0>()->Describe(
         module->pp_module(),
         &addr,
@@ -85,6 +103,11 @@ std::string NetAddressPrivate::Describe(const PP_NetAddress_Private& addr,
 bool NetAddressPrivate::ReplacePort(const PP_NetAddress_Private& addr_in,
                                     uint16_t port,
                                     PP_NetAddress_Private* addr_out) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    return !!get_interface<PPB_NetAddress_Private_1_1>()->ReplacePort(&addr_in,
+                                                                      port,
+                                                                      addr_out);
+  }
   if (has_interface<PPB_NetAddress_Private_1_0>()) {
     return !!get_interface<PPB_NetAddress_Private_1_0>()->ReplacePort(&addr_in,
                                                                       port,
@@ -101,7 +124,11 @@ bool NetAddressPrivate::ReplacePort(const PP_NetAddress_Private& addr_in,
 // static
 void NetAddressPrivate::GetAnyAddress(bool is_ipv6,
                                       PP_NetAddress_Private* addr) {
-  if (has_interface<PPB_NetAddress_Private_1_0>()) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    get_interface<PPB_NetAddress_Private_1_1>()->GetAnyAddress(
+        PP_FromBool(is_ipv6),
+        addr);
+  } else if (has_interface<PPB_NetAddress_Private_1_0>()) {
     get_interface<PPB_NetAddress_Private_1_0>()->GetAnyAddress(
         PP_FromBool(is_ipv6),
         addr);
@@ -115,6 +142,8 @@ void NetAddressPrivate::GetAnyAddress(bool is_ipv6,
 // static
 PP_NetAddressFamily_Private NetAddressPrivate::GetFamily(
     const PP_NetAddress_Private& addr) {
+  if (has_interface<PPB_NetAddress_Private_1_1>())
+    return get_interface<PPB_NetAddress_Private_1_1>()->GetFamily(&addr);
   if (has_interface<PPB_NetAddress_Private_1_0>())
     return get_interface<PPB_NetAddress_Private_1_0>()->GetFamily(&addr);
   return PP_NETADDRESSFAMILY_UNSPECIFIED;
@@ -122,6 +151,8 @@ PP_NetAddressFamily_Private NetAddressPrivate::GetFamily(
 
 // static
 uint16_t NetAddressPrivate::GetPort(const PP_NetAddress_Private& addr) {
+  if (has_interface<PPB_NetAddress_Private_1_1>())
+    return get_interface<PPB_NetAddress_Private_1_1>()->GetPort(&addr);
   if (has_interface<PPB_NetAddress_Private_1_0>())
     return get_interface<PPB_NetAddress_Private_1_0>()->GetPort(&addr);
   return 0;
@@ -131,6 +162,12 @@ uint16_t NetAddressPrivate::GetPort(const PP_NetAddress_Private& addr) {
 bool NetAddressPrivate::GetAddress(const PP_NetAddress_Private& addr,
                                    void* address,
                                    uint16_t address_size) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    return PP_ToBool(get_interface<PPB_NetAddress_Private_1_1>()->GetAddress(
+        &addr,
+        address,
+        address_size));
+  }
   if (has_interface<PPB_NetAddress_Private_1_0>()) {
     return PP_ToBool(get_interface<PPB_NetAddress_Private_1_0>()->GetAddress(
         &addr,
@@ -140,4 +177,38 @@ bool NetAddressPrivate::GetAddress(const PP_NetAddress_Private& addr,
   return false;
 }
 
+// static
+uint32_t NetAddressPrivate::GetScopeID(const PP_NetAddress_Private& addr) {
+  if (has_interface<PPB_NetAddress_Private_1_1>())
+    return get_interface<PPB_NetAddress_Private_1_1>()->GetScopeID(&addr);
+  return 0;
+}
+
+// static
+bool NetAddressPrivate::CreateFromIPv4Address(
+    const uint8_t ip[4],
+    uint16_t port,
+    struct PP_NetAddress_Private* addr_out) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    get_interface<PPB_NetAddress_Private_1_1>()->CreateFromIPv4Address(
+        ip, port, addr_out);
+    return true;
+  }
+  return false;
+}
+
+// static
+bool NetAddressPrivate::CreateFromIPv6Address(
+    const uint8_t ip[16],
+    uint32_t scope_id,
+    uint16_t port,
+    struct PP_NetAddress_Private* addr_out) {
+  if (has_interface<PPB_NetAddress_Private_1_1>()) {
+    get_interface<PPB_NetAddress_Private_1_1>()->CreateFromIPv6Address(
+        ip, scope_id, port, addr_out);
+    return true;
+  }
+  return false;
+}
+
 }  // namespace pp