Add support for HTTP handlers that are in self-contained apps. Also add an example app.

services/http_server/http_server.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 <stdio.h>
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <arpa/inet.h>
 #endif
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_runner.h"
+#include "mojo/public/cpp/application/interface_factory.h"
 #include "mojo/public/cpp/environment/async_waiter.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
 #include "services/http_server/http_request_parser.h"
 #include "services/http_server/public/http_request.mojom.h"
 #include "services/http_server/public/http_response.mojom.h"
+#include "services/http_server/public/http_server.mojom.h"
 #include "third_party/re2/re2/re2.h"
 
 namespace mojo {
 namespace examples {
 
 class Connection;
 
-typedef base::Callback<HttpResponsePtr(
-    const HttpRequest& request)> HandleRequestCallback;
+typedef base::Callback<void(HttpRequestPtr, Connection*)> HandleRequestCallback;
 
 const char* GetHttpReasonPhrase(uint32_t code_in) {
   switch (code_in) {
 #define HTTP_STATUS(label, code, reason) case code: return reason;
 #include "net/http/http_status_code_list.h"
 #undef HTTP_STATUS
 
     default:
       NOTREACHED() << "unknown HTTP status code " << code_in;
   }
 
   return "";
 }
 
 // Represents one connection to a client. This connection will manage its own
 // lifetime and will delete itself when the connection is closed.
 class Connection {
  public:
   // Callback called when a request is parsed. Response should be sent
   // using Connection::SendResponse() on the |connection| argument.
-  typedef base::Callback<void(Connection*, const HttpRequest&)> Callback;
+  typedef base::Callback<void(Connection*, HttpRequestPtr)> Callback;
 
   Connection(TCPConnectedSocketPtr conn,
              ScopedDataPipeProducerHandle sender,
              ScopedDataPipeConsumerHandle receiver,
              const Callback& callback)
       : connection_(conn.Pass()),
         sender_(sender.Pass()),
         receiver_(receiver.Pass()),
         request_waiter_(receiver_.get(), MOJO_HANDLE_SIGNAL_READABLE,
                         base::Bind(&Connection::OnRequestDataReady,
@@ skipping 41 matching lines @@
     content_ = response->body.Pass();
     WriteMore();
   }
 
  private:
   // Called when we have more data available from the request.
   void OnRequestDataReady(MojoResult result) {
     uint32_t num_bytes = 0;
     result = ReadDataRaw(receiver_.get(), NULL, &num_bytes,
                          MOJO_READ_DATA_FLAG_QUERY);
-    printf("ReadDataRaw result = %d, num_bytes = %d\n", result, num_bytes);
     if (!num_bytes)
       return;
 
     scoped_ptr<uint8_t[]> buffer(new uint8_t[num_bytes]);
     result = ReadDataRaw(receiver_.get(), buffer.get(), &num_bytes,
                          MOJO_READ_DATA_FLAG_ALL_OR_NONE);
 
     request_parser_.ProcessChunk(reinterpret_cast<char*>(buffer.get()));
     if (request_parser_.ParseRequest() == HttpRequestParser::ACCEPTED) {
-      HttpRequestPtr http_request = request_parser_.GetRequest();
-      handle_request_callback_.Run(this, *http_request.get());
+      handle_request_callback_.Run(this, request_parser_.GetRequest());
     }
   }
 
   void WriteMore() {
     uint32_t response_bytes_available =
         static_cast<uint32_t>(response_.size() - response_offset_);
     if (response_bytes_available) {
       MojoResult result = WriteDataRaw(
           sender_.get(), &response_[response_offset_],
           &response_bytes_available, 0);
@@ skipping 87 matching lines @@
 
   // Callback to run once all of the request has been read.
   const Callback handle_request_callback_;
 
   // Contains response data to write to the pipe. Initially it is the headers,
   // and then when they're written it contains chunks of the body.
   std::string response_;
   size_t response_offset_;
 };
 
-HttpResponsePtr CreateResponse(int code, const std::string& data) {
+HttpResponsePtr CreateResponseHelper(int code, const std::string& data) {
   HttpResponsePtr response = HttpResponse::New();
 
   ScopedDataPipeProducerHandle producer_handle;
   MojoCreateDataPipeOptions options = {sizeof(MojoCreateDataPipeOptions),
                                        MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
                                        1,
                                        data.size()};
   MojoResult result = CreateDataPipe(
       &options, &producer_handle, &response->body);
   DCHECK_EQ(MOJO_RESULT_OK, result);
   uint32_t num_bytes = data.size();
   result = WriteDataRaw(
       producer_handle.get(), data.c_str(), &num_bytes,
       MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
   DCHECK_EQ(MOJO_RESULT_OK, result);
   response->content_length = num_bytes;
   return response.Pass();
 }
 
-HttpResponsePtr FooHandler(const HttpRequest& request) {
-  return CreateResponse(200, "Foo").Pass();
+void FooHandler(HttpRequestPtr request, Connection* connection) {
+  connection->SendResponse(CreateResponseHelper(200, "Foo").Pass());
 }
 
-HttpResponsePtr BarHandler(const HttpRequest& request) {
-  return CreateResponse(200, "Bar").Pass();
+void BarHandler(HttpRequestPtr request, Connection* connection) {
+  connection->SendResponse(CreateResponseHelper(200, "Bar").Pass());
 }
 
-class HttpServerApp : public ApplicationDelegate {
+class HttpServerApp;
+
+class HttpServerServiceImpl : public InterfaceImpl<HttpServerService> {
+ public:
+  HttpServerServiceImpl(ApplicationConnection* connection,
+                        HttpServerApp* app)
+      : app_(app) {}
+  virtual ~HttpServerServiceImpl();
+
+ private:
+  // HttpServerService:
+  void AddHandler(const mojo::String& path,
+                  const mojo::Callback<void(bool)>& callback) override;
+  void RemoveHandler(const mojo::String& path,
+                     const mojo::Callback<void(bool)>& callback) override;
+
+  void CreateResponse(
+      uint32_t status_code,
+      const mojo::String& body,
+      const mojo::Callback<void(mojo::HttpResponsePtr)>& callback) {
+    callback.Run(CreateResponseHelper(status_code, body));
+  }
+
+  void OnRequest(HttpRequestPtr request, Connection* connection) {
+    client()->OnHandleRequest(
+        request.Pass(),
+        base::Bind(&HttpServerServiceImpl::OnResponse, base::Unretained(this),
+                   connection));
+  }
+
+  void OnResponse(Connection* connection, HttpResponsePtr response) {
+    connection->SendResponse(response.Pass());
+  }
+
+  HttpServerApp* app_;
+  std::vector<std::string> paths_;
+};
+
+class HttpServerApp : public ApplicationDelegate,
+                      public InterfaceFactory<HttpServerService> {
  public:
   HttpServerApp() : weak_ptr_factory_(this) {}
   virtual void Initialize(ApplicationImpl* app) override {
     app->ConnectToService("mojo:network_service", &network_service_);
 
     AddHandler("/foo", base::Bind(FooHandler));
     AddHandler("/bar", base::Bind(BarHandler));
 
     Start();
   }
 
   // Add a handler for the given regex path.
-  void AddHandler(const std::string& path,
+  bool AddHandler(const std::string& path,
                   const HandleRequestCallback& handler) {
+    for (auto& handler : handlers_) {
+      if (handler.pattern->pattern() == path)
+        return false;
+    }
+
     handlers_.push_back(Handler(path, handler));
+    return true;
+  }
+
+  bool RemoveHandler(const std::string& path) {
+    for (size_t i = 0; i < handlers_.size(); ++i) {

[yzshen1, 2014/11/12 17:38:33]

nit: using iterator here might be a little more cleaner.

[jam, 2014/11/12 20:48:40]

Done.

+      if (handlers_[i].pattern->pattern() == path) {
+        handlers_.erase(handlers_.begin() + i);
+        return true;
+      }
+    }
+
+    return false;
   }
 
  private:
+  // ApplicationDelegate:
+  bool ConfigureIncomingConnection(
+      ApplicationConnection* connection) override {
+    connection->AddService(this);
+    return true;
+  }
+
+  // InterfaceFactory<HttpServerService>:
+  void Create(ApplicationConnection* connection,
+              InterfaceRequest<HttpServerService> request) override {
+    mojo::BindToRequest(new HttpServerServiceImpl(connection, this), &request);
+  }
+
   void OnSocketBound(NetworkErrorPtr err, NetAddressPtr bound_address) {
     if (err->code != 0) {
       printf("Bound err = %d\n", err->code);
       return;
     }
 
     printf("Got address %d.%d.%d.%d:%d\n",
            (int)bound_address->ipv4->addr[0],
            (int)bound_address->ipv4->addr[1],
            (int)bound_address->ipv4->addr[2],
@@ skipping 47 matching lines @@
 
   void Start() {
     NetAddressPtr net_address(NetAddress::New());
     net_address->family = NET_ADDRESS_FAMILY_IPV4;
     net_address->ipv4 = NetAddressIPv4::New();
     net_address->ipv4->addr.resize(4);
     net_address->ipv4->addr[0] = 127;
     net_address->ipv4->addr[1] = 0;
     net_address->ipv4->addr[2] = 0;
     net_address->ipv4->addr[3] = 1;
-    net_address->ipv4->port = 0;
+    net_address->ipv4->port = 80;

[yzshen1, 2014/11/12 17:38:33]

This requires that there is nothing occupying that port currently. Are you
planning to make it configurable later?

[jam, 2014/11/12 20:48:40]

I think right now it's easier if it's 80 so that when we push this to servers it
runs on a predetermined port. if we need it to be configurable later, we can add
that easily.

 
     // Note that we can start using the proxies right away even thought the
     // callbacks have not been called yet. If a previous step fails, they'll
     // all fail.
     network_service_->CreateTCPBoundSocket(
         net_address.Pass(),
         GetProxy(&bound_socket_),
         base::Bind(&HttpServerApp::OnSocketBound, base::Unretained(this)));
     bound_socket_->StartListening(GetProxy(
         &server_socket_),
         base::Bind(&HttpServerApp::OnSocketListening, base::Unretained(this)));
     WaitForNextConnection();
   }
 
-  void HandleRequest(Connection* connection, const HttpRequest& request) {
-    printf("HandleRequest for %s\n", request.relative_url.data());
+  void HandleRequest(Connection* connection, HttpRequestPtr request) {
     for (auto& handler : handlers_) {
-      if (RE2::FullMatch(request.relative_url.data(), *handler.pattern)) {
-        connection->SendResponse(handler.callback.Run(request).Pass());
+      if (RE2::FullMatch(request->relative_url.data(), *handler.pattern)) {
+        handler.callback.Run(request.Pass(), connection);
         return;
       }
     }
 
     connection->SendResponse(
-        CreateResponse(404, "No registered handler").Pass());
+        CreateResponseHelper(404, "No registered handler").Pass());
   }
 
   struct Handler {
     Handler(const std::string& pattern,
             const HandleRequestCallback& callback)
         : pattern(new RE2(pattern.c_str())), callback(callback) {}
     Handler(const Handler& handler)
         : pattern(new RE2(handler.pattern->pattern())),
           callback(handler.callback) {}
     Handler& operator=(const Handler& handler) {
@@ skipping 13 matching lines @@
   TCPBoundSocketPtr bound_socket_;
   TCPServerSocketPtr server_socket_;
 
   ScopedDataPipeProducerHandle pending_send_handle_;
   ScopedDataPipeConsumerHandle pending_receive_handle_;
   TCPConnectedSocketPtr pending_connected_socket_;
 
   std::vector<Handler> handlers_;
 };
 
+HttpServerServiceImpl::~HttpServerServiceImpl() {
+  for (auto& path : paths_)
+    app_->RemoveHandler(path);
+}
+
+void HttpServerServiceImpl::AddHandler(
+    const mojo::String& path,
+    const mojo::Callback<void(bool)>& callback) {
+  bool rv = app_->AddHandler(path,
+                             base::Bind(&HttpServerServiceImpl::OnRequest,
+                                        base::Unretained(this)));
+  callback.Run(rv);
+  if (rv)
+    paths_.push_back(path);
+}
+
+void HttpServerServiceImpl::RemoveHandler(
+    const mojo::String& path,
+    const mojo::Callback<void(bool)>& callback) {
+  bool rv = app_->RemoveHandler(path);
+  callback.Run(rv);
+  for (size_t i = 0; i < paths_.size(); ++i) {
+    if (paths_[i] == path) {
+      paths_.erase(paths_.begin() + i);
+      break;
+    }
+  }
+}
+
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunner runner(new mojo::examples::HttpServerApp);
   return runner.Run(shell_handle);
 }