Initial Chrome DevTools Protocol implementation

This builds on devtools-html/cdp and devtools-html/tokio-cdp to implement a
simple Chrome DevTools Protocol server into Servo. The top-level browsing
context is exposed as the single "tab" supported (and thus creating new tabs and
switching between active tabs is not supported). One command is implemented so
far, Page.navigate, to navigate the tab to a particular URL.

Similar to the Firefox DevTools Server, the Chrome DevTools Server can be
started by passing the --cdp flag to Servo. The default port is 9222; a
different one can be specified by passing a port to the flag.

components/cdp/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "servo_cdp"
+version = "0.0.1"
+authors = ["The Servo Project Developers"]
+license = "MPL-2.0"
+publish = false
+
+[lib]
+name = "servo_cdp"
+path = "lib.rs"
+
+[dependencies]
+bincode = "0.8"
+futures = "0.1"
+ipc-channel = "0.8"
+log = "0.3"
+msg = {path = "../msg"}
+script_traits = {path = "../script_traits"}
+serde = "1.0"
+serde_json = "1.0"
+servo_config = {path = "../config"}
+servo_url = {path = "../url"}
+tokio-core = "0.1"
+tokio-service = "0.1"
+
+[dependencies.cdp]
+git = "https://github.com/devtools-html/cdp"
+rev = "0b3a0ba2a71b36324a8f465cc47eaaa2762b8d59"
+
+[dependencies.tokio-cdp]
+git = "https://github.com/devtools-html/tokio-cdp"
+rev = "c23b7a36986c2f3ae7aaf947a9475618395b7758"

components/cdp/ipc.rs

@@ -0,0 +1,100 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use bincode;
+use futures::{Async, Future};
+use futures::future::{self, Either};
+use ipc_channel::ipc::{self, IpcReceiver};
+use msg::constellation_msg::{BrowsingContextId, TopLevelBrowsingContextId};
+use script_traits::{ConstellationMsg, LoadData, WebDriverCommandMsg};
+use script_traits::webdriver_msg::{LoadStatus, WebDriverScriptCommand};
+use serde::{Deserialize, Serialize};
+use servo_url::ServoUrl;
+use std::io;
+use std::sync::mpsc::Sender;
+
+pub fn focus_top_level_browsing_context_id(
+    constellation_chan: &Sender<ConstellationMsg>,
+) -> io::Result<IpcReceiver<Option<TopLevelBrowsingContextId>>> {
+    let (sender, receiver) = ipc::channel()?;
+    let msg = ConstellationMsg::GetFocusTopLevelBrowsingContext(sender);
+    send(constellation_chan, msg).map(|_| receiver)
+}
+
+pub fn get_page_title(
+    constellation_chan: &Sender<ConstellationMsg>,
+    browsing_context_id: BrowsingContextId,
+) -> io::Result<IpcReceiver<String>> {
+    let (sender, receiver) = ipc::channel()?;
+    let msg = WebDriverScriptCommand::GetTitle(sender);
+    send_webdriver_script_cmd(constellation_chan, browsing_context_id, msg).map(|_| receiver)
+}
+
+pub fn get_page_url(
+    constellation_chan: &Sender<ConstellationMsg>,
+    browsing_context_id: BrowsingContextId,
+) -> io::Result<IpcReceiver<ServoUrl>> {
+    let (sender, receiver) = ipc::channel()?;
+    let msg = WebDriverScriptCommand::GetUrl(sender);
+    send_webdriver_script_cmd(constellation_chan, browsing_context_id, msg).map(|_| receiver)
+}
+
+pub fn load_url(
+    constellation_chan: &Sender<ConstellationMsg>,
+    top_level_browsing_context_id: TopLevelBrowsingContextId,
+    load_data: LoadData,
+) -> io::Result<IpcReceiver<LoadStatus>> {
+    let (sender, receiver) = ipc::channel()?;
+    let msg = WebDriverCommandMsg::LoadUrl(top_level_browsing_context_id, load_data, sender);
+    send_webdriver_cmd(constellation_chan, msg).map(|_| receiver)
+}
+
+fn send_webdriver_script_cmd(
+    constellation_chan: &Sender<ConstellationMsg>,
+    browsing_context_id: BrowsingContextId,
+    msg: WebDriverScriptCommand,
+) -> io::Result<()> {
+    send_webdriver_cmd(
+        constellation_chan,
+        WebDriverCommandMsg::ScriptCommand(browsing_context_id, msg),
+    )
+}
+
+fn send_webdriver_cmd(
+    constellation_chan: &Sender<ConstellationMsg>,
+    msg: WebDriverCommandMsg,
+) -> io::Result<()> {
+    send(constellation_chan, ConstellationMsg::WebDriverCommand(msg))
+}
+
+fn send<T>(sender: &Sender<T>, msg: T) -> io::Result<()> {
+    sender.send(msg).map_err(|_| io::Error::new(io::ErrorKind::ConnectionReset, "channel closed"))
+}
+
+pub fn receive_ipc<T>(receiver: IpcReceiver<T>) -> impl Future<Item = T, Error = io::Error>
+where
+    for<'de> T: Serialize + Deserialize<'de>,
+{
+    future::poll_fn(move || match receiver.recv() {
+        Ok(msg) => Ok(msg.into()),
+        Err(err) => match *err {
+            bincode::ErrorKind::IoError(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                Ok(Async::NotReady)
+            }
+            _ => Err(io::Error::new(io::ErrorKind::Other, err)),
+        },
+    })
+}
+
+pub fn wrap_receive_ipc<T>(
+    result: io::Result<IpcReceiver<T>>,
+) -> impl Future<Item = T, Error = io::Error>
+where
+    for<'de> T: Serialize + Deserialize<'de>,
+{
+    match result {
+        Err(err) => Either::A(future::err(err)),
+        Ok(receiver) => Either::B(receive_ipc(receiver)),
+    }
+}