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

services/http_server/http_server_impl.cc

 // Copyright 2014 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 "services/http_server/http_server_impl.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/services/http_server/cpp/http_server_util.h"
 #include "services/http_server/connection.h"
 #include "services/http_server/http_server_factory_impl.h"
 
 namespace http_server {
 
 HttpServerImpl::HttpServerImpl(mojo::ApplicationImpl* app,
                                HttpServerFactoryImpl* factory,
                                mojo::NetAddressPtr requested_local_address)
     : factory_(factory),
       requested_local_address_(requested_local_address.Pass()),
       assigned_port_(0),
       weak_ptr_factory_(this) {
   app->ConnectToService("mojo:network_service", &network_service_);
   Start();
 }
 
 HttpServerImpl::~HttpServerImpl() {
 }
 
 void HttpServerImpl::AddBinding(mojo::InterfaceRequest<HttpServer> request) {
   bindings_.AddBinding(this, request.Pass());
 }
 
 void HttpServerImpl::SetHandler(const mojo::String& path,
-                                HttpHandlerPtr http_handler,
+                                mojo::InterfaceHandle<HttpHandler> http_handler,
                                 const mojo::Callback<void(bool)>& callback) {
   for (const auto& handler : handlers_) {
     if (handler->pattern->pattern() == path)
       callback.Run(false);
   }
 
-  Handler* handler = new Handler(path, http_handler.Pass());
+  Handler* handler =
+      new Handler(path, HttpHandlerPtr::Create(std::move(http_handler)));

[viettrungluu, 2016/02/11 18:26:29]

Maybe make Handler's ctor take an IH instead? <shrug>

[vardhan, 2016/02/11 22:47:53]

Handler more or less just holds data (if you look at how this http handler is
accessed).  I think it makes sense to convert InterfaceHandle<> to
InterfacePtr<> here.

   handler->http_handler.set_connection_error_handler(
       [this, handler]() { OnHandlerConnectionError(handler); });
   handlers_.push_back(handler);
   callback.Run(true);
 }
 
 void HttpServerImpl::GetPort(const GetPortCallback& callback) {
   if (assigned_port_)
     callback.Run(assigned_port_);
   else
@@ skipping 106 matching lines @@
 
 HttpServerImpl::Handler::Handler(const std::string& pattern,
                                  HttpHandlerPtr http_handler)
     : pattern(new RE2(pattern.c_str())), http_handler(http_handler.Pass()) {
 }
 
 HttpServerImpl::Handler::~Handler() {
 }
 
 }  // namespace http_server