Pepper: Make C++ wrappers for PPB_NetAddress_Private backwards compatible.

(The compatibility is needed for Pepper Flash to use the wrappers.)

Also fix the IDL file to correctly specify that version 1.0 is only available
starting with M19. (The generated header itself didn't change, since we're
currently generating for M19.)

Review URL: https://chromiumcodereview.appspot.com/9618014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@125422 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 74 insertions, 41 deletions

diff --git a/ppapi/api/private/ppb_net_address_private.idl b/ppapi/api/private/ppb_net_address_private.idl
index 374164e..01a370b 100644
--- a/ppapi/api/private/ppb_net_address_private.idl
+++ b/ppapi/api/private/ppb_net_address_private.idl
@@ -9,7 +9,7 @@
 
 label Chrome {
     M17 = 0.1,
-    M18 = 1.0
+    M19 = 1.0
 };
 
 [assert_size(4)]
diff --git a/ppapi/cpp/private/net_address_private.cc b/ppapi/cpp/private/net_address_private.cc
index 19bf2d3732..1da2115 100644
--- a/ppapi/cpp/private/net_address_private.cc
+++ b/ppapi/cpp/private/net_address_private.cc
@@ -13,49 +13,71 @@ namespace pp {
 
 namespace {
 
-template <> const char* interface_name<PPB_NetAddress_Private>() {
-  return PPB_NETADDRESS_PRIVATE_INTERFACE;
+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>();
+  return 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>())
-    return false;
-  return !!get_interface<PPB_NetAddress_Private>()->AreEqual(&addr1, &addr2);
+  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>())
-    return false;
-  return !!get_interface<PPB_NetAddress_Private>()->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) {
-  if (!has_interface<PPB_NetAddress_Private>())
-    return std::string();
-
   Module* module = Module::Get();
   if (!module)
     return std::string();
 
-  Var result(PASS_REF,
-             get_interface<PPB_NetAddress_Private>()->Describe(
-                 module->pp_module(),
-                 &addr,
-                 PP_FromBool(include_port)));
+  PP_Var result_pp_var = PP_MakeUndefined();
+  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();
 }
 
@@ -63,48 +85,59 @@ 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>())
-    return false;
-  return !!get_interface<PPB_NetAddress_Private>()->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>())
-    return;
-  get_interface<PPB_NetAddress_Private>()->GetAnyAddress(
-      PP_FromBool(is_ipv6),
-      addr);
+  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>())
-    return PP_NETADDRESSFAMILY_UNSPECIFIED;
-  return get_interface<PPB_NetAddress_Private>()->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>())
-    return 0;
-  return get_interface<PPB_NetAddress_Private>()->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>())
-    return false;
-  return PP_ToBool(get_interface<PPB_NetAddress_Private>()->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;
 }
 
 }  // namespace pp