mojo::Callback -> base::Callback

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- import "struct_macros.tmpl" as struct_macros %}
 
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
 {%- macro alloc_params(struct, params, message, serialization_context,
                        description) %}
   ({{params}})->DecodePointers();
@@ skipping 207 matching lines @@
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method.response_param_struct %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder
-    : public {{class_name}}::{{method.name}}Callback::Runnable {
+    : public base::RefCountedThreadSafe<
+          {{class_name}}_{{method.name}}_ProxyToResponder> {
  public:
-  ~{{class_name}}_{{method.name}}_ProxyToResponder() override {
+  static {{class_name}}::{{method.name}}Callback CreateCallback(
+      uint64_t request_id,
+      bool is_sync,
+      mojo::MessageReceiverWithStatus* responder,
+      scoped_refptr<mojo::internal::MultiplexRouter> router) {
+    scoped_refptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy
+        = new {{class_name}}_{{method.name}}_ProxyToResponder(
+            request_id, is_sync, responder, router);
+    return base::Bind(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
+                      proxy);
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<
+      {{class_name}}_{{method.name}}_ProxyToResponder>;
+
+  {{class_name}}_{{method.name}}_ProxyToResponder(
+      uint64_t request_id,
+      bool is_sync,
+      mojo::MessageReceiverWithStatus* responder,
+      scoped_refptr<mojo::internal::MultiplexRouter> router)
+      : request_id_(request_id),
+        is_sync_(is_sync),
+        responder_(responder),
+        serialization_context_(std::move(router)) {
+  }
+
+  ~{{class_name}}_{{method.name}}_ProxyToResponder() {
 #if DCHECK_IS_ON()
     if (responder_) {
       // Is the Mojo application destroying the callback without running it
       // and without first closing the pipe?
       responder_->DCheckInvalid("The callback passed to "
           "{{class_name}}::{{method.name}}({%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback) "
           "was never run.");
     }
 #endif
     // If the Callback was dropped then deleting the responder will close
     // the pipe so the calling application knows to stop waiting for a reply.
     delete responder_;
   }
 
-  {{class_name}}_{{method.name}}_ProxyToResponder(
-      uint64_t request_id,
-      bool is_sync,
-      mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::internal::MultiplexRouter> router)
-      : request_id_(request_id),
-        is_sync_(is_sync),
-        responder_(responder),
-        serialization_context_(std::move(router)) {
-  }
+  void Run(
+      {{interface_macros.declare_responder_params(
+          "in_", method.response_parameters, for_blink)}});
 
-  void Run({{interface_macros.declare_params("in_", method.response_parameters)}}) override;
-
- private:
   uint64_t request_id_;
   bool is_sync_;
   mojo::MessageReceiverWithStatus* responder_;
   // TODO(yzshen): maybe I should use a ref to the original one?
   mojo::internal::SerializationContext serialization_context_;
+
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
+
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
-    {{interface_macros.declare_params("in_", method.response_parameters)}}) {
+    {{interface_macros.declare_responder_params(
+        "in_", method.response_parameters, for_blink)}}) {
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
                                       "&serialization_context_")}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, size, request_id_,
       is_sync_ ? mojo::internal::kMessageIsSync : 0);
   {{build_message(response_params_struct, "in_%s", params_description,
                   "&serialization_context_")}}
   bool ok = responder_->Accept(builder.message());
   ALLOW_UNUSED_LOCAL(ok);
   // TODO(darin): !ok returned here indicates a malformed message, and that may
@@ skipping 53 matching lines @@
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters != None %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       {{alloc_params(method.param_struct, "params", "message",
           "&serialization_context_", "{{class_name}}::{{method.name}}")|
               indent(4)}}
-      {{class_name}}::{{method.name}}Callback::Runnable* runnable =
-          new {{class_name}}_{{method.name}}_ProxyToResponder(
+      {{class_name}}::{{method.name}}Callback callback =
+          {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
               message->has_flag(mojo::internal::kMessageIsSync),
               responder,
               serialization_context_.router);
-      {{class_name}}::{{method.name}}Callback callback(runnable);
       // A null |sink_| means no implementation was bound.
       assert(sink_);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
@@ skipping 91 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}