Add CreateFromIPv[46]Address() in PPB_NetAddress_Private.

ppapi/cpp/private/net_address_private.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 "ppapi/cpp/private/net_address_private.h"
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/var.h"
 
 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;
 }
 
 template <> const char* interface_name<PPB_NetAddress_Private_0_1>() {
   return PPB_NETADDRESS_PRIVATE_INTERFACE_0_1;
 }
 
 }  // namespace
 
 // 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);
   }
   if (has_interface<PPB_NetAddress_Private_0_1>()) {
     return !!get_interface<PPB_NetAddress_Private_0_1>()->AreEqual(&addr1,
                                                                    &addr2);
   }
   return false;
 }
 
 // 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);
   }
   if (has_interface<PPB_NetAddress_Private_0_1>()) {
     return !!get_interface<PPB_NetAddress_Private_0_1>()->AreHostsEqual(&addr1,
                                                                         &addr2);
   }
   return false;
 }
 
 // static
 std::string NetAddressPrivate::Describe(const PP_NetAddress_Private& addr,
                                         bool include_port) {
   Module* module = Module::Get();
   if (!module)
     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,
         PP_FromBool(include_port));
   } else if (has_interface<PPB_NetAddress_Private_0_1>()) {
     result_pp_var = get_interface<PPB_NetAddress_Private_0_1>()->Describe(
         module->pp_module(),
         &addr,
         PP_FromBool(include_port));
   }
 
   Var result(PASS_REF, result_pp_var);
   return result.is_string() ? result.AsString() : std::string();
 }
 
 // static
 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,
                                                                       addr_out);
   }
   if (has_interface<PPB_NetAddress_Private_0_1>()) {
     return !!get_interface<PPB_NetAddress_Private_0_1>()->ReplacePort(&addr_in,
                                                                       port,
                                                                       addr_out);
   }
   return false;
 }
 
 // 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);
   } else if (has_interface<PPB_NetAddress_Private_0_1>()) {
     get_interface<PPB_NetAddress_Private_0_1>()->GetAnyAddress(
         PP_FromBool(is_ipv6),
         addr);
   }
 }
 
 // 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;
 }
 
 // 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;
 }
 
 // static
 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,
         address,
         address_size));
   }
   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