Build libwebserv protocol handler proxy and stub out request handler

Change-Id: Ibfbca0ac631e76414f475f7f7eb5564a298ab198
Test: Build continues to succeed in Binder mode
Bug: 27204884

libwebserv/binder_server.cc

diff --git a/libwebserv/binder_server.cc b/libwebserv/binder_server.cc
index ced4ba8..4ac8636 100644
--- a/libwebserv/binder_server.cc
+++ b/libwebserv/binder_server.cc
@@ -12,22 +12,191 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "libwebserv/binder_server.h"
-
 #include "webserv_common/binder_constants.h"
-#include "libwebserv/protocol_handler.h"
 
+#include "libwebserv/binder_server.h"
+#include "libwebserv/protocol_handler.h"
+#include "libwebserv/request_handler_callback.h"
+
+#include "android/webservd/BnRequestHandler.h"
+
+#include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 using android::sp;
 using android::IBinder;
 using android::binder::Status;
+using android::webservd::IHttpRequest;
+using android::webservd::IProtocolHandler;
+using android::webservd::IRequestHandler;
+using std::map;
+using std::pair;
+using std::set;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 namespace libwebserv {
 
+class BinderRequestHandler : public android::webservd::BnRequestHandler {
+ public:
+  explicit BinderRequestHandler(unique_ptr<RequestHandlerInterface> handler)
+      : handler_(std::move(handler)) {}
+
+  Status ProcessRequest(const sp<IHttpRequest>& request) override {
+    (void)request;
+    return Status::ok();
+  }
+
+ private:
+  unique_ptr<RequestHandlerInterface> handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(BinderRequestHandler);
+};
+
+class BinderProtocolHandler : public ProtocolHandler {
+ public:
+  explicit BinderProtocolHandler(const string& name)
+      : name_(name) {}
+
+  virtual ~BinderProtocolHandler() {
+    ResetRemoteProtocolHandlers();
+  }
+
+  bool AddRemote(sp<IProtocolHandler> handler) {
+    string name;
+    int32_t port;
+    string protocol;
+
+    if (!handler->GetName(&name).isOk()) {
+      LOG(INFO) << "Could not get name of remote protocol handler.";
+      return false;
+    }
+
+    CHECK(name == name_);
+
+    if (!handler->GetPort(&port).isOk()) {
+      LOG(INFO) << "Could not get port for remote protocol handler.";
+      return false;
+    }
+
+    if (!handler->GetProtocol(&protocol).isOk()) {
+      LOG(INFO) << "Could not get protocol for remote protocol handler.";
+      return false;
+    }
+
+    ports_.insert(uint16_t(port));
+    protocols_.insert(protocol);
+    remote_handlers_.push_back(handler);
+
+    return true;
+  }
+
+  int AddHandler(const string& url,
+                 const string& method,
+                 unique_ptr<RequestHandlerInterface> handler) override {
+    sp<IRequestHandler> binder_handler(
+      new BinderRequestHandler(std::move(handler)));
+    set<pair<sp<IProtocolHandler>, string>> guids;
+
+    // Add this local request handler to each remote protocol handler
+    // associated with this local protocol handler.
+    for (sp<IProtocolHandler> handler : remote_handlers_) {
+      string guid;
+
+      if (!handler->AddRequestHandler(url,
+                                      method,
+                                      binder_handler,
+                                      &guid).isOk()) {
+        LOG(WARNING) << "Remote protocol handler failed to "
+                     << "register new request handler.";
+      } else {
+        guids.emplace(handler, guid);
+      }
+    }
+
+    int id = last_handler_id_++;
+    handler_ids_.emplace(id, guids);
+    return id;
+  }
+
+  int AddHandlerCallback(
+      const string& url,
+      const string& method,
+      const base::Callback<RequestHandlerInterface::HandlerSignature>&
+          handler_callback) override {
+    std::unique_ptr<RequestHandlerInterface> handler{
+        new RequestHandlerCallback{handler_callback}};
+    return AddHandler(url, method, std::move(handler));
+  }
+
+  bool RemoveHandler(int handler_id) override {
+    auto it = handler_ids_.find(handler_id);
+
+    if (it == handler_ids_.end()) {
+      return false;
+    }
+
+    for (const pair<sp<IProtocolHandler>,string>& remote : it->second) {
+      if (!remote.first->RemoveRequestHandler(remote.second).isOk()) {
+        LOG(WARNING) << "Could not remove request handler from remote.";
+      }
+    }
+
+    return true;
+  }
+
+  void ResetRemoteProtocolHandlers() {
+    for (auto it : handler_ids_) {
+      for (auto remote : it.second) {
+        if (!remote.first->RemoveRequestHandler(remote.second).isOk()) {
+          LOG(INFO) << "Could not remove request handler from remote.";
+        }
+      }
+    }
+
+    handler_ids_.clear();
+    remote_handlers_.clear();
+  }
+
+  bool IsConnected() const override { return !remote_handlers_.empty(); }
+  string GetName() const override { return name_; }
+  set<uint16_t> GetPorts() const override { return ports_; }
+  set<string> GetProtocols() const override { return protocols_; }
+
+  brillo::Blob GetCertificateFingerprint() const override {
+    brillo::Blob result;
+
+    for (auto& handler : remote_handlers_) {
+      Status status = handler->GetCertificateFingerprint(&result);
+      if (!status.isOk()) {
+        LOG(WARNING) << "Could not get certificate fingerprint "
+                     << "from protocol handler: " << status;
+      } else if (!result.empty()) {
+        break;
+      }
+    }
+
+    return result;
+  }
+
+ private:
+  int last_handler_id_ = 0;
+  set<uint16_t> ports_;
+  set<string> protocols_;
+  string name_;
+  vector<sp<IProtocolHandler>> remote_handlers_;
+
+  // Map of handler ID numbers as returned by AddHandler to pairs of
+  // IProtocolHandler pointers and string handler GUIDs as returned by the
+  // daemon.
+  map<int,set<pair<sp<IProtocolHandler>,string>>> handler_ids_;
+
+  DISALLOW_COPY_AND_ASSIGN(BinderProtocolHandler);
+};
+
 BinderServer::BinderServer(brillo::MessageLoop* message_loop,
                            const base::Closure& on_server_online,
                            const base::Closure& on_server_offline,
@@ -59,14 +228,10 @@
                                  base::TimeDelta::FromSeconds(1));
 }
 
-
 void BinderServer::ClearLocalState() {
-  // Remove all references to remote protocol handlers from our local wrappers.
-
-  // TODO(wiley) Define this method
-  //for (auto& local_handler: local_protocol_handlers_) {
-  //  local_handler.second->ResetRemoteProtocolHandlers();
-  //}
+  for (auto& local_handler: local_protocol_handlers_) {
+    local_handler.second->ResetRemoteProtocolHandlers();
+  }
 
   remote_server_.clear();
 }
@@ -90,11 +255,17 @@
       LOG(INFO) << "Remote handler could not report its name.";
       return false;
     }
-    // TODO(wiley) Look for a BinderPHGroup by that name in local_handlers_
-    //             Create a new BinderPHGroup if necessary
-    //             Add it to the map under |name|
-    //             Update |it| appropriately
-    //             Tell |it| about |remote_handler|
+
+    auto it = local_protocol_handlers_.find(name);
+
+    if (it == local_protocol_handlers_.end()) {
+      unique_ptr<BinderProtocolHandler> local_handler(
+          new BinderProtocolHandler(name));
+      local_protocol_handlers_[name] = std::move(local_handler);
+      it = local_protocol_handlers_.find(name);
+    }
+
+    it->second->AddRemote(remote_handler);
   }
   return true;
 }
@@ -107,10 +278,14 @@
   return GetProtocolHandler(ProtocolHandler::kHttps);
 }
 
-ProtocolHandler* BinderServer::GetProtocolHandler(const string& /*name*/) {
-  // TODO(sadmac) Once BuildLocalState populates the map of protocol handlers,
-  //              use it to return a result here.
-  return nullptr;
+ProtocolHandler* BinderServer::GetProtocolHandler(const string& name) {
+  auto it = local_protocol_handlers_.find(name);
+
+  if (it == local_protocol_handlers_.end()) {
+    return nullptr;
+  }
+
+  return it->second.get();
 }
 
 bool BinderServer::IsConnected() const {