Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl

 {#  TODO(yzshen): Make these templates more readable. #}
 
 {#  Computes the serialized size for the specified struct.
     |struct| is the struct definition.
     |input_field_pattern| should be a pattern that contains one string
     placeholder, for example, "input->%s", "p_%s". The placeholder will be
     substituted with struct field names to refer to the input fields.
     This macro is expanded to compute seriailized size for both:
     - user-defined structs: the input is an instance of the corresponding struct
       wrapper class.
@@ skipping 163 matching lines @@
 {%-         set condition = "!%s->%s.ptr" | format(output,name) %}
 {%-       endif %}
   {{_validation_check_macro(
     condition = condition,
     error_code = "mojo::internal::ValidationError::UNEXPECTED_NULL_POINTER",
     error_msg = "null %s in %s" | format(name, struct_display_name),
     should_return_errors = should_return_errors)}}
 {%-     endif %}
 {%-   elif kind|is_any_handle_kind or kind|is_interface_kind %}
 {%-     if kind|is_interface_kind %}
-  mojo::internal::InterfacePointerToData({{input_field}}.Pass(), &{{output}}->{{name}});
+  mojo::internal::InterfaceHandleToData({{input_field}}.Pass(),
+                                        &{{output}}->{{name}});
 {%-     elif kind|is_interface_request_kind %}
   {{output}}->{{name}} = {{input_field}}.PassMessagePipe().release();
 {%-     else %}
   {{output}}->{{name}} = {{input_field}}.release();
 {%-     endif %}
 {%-     if not kind|is_nullable_kind %}
 {%-       if kind|is_interface_kind %}
 {%-         set condition = "!%s->%s.handle.is_valid()" | format(output, name) %}
 {%-       else %}
 {%-         set condition = "!%s->%s.is_valid()" | format(output,name) %}
@@ skipping 51 matching lines @@
 {%-       elif kind|is_struct_kind %}
     if ({{input}}->{{name}}.ptr) {
       {{output_field}} = {{kind|get_name_for_kind}}::New();
       Deserialize_({{input}}->{{name}}.ptr, {{output_field}}.get());
     }
 {%-       else %}
 {#- Arrays and Maps #}
     Deserialize_({{input}}->{{name}}.ptr, &{{output_field}});
 {%-       endif %}
 {%-     elif kind|is_interface_kind %}
-    mojo::internal::InterfaceDataToPointer(&{{input}}->{{name}}, &{{output_field}});
+    mojo::internal::InterfaceDataToHandle(&{{input}}->{{name}}, &{{output_field}});
 {%-     elif kind|is_interface_request_kind %}
     {{output_field}}.Bind(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&{{input}}->{{name}})));
 {%-     elif kind|is_any_handle_kind %}
     {{output_field}}.reset(mojo::internal::FetchAndReset(&{{input}}->{{name}}));
 {%-     elif kind|is_enum_kind %}
     {{output_field}} = static_cast<{{kind|cpp_wrapper_type}}>({{input}}->{{name}});
 {%-     else %}
     {{output_field}} = {{input}}->{{name}};
 {%-     endif %}
 {%-   endfor %}
   } while (false);
 {%- endmacro %}
 
 {# Forward declares |struct|, and typedefs the appropriate Ptr wrapper
    (|mojo::StructPtr| or |mojo::InlinedStructPtr|).  This macro is expanded for
    all generated structs:
    - user-defined mojo structs
    - interface method params/response params #}
 {%- macro structptr_forward_decl(struct) -%}
 class {{struct.name}};
 {%    if struct|should_inline %}
 using {{struct.name}}Ptr = mojo::InlinedStructPtr<{{struct.name}}>;
 {%    else %}
 using {{struct.name}}Ptr = mojo::StructPtr<{{struct.name}}>;
 {%    endif %}
 {% endmacro %}