├── JS_API.md
├── README.md
├── examples
    ├── README.txt
    ├── browsers.rs
    └── compositor.rs
└── servo_traits
    ├── browser
        ├── browser.rs
        ├── content_blocker.rs
        ├── content_description.rs
        ├── document.rs
        ├── editable.rs
        ├── findable.rs
        ├── http_observer.rs
        ├── load_data.rs
        ├── multimedia.rs
        ├── printable.rs
        ├── security.rs
        └── session.rs
    └── compositor
        ├── browserview.rs
        └── compositor.rs


/JS_API.md:
--------------------------------------------------------------------------------
  1 | # Building a Servo-based browser in HTML and JavaScript
  2 | 
  3 | The current Browser API "pollutes" Servo's code base, bends standards (`<iframe mozbrowser>`) and security policies (cross-domain XHR).
  4 | 
  5 | We want the JS API to be as self contained as possible. It doesn't have to live within Servo's code base.
  6 | 
  7 | We like the Electron approach where a webpage embeds a webpage, with a JS runtime as a bridge between the embedder and the OS.
  8 | 
  9 | The idea is to make Servo embed itself.
 10 | 
 11 | Here is a possible approach
 12 | 
 13 | ---
 14 | 
 15 | A JS app is made out of 4 files:
 16 | - app.js
 17 | - window.html
 18 | - window.js
 19 | - compositor.js
 20 | 
 21 | ___
 22 | 
 23 | *app.js* is run via a [JS runtime](https://github.com/servo/servo/issues/7379).
 24 | An event loop + Spidermonkey + bindings.
 25 | Here we're not talking about Servo's JS runtime. Just Spidermonkey by itself.
 26 | 
 27 | On launch: `var browser1 = NewNativeWindow("./window.html")`
 28 | 
 29 | Behind `NewNativeWindow`, Rust code:
 30 | - create a native window (let's say a glutin window)
 31 | - load libservo
 32 | - create a Servo's [Compositor](servo_traits/compositor/compositor.rs) out of the window (wrapped as a [Drawable](servo_traits/compositor/compositor.rs))
 33 | - create a full-window [BrowserView](servo_traits/compositor/browserview.rs)
 34 | - create and attach a [Browser](servo_traits/browser/browser.rs) to the BrowserView, load `window.html`, with a special module resolver (see below)
 35 | - a JS binding translates the Rust Browser into a JS Browser object (`browser1`)
 36 | 
 37 | At this point, *window.html* is rendered full window in the native window.
 38 | 
 39 | We want that web page to be able to create other windows within that window (like `<iframes>`, but we want to use `<embed>`).
 40 | 
 41 | To do so, we need to be able to create a Browser and a BrowserView in JavaScript.
 42 | 
 43 | ### Browser:
 44 | 
 45 | To expose JS bindings to *window.js*, when the window.html' browser is created in `NewNativeWindow`, a module resolver is registered via `Browser::register_js_module_resolver`
 46 | 
 47 | The binding will then be accessible from via a JS module:
 48 | 
 49 | `import {Browser} from "Servo";`
 50 | 
 51 | **This is how we give special privilege to a Browser**.
 52 | 
 53 | At this point, the JS code (`<script>` within `browser1`) can create a new browser (a tab):
 54 | `var browser2 = new Browser()`.
 55 | This first tab is the second Browser created.
 56 | Let's create a second tab: `var browser3 = new Browser()`.
 57 | 
 58 | At this point, 3 browsers are accessible:
 59 | - browser1, in app.js, run in the JS runtime. It's the top level browser.
 60 | - browser2 and browser3, in window.js, run in Servo JS runtime. Two tabs.
 61 | 
 62 | *Note: at no point in the Servo API we mention hierarchy. The fact that browser2 and browser3
 63 | are "inside" browser1 has no implication.*
 64 | 
 65 | ### BrowserView:
 66 | 
 67 | This is not enough, as these new tabs would be headless. A BrowserView per Browser is necessary.
 68 | `browser1` already has a browserview, created in Rust in `NewNativeWindow`.
 69 | 
 70 | We want the geometry of the browserview to be part of the layout of the page.
 71 | To do so, Servo would use the `<embed>` tag as a browserview, to draw a Browser.
 72 | The layout thread of the top level Browser would update the actual BrowserView
 73 | coordinates and size.
 74 | 
 75 | The browser could be initialized that way:
 76 | 
 77 | `var browser2 = new Browser(embed_element)`
 78 | 
 79 | The BrowserView methods are not accessible from browser1 script thread.
 80 | Same for the Compositor methods.
 81 | 
 82 | ```
 83 | import {CompositorWorker} from "Servo";
 84 | var cw = new CompositorWorker('compositor.js')
 85 | ```
 86 | 
 87 | CompositorWorker is a [SharedWorker](https://html.spec.whatwg.org/multipage/workers.html#sharedworker)
 88 | run in Servo's Compositor thread, where Compositor's methods are accessible.
 89 | 
 90 | Browser JS code and Compositor JS code can communicate via message passing.
 91 | 
 92 | Each port of the SharedWorker is a browserview (3 here).
 93 | 
 94 | That means all browsers in a window share the same compositor.
 95 | 
 96 | # Life of an event
 97 | 
 98 | The native window would get a new event, which would be sent as a message to the compositor
 99 | worker. It's then up to the JS code in compositor.js to route the event to the proper browser.
100 | If it's a mouse event, `Compositor.get_browserviews_from_point` will return the browserview to target.
101 | If it's a keyboard event, the relevant browserview is the one that is attached to the focused browser.
102 | The event is sent to the browser attached to the browserview, and eventually sent back to the
103 | compositor.
104 | 
105 | ___
106 | 
107 | *Note: It is important to make `browser/` code and `compositor/` code live in different threads.
108 | We assumed `browser/` lives in the script thread of the host page, and `compositor/` in a worker,
109 | but we could also have both in workers.*
110 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | **This is a non-normative and non-functional Rust API proposal for Servo. Only used to illustrate and outline a possible Servo embedding API.**
  2 | 
  3 | It's built from the perspective of an embedder. It takes into consideration future work that will be required to build a full browser (multi window, session restore, web extensions, permissions, …). It delegates as much as possible to the embedder.
  4 | 
  5 | This API is in Rust. We don't want to expose a JS API directly from Servo.
  6 | 
  7 | See usage [examples here](https://github.com/paulrouget/servo-embedding-api/issues/2).
  8 | 
  9 | To understand how that fit in the BrowserHTML story, see the [JS_API.md](JS_API.md) document.
 10 | 
 11 | The API is split in two: [`/compositor/`](servo_traits/compositor)
 12 | and [`/browser/`](servo_traits/browser).
 13 | One code lives in the Compositor thread, the other in the Constellation thread.
 14 | 
 15 | 
 16 | 
 17 | # API Overview
 18 | 
 19 | The embedder provides a [`Drawable`](servo_traits/compositor/compositor.rs) object, which gives access to the GL context.
 20 | 
 21 | A [`Compositor`](servo_traits/compositor/compositor.rs) object is built from [`Drawable`](servo_traits/compositor/compositor.rs).
 22 | 
 23 | One [`Compositor+Drawable`](servo_traits/compositor/compositor.rs) per native window.
 24 | 
 25 | A [`Compositor`](servo_traits/compositor/compositor.rs) holds a list of [`BrowserView`](servo_traits/compositor/browserview.rs).
 26 | 
 27 | A [`BrowserView`](servo_traits/compositor/browserview.rs) is linked to one or several [`Browser`](servo_traits/browser/browser.rs).
 28 | 
 29 | A [`BrowserView`](servo_traits/compositor/browserview.rs) is where a web page is painted.
 30 | 
 31 | A [`DocumentView`](servo_traits/compositor/compositor.rs) is a special type of [`BrowserView`](servo_traits/compositor/browserview.rs) that can mirror a document from another Browser. Its dimensions don't affect the page layout.
 32 | 
 33 | All [`BrowserView`](servo_traits/compositor/browserview.rs) and [`DocumentView`](servo_traits/compositor/compositor.rs) have a coordinate (glViewport), a size, a z-index, an opacity and a background color. All these properties can be changed and animated.
 34 | 
 35 | All [`BrowserView`](servo_traits/compositor/browserview.rs) and [`DocumentView`](servo_traits/compositor/compositor.rs) are rendered and clipped by the [`Compositor`](servo_traits/compositor/compositor.rs).
 36 | 
 37 | A [`Browser`](servo_traits/browser/browser.rs) (Servo's Frame) is the equivalent of a tab.
 38 | 
 39 | A [`Browser`](servo_traits/browser/browser.rs) is attached to one [`BrowserView`](servo_traits/compositor/compositor.rs).
 40 | 
 41 | A [`Browser`](servo_traits/browser/browser.rs) offers access to methods and properties to manipulate the history and the web page.
 42 | 
 43 | A [`Session`](servo_traits/browser/session.rs) has multiple [`Browser`](servo_traits/browser/browser.rs) which have multiple [`Document`](servo_traits/browser/document.rs).
 44 | 
 45 | A [`Browser`](servo_traits/browser/browser.rs) is associated to one [`Session`](servo_traits/browser/session.rs), that controls offline data of a set of documents. Usually, a web browser would only use 2 sessions: a regular one, and a private one.
 46 | 
 47 | A [`BrowserHandler`](servo_traits/browser/browser.rs) reports all the activity of a browser (history changes, navigation, …).
 48 | 
 49 | A [`Document`](servo_traits/browser/document.rs) gives access to document properties and methods.
 50 | 
 51 | A [`DocumentHandler`](servo_traits/browser/document.rs) reports all the activity of a document (load state, url changes, title changes, …).
 52 | 
 53 | [`LoadData`](servo_traits/browser/load_data.rs) is a structure that holds all the information needed to load or restore a page.
 54 | 
 55 | # Life of an event
 56 | 
 57 | The embedder gets an event from the native window.
 58 | 
 59 | The relevant compositor is the one associated to the native window.
 60 | 
 61 | If it's a keyboard event, the relevant Browser is the focused Browser, which is
 62 | known by the embedder.
 63 | 
 64 | If it's a mouse/touch/pointer event, [Compositor's `get_browserviews_from_point()`](servo_traits/compositor/compositor.rs)
 65 | method will return all the browserviews under the mouse.  (up to the embedder to
 66 | pick the highest browserview or not).
 67 | 
 68 | [Browser's `handle_event`](servo_traits/browser/browser.rs) method is used to forward the event to the Browser.
 69 | Servo will pick the relevant Document.  A Future is returned. Once the Future
 70 | is resolved, the event has been through the page. The returned boolean will
 71 | tell the embedder if the event has been consumed by the content (scroll
 72 | actually happened, key event has been typed, preventDefault() has been called,
 73 | …).
 74 | 
 75 | This gives the embedder 2 chances to respond to the event: once received from
 76 | the native window, and after it's been through the content.
 77 | 
 78 | # Rational
 79 | 
 80 | A web browser is made of 3 components: the web engine, the frontend, and the runtime (OS integration). The work we are doing on the API is not about the runtime code (see [#7379](https://github.com/servo/servo/issues/7379) for runtime related work). The web engine is embedded. The web browser application is the embeddee. The proposed API is designed to make embedding Servo possible.
 81 | 
 82 | After experimenting with other APIs and web engines, we found three main problems that we want to address:
 83 | - Web standards get mixed up and polluted by non-web components (think Browser API & iframes),
 84 | - too much abstractions: implementing anything that goes beyond the usual “tabs and history” paradigm is nearly impossible with any existing APIs, as they are designed with the assumption all browsers will be built the same way
 85 | - no control over the compositor: we want to move pages around with gestures, bounce them,  scale them… but the current mechanisms jail pages in a rectangle
 86 | 
 87 | ## Recommendations
 88 | 
 89 | ### Servo should stay clean and safe contained, and delegate as much as possible
 90 | 
 91 | Servo should be only about rendering the web. Servo should worry as little as possible about OS-level problems. These should be handled in a "runtime", which is an orthogonal project.
 92 | Servo should not have to worry about non-web related permission management.
 93 | Servo should limit as much as possible non-standard behavior. The current Browser API "pollutes" Servo's code base, bends standards (`<iframe mozbrowser>`) and security policies (cross-domain XHR).
 94 | 
 95 | 
 96 | Disk IO should be delegated to the embedder where possible (session restore for example should be built at the embedder level).
 97 | 
 98 | ### Rust only
 99 | 
100 | Servo must stay a library. The exposed API should be a Rust API. It should be possible to build a JS wrapper around that library as a third-party project, same for other languages (C++ bindings, Java bindings, …). **Maybe the next-gen browser won’t be in JS, but in Rust. Let’s not limit the embedder options**.
101 | 
102 | ### Low-level & Granularity
103 | 
104 | Servo should not expose a "Browser API", and "Web Extension API", and a "Webdriver API", but a low-level-enough API that can be used to build any of these, in any language.
105 | 
106 | 
107 | The API should be powerful enough to build a full browser, on mobile and on desktop. The API should be close to the current Servo architecture, and make few assumptions about what the embedder needs. **Abstraction limits future experiment and requires more work on top of Servo. It's "libservo", not "libbrowser"**.
108 | 
109 | ### Open up the compositor/webrender
110 | 
111 | Most of the known embedding APIs “jail” content into a rectangle with little control over how the page is displayed. The Servo API should not just be about controlling browsing, but also compositing/rendering.
112 | 
113 | 
114 | Usually, size of the content is the size of its frame (frame clips the page at its boundaries), events are directly sent to the page, and only the active page is rendered.
115 | We want to have a better control over which events go to the page. We don't want Cmd-W to go though the page. We want Cmd-R to go through the page but know if the content even called preventDefault=true
116 | We want to render non active web page (page from the history), like the swipe-to-go-back feature in Safari (problem with Webkit: this is a builtin feature of the engine, it is not a feature the embedder has access to)
117 | We want to be able to be able to change the UI on scroll, in the compositor. This kind of animation for example: https://youtu.be/Tf6PtZ1Z2eE / https://youtu.be/EhrkAKo4p5g
118 | 
119 | 
120 | ## Links
121 | 
122 | - [Chromium Embedded Framework](https://bitbucket.org/chromiumembedded/cef/wiki/GeneralUsage)
123 | - [Mozilla Browser API](https://developer.mozilla.org/en-US/docs/Mozilla/Gecko/Chrome/API/Browser_API)
124 | - [Electron's webview](http://electron.atom.io/docs/api/web-contents/)
125 | - [Android's webview](https://developer.android.com/reference/android/webkit/WebView.html)
126 | - [iOS's WKWebview](https://developer.apple.com/reference/webkit/wkwebview)
127 | 
128 | 
129 | ## First steps
130 | 
131 | The API described here is large, but there's a minimal set of tasks that we can start with:
132 | - We need to fix the top-level browsing context in Servo. We need the ability to have separate top-level browsing contexts. Either kill the root frame, or have multiple constellations.
133 | - Implement "LoadData". It's an "offline" version of a pipeline and contains all the data required to restore a pipeline that has been killed (e.g. through app shut down, or because the pipeline has been purged because it's distant history, or the tab has been closed and we want to restore it). It is also used to open new links in tabs and windows. Basically, improve the "HistoryEntry" struct introduced in #11893
134 | - Implement the "Browser" interface (no need to implement the Document API at this stage)
135 | - figure out how to create and initialise Browser and Compositor (right threads)
136 | - remove `fn main()` from components/servo, make ports/ the entry point, and move event routing to ports/ (maybe use libui-rs)
137 | - build, in a separate repo, a JS binding for this API
138 | - implement BrowserView and makes `<embed>` implement this interface (without `View::set_frame()`)
139 | - implement a JS library that wrap the Servo API into the Browser API
140 | - Now, at this point, we can create a Rust project, that embeds Servo, create a Browser, inject the JS binding to the Browser instance (giving it special privileges), make Servo create a browserview, and we end up with Servo being the embedder and the embeddee
141 | - **get rid of all the mozbrowser code in Servo**
142 | 


--------------------------------------------------------------------------------
/examples/README.txt:
--------------------------------------------------------------------------------
1 | This is pseudo code. To illustrate the WIP Rust API.
2 | 
3 | See https://github.com/paulrouget/servo-embedding-api/issues/2 for context.
4 | 


--------------------------------------------------------------------------------
/examples/browsers.rs:
--------------------------------------------------------------------------------
  1 | struct ProgressbarStatus {
  2 |     Connecting,
  3 |     Connected,
  4 |     Loaded,
  5 | }
  6 | 
  7 | struct MySession {
  8 |     session: Session,
  9 |     windows: Vec<MyWindow>,
 10 |     browsers: Vec<Browser>,
 11 |     app_sender: IpcSender<AppMsg>,
 12 | }
 13 | 
 14 | struct ClosedTab {
 15 |     entries: Vec<LoadData>,
 16 |     current: u32,
 17 | }
 18 | 
 19 | struct MyWindow {
 20 |     compositor_sender: IpcSender<CompositorMsg>,
 21 |     browsers: Vec<BrowserID>,
 22 |     fg_browser_index: u32,
 23 |     closed_tabs: Vec<ClosedTab>,
 24 | }
 25 | 
 26 | struct BrowserHelper { }
 27 | impl BrowserHelper {
 28 |     fn can_go_back(browser) {
 29 |         let i = browser.get_current_entry_index();
 30 |         i.is_some() && i != Some(0)
 31 |     },
 32 |     fn can_go_fwd(browser) {
 33 |         let i = browser.get_current_entry_index();
 34 |         let max = browser.get_entry_count() - 1;
 35 |         i.is_some() && i != Some(max)
 36 |     }
 37 |     fn go_back(browser) {
 38 |         if BrowserHelper::can_go_back(browser) {
 39 |             let i = browser.get_current_entry_index().unwrap();
 40 |             browser.set_current_entry_index(i - 1);
 41 |         }
 42 |     }
 43 |     fn go_fwd(browser) {
 44 |         if BrowserHelper::can_go_fwd(browser) {
 45 |             let i = browser.get_current_entry_index().unwrap();
 46 |             browser.set_current_entry_index(i + 1);
 47 |         }
 48 |     }
 49 |     fn get_current_document(browser) {
 50 |         browser.get_current_entry()
 51 |                .map(|e| e.document_id)
 52 |                .map(|id| browser.get_document(id))
 53 |     }
 54 |     fn create_new_view_and_browser(session, compositor) {
 55 |         let (sender, receiver) = ipc::channel().unwrap();
 56 |         let msg = CompositorMsg::CreateBrowserView(sender);
 57 |         compositor.send(msg);
 58 |         let browserview_id = receiver.recv().unwrap();
 59 |         Browser::new(session.session, // Session
 60 |                      "".to_owned(),
 61 |                      browserview_id,
 62 |                      session, // BrowserHandler
 63 |                      session, // document handler
 64 |                      session, // http handler
 65 |                      );
 66 |     }
 67 | }
 68 | 
 69 | impl MyWindow { // One per native window
 70 |     fn get_my_session() -> MySession {
 71 |         // …
 72 |     }
 73 |     fn handle_compositor_message(&self, msg) {
 74 |         match msg {
 75 | 
 76 |             BrowserMsg::MouseEvent(event, browserid) => {
 77 |                 let browser = GetBrowserFromID(browseid);
 78 |                 browserid.handle_event(event).and_then(|consumed| {
 79 |                     if event_is_scroll_event && !consumed {
 80 | 
 81 |                         // strategy 1: all scroll events that are not consumed
 82 |                         // are sent back to compositor
 83 |                         let msg = CompositorMsg::UnconsumedScrollEvent(event, browserid);
 84 | 
 85 |                         // strategy 2: all scroll events stay in compositor until
 86 |                         // the use remove his fingers from touchpad
 87 |                         let msg = CompositorMsg::ScrollBrowserViewUntilRelease(browserid);
 88 | 
 89 |                         self.compositor_sender.send(msg);
 90 |                     }
 91 |                 });
 92 |             }
 93 | 
 94 |             BrowserMsg::KeyboardEvent(event) => {
 95 | 
 96 |                 match event.key {
 97 | 
 98 |                     CMD_LEFT => { // go back
 99 |                         let browser = self.browsers[self.fg_browser_index];
100 |                         BrowserHelper::go_back(browser);
101 |                     },
102 | 
103 |                     ESC => { // stop loading
104 |                         let browser = self.browsers[self.fg_browser_index];
105 |                         if browser.has_pending_document() {
106 |                             // there is a page to be loaded
107 |                             browser.cancel_pending_document();
108 |                         }
109 |                         if let Some(p) = BrowserHelper::get_current_document(browser) {
110 |                             p.stop_loading();
111 |                         }
112 |                     },
113 | 
114 |                     CMD_R => { // reload
115 |                         if let Some(p) = BrowserHelper::get_current_document(browser) {
116 |                             p.reload();
117 |                         }
118 |                     },
119 | 
120 |                     CMD_L => { // focus url bar
121 |                         let browser = self.browsers[self.fg_browser_index];
122 |                         browser.handle_event(event).and_then(|consumed| {
123 |                             if !consumed {
124 |                                 // […] focus urlbar
125 |                             }
126 |                         });
127 |                     }
128 | 
129 |                     CMD_Q => { // quit
130 |                         let msg = AppMsg::Quit();
131 |                         // not sure how to reach the session
132 |                         session.app_sender(msg);
133 |                     }
134 | 
135 |                     CMD_W => { // close tab
136 |                         let browser = …; // Tab to close
137 |                         let browserview = …; // get browserview from hashmap
138 |                         let msg = CompositorMsg::KillBrowserView(browserview);
139 |                         self.compositor_sender.send(msg);
140 |                         let load_data = browser.get_entries().map(|e| e.load_data);
141 |                         let idx = browser.get_current_entry_index();
142 |                         let closed_tab = ClosedTab {
143 |                             entries: load_data,
144 |                             current: idx,
145 |                         }
146 |                         self.closed_tabs.push(closed_tab);
147 |                         // Destroy browser
148 |                     }
149 | 
150 |                     CMD_SHIT_T => {
151 |                         let closed_tab = match self.closed_tabs.pop() {
152 |                             Some(closed_tab) => { closed_tab },
153 |                             None => return,
154 |                         }
155 |                         let session = self.get_my_session();
156 |                         let browser = BrowserHelper::create_new_view_and_browser(session, self.compositor_sender);
157 |                         browser.restore_entries(closed_tab.entries, closed_tab.current);
158 |                         self.browsers.push(browser);
159 |                         self.fg_browser_index = self.browsers.size - 1;
160 |                     }
161 | 
162 |                 }
163 |             }
164 |         }
165 |     }
166 | 
167 |     fn user_hit_enter_in_urlbar(&self, url: String, user_value: String) {
168 |         let browser = self.browsers[self.fg_browser_index];
169 |         if browser.has_prerendering_document() {
170 |             // We assumed that the prerendering document would
171 |             // have been dismissed if the user entered a different
172 |             // url
173 |             browser.navigate_to_prerendering_document(None);
174 |         } else {
175 |             let load_data = LoadData {
176 |                 url: url.clone(),
177 |                 user_typed_value: user_value.clone(),
178 |                 transition_type: TransitionType::Typed,
179 |                 http_method: HTTPMethod::GET,
180 |                 scroll_restoration_mode: ScrollRestoration::Auto,
181 |                 title: None,
182 |                 http_headers: None,
183 |                 body: None,
184 |                 referrer_url: None,
185 |                 scroll_position: None,
186 |                 js_state_object: None,
187 |                 form_data: None,
188 |             }
189 |             browser.navigate(load_data, None);
190 |         }
191 |     }
192 | 
193 |     fn user_about_to_hit_enter_in_urlbar(&self, url: String, user_value: String) {
194 |         let browser = self.browsers[self.fg_browser_index];
195 |         if browser.has_prerendering_document() {
196 |             browser.cancel_prerendering_document();
197 |         }
198 |         browser.build_prerendering_document(LoadData {
199 |             url: url.clone(),
200 |             user_typed_value: user_value.clone(),
201 |             transition_type: TransitionType::Typed,
202 |             http_method: HTTPMethod::GET,
203 |             scroll_restoration_mode: ScrollRestoration::Auto,
204 |             title: None,
205 |             http_headers: None,
206 |             body: None,
207 |             referrer_url: None,
208 |             scroll_position: None,
209 |             js_state_object: None,
210 |             form_data: None,
211 |         });
212 |     }
213 | 
214 |     fn invalidate_prerendering_document() {
215 |         // Called if the preloading document makes
216 |         let browser = self.browsers[self.fg_browser_index];
217 |         if browser.has_prerendering_document() {
218 |             browser.cancel_prerendering_document();
219 |         }
220 |     },
221 | 
222 |     fn add_browser(&self,
223 |                           load_data: LoadData,
224 |                           opener: Option<DocumentID>
225 |                           disposition: WindowDisposition) {
226 | 
227 |         if disposition == WindowDisposition::NewWindow {
228 |             // Error
229 |         }
230 | 
231 |         let session = self.get_my_session();
232 |         let browser = BrowserHelper::create_new_view_and_browser(session, self.compositor_sender);
233 |         browser.navigate(load_data, opener);
234 |         self.browsers.push(browser);
235 |         if disposition == WindowDisposition::ForegroundTab {
236 |             self.fg_browser_index = self.browsers.size - 1;
237 |             // […] more stuff
238 |         }
239 |     }
240 | 
241 |     fn preview_browser_history(&self, browser) {
242 |         let documents = browser.get_entries().iter().filter_map(|e| {
243 |             e.document_id
244 |         });
245 |         let msg = CompositorMsg::PreviewManyDocuments(documents);
246 |         self.compositor_sender.send(msg);
247 |     }
248 | 
249 |     fn update_progressbar(&self) {
250 |         let mut status = ProgressbarStatus::Loaded;
251 |         let browser = self.browsers[self.fg_browser_index];
252 |         if browser.has_pending_document() {
253 |             status = ProgressbarStatus::Connecting;
254 |             // update progressbar
255 |             return;
256 |         }
257 | 
258 |         let document = BrowserHelper::get_current_document(browser).unwrap();
259 |         let state = document.get_document_state();
260 | 
261 |         status = match state {
262 |             Complete | Error(_) | Crash(_) => {
263 |                 ProgressbarStatus::Loaded
264 |             },
265 |             Interactive, Loading => {
266 |                 ProgressbarStatus::Connected
267 |             },
268 | 
269 |         }
270 |         // update progressbar
271 |     }
272 | }
273 | 
274 | impl MySession {
275 |     fn find_window_for_browser(&self, browser: BrowserID) -> &MyWindow {
276 |         // […]
277 |     },
278 |     fn find_browser_for_document_id(&self, document_id: DocumentID) -> BrowserID {
279 |         // This is not really handy. It's probably better to have a
280 |         // document_id <-> browser hashmap, built with
281 |         // BrowserHandler::current_entry_index_changed
282 |         self.browsers.find(|b| {
283 |             b.get_current_entry().unwrap().document_id == document_id
284 |         });
285 |     }
286 |     fn create_new_native_window(&self) {
287 |         let (sender, receiver) = ipc::channel().unwrap();
288 |         let msg = AppMsg::CreateNewNativeWindow(sender);
289 |         self.app_sender.send(msg);
290 |         let chan = receiver.recv().unwrap();
291 |         let window = MyWindow {
292 |             compositor_sender: chan,
293 |             browsers: [],
294 |             fg_browser_index: 0
295 |         };
296 |         self.windows.push(window);
297 |         window
298 |     }
299 | }
300 | 
301 | impl DocumentHandler for MySession {
302 | 
303 |     fn will_navigate(&self, document_id: DocumentID, load_data: LoadData) {
304 |         match load_data.transition_type {
305 |             LinkClicked(MiddleButton, _) |
306 |             LinkClicked(_, CMD_KEY) |
307 |             LinkClicked(_, CTRL_KEY) => {
308 |                 let browser = self.find_browser_for_document(document_id);
309 |                 let window = self.find_window_for_browser(browser);
310 |                 window.add_browser(load_data, WindowDisposition::BackgroundTab);
311 |                 // Will cancel navigation
312 |                 false
313 |             },
314 |             JavaScript => {
315 |                 let browser = self.find_browser_for_document(document_id);
316 |                 let window = self.find_window_for_browser(browser);
317 |                 window.add_browser(load_data, WindowDisposition::BackgroundTab);
318 |                 false
319 |             }
320 |             Reload => {
321 |                 // Reload is about to happen
322 |             },
323 |             _ => {
324 |                 // Will let navigation happen
325 |                 let browser = self.find_browser_for_document(document_id);
326 |                 if is_pin_tab(browser) { // the pin tab notion is an embedder thing
327 |                     let document = browser.get_document(document_id).unwrap();
328 |                     let old_url = document.get_url();
329 |                     let old_domain = Url::parse(old_url).unwrap();
330 |                     let new_domain = Url::parse(load_data.url).unwrap();
331 |                     if old_domain != new_domain {
332 |                         let window = self.find_window_for_browser(browser);
333 |                         window.add_browser(load_data, WindowDisposition::ForegroundTab);
334 |                         // Will cancel navigation
335 |                         false
336 |                     } else {
337 |                         true
338 |                     }
339 |                 } else {
340 |                     true
341 |                 }
342 |             }
343 |         }
344 |     }
345 | 
346 |     fn title_changed(&self, document_id: DocumentID) {
347 |         let browser = self.find_browser_for_document(document_id);
348 |         let document = browser.get_document(document_id).unwrap();
349 |         let title = document.get_title();
350 |         // […] Update title in tab
351 |     }
352 | 
353 |     fn icons_changed(&self, document_id: DocumentID) {
354 |         let browser = self.find_browser_for_document(document_id);
355 |         let document = browser.get_document(document_id).unwrap();
356 |         let icons = document.get_icons();
357 |         let best_fit = icons.fold(/*[…]*/);
358 |         // […] Update icon in tab
359 |     }
360 | 
361 |     fn metas_changed(&self, document_id, DocumentID) {
362 |         let browser = self.find_browser_for_document(document_id);
363 |         let document = browser.get_document(document_id).unwrap();
364 |         let metas = document.get_metas();
365 |         if let Some(meta) = metas.find(|m| m.name == "theme-color") {
366 |             let color = meta.content;
367 |             // […] Update color for tab
368 |         }
369 | 
370 |     }
371 | 
372 |     fn close(&self, document_id: DocumentID) {
373 |         self.confirm(document_id,
374 |                      "Wanna close?".to_owned(),
375 |                      "you will lose everything".to_owned())
376 |             .and_then(|| {
377 |                 // […] then destroy browser
378 |             });
379 |     }
380 | 
381 |     fn new_window(&self, document_id: DocumentID, mut disposition: WindowDisposition, load_data: LoadData) {
382 |         let window = if disposition == WindowDisposition::NewWindow {
383 |             disposition = WindowDisposition::ForegroundTab
384 |             self.create_new_native_window()
385 |         } else {
386 |             let browser = self.find_browser_for_document(document_id);
387 |             self.find_window_for_browser(browser)
388 |         }
389 |         window.add_browser(load_data, disposition);
390 |     }
391 | 
392 |     fn confirm(&self, document_id: DocumentID, title: String, message: String) -> impl Future<Item=bool> {
393 |         let browser = self.find_browser_for_document(document_id);
394 |         let window = self.find_window_for_browser(browser);
395 |         let msg = CompositorMsg::ShowConfirmDialog(
396 |             browser.get_id(),
397 |             title,
398 |             message);
399 |         window.compositor_sender.send(msg);
400 |         // Missing: return a Future that would resolve once
401 |         // the compositor get the information
402 |     }
403 | 
404 |     fn state_changed(&self, document_id: DocumentID) {
405 |         let browser = self.find_browser_for_document(document_id);
406 |         let window = self.find_window_for_browser(browser);
407 |         window.update_progressbar();
408 | 
409 |         let document = browser.get_document(document_id).unwrap();
410 |         let state = document.get_document_state();
411 |         match state {
412 |             DocumentState::Error(_) => {
413 |                 // Connection error
414 |                 // Do something
415 |             },
416 |             DocumentState::Complete => {
417 |                 let http_response = document.get_http_response().expect("error").unwrap();
418 |                 let status = http_method.raw_status;
419 |                 if status == 404 {
420 |                     // Do something
421 |                 }
422 |             }
423 |             _ => {},
424 |         }
425 |     }
426 | }
427 | 
428 | impl BrowserHandler for MySession {
429 | 
430 |     fn current_entry_index_changed(&self, browser, document_id, index) {
431 |         // Update a map of browser <-> document_id
432 |     }
433 | 
434 |     fn document_pending(&self, browser: BrowserID) {
435 |         let window = self.find_window_for_browser(browser);
436 |         window.update_progressbar();
437 |     }
438 | 
439 |     fn no_document_pending(&self, browser: BrowserID) {
440 |         let window = self.find_window_for_browser(browser);
441 |         window.update_progressbar();
442 |     }
443 | 
444 | }
445 | 


--------------------------------------------------------------------------------
/examples/compositor.rs:
--------------------------------------------------------------------------------
  1 | struct MyCompositor {
  2 |     compositor: Compositor,
  3 |     browser_sender: IpcSender<BrowserMsg>,
  4 |     translate_browserview: bool,
  5 |     translate_toolbar: bool,
  6 | }
  7 | 
  8 | struct App {
  9 |     compositors: Vec<CompositorMsg>,
 10 | }
 11 | 
 12 | impl App {
 13 |     fn handle_message {
 14 |         match message {
 15 |             AppMsg::CreateNewNativeWindow(resp_chan) => {
 16 |                 let drawable = NewGlutinWindowAsDrawable();
 17 |                 let new_compositor = MyCompositor {
 18 |                     compositor: Compositor::new(drawable),
 19 |                     browser_sender: …,
 20 |                 }
 21 |                 self.compositors.push(new_compositor);
 22 |                 // create chan
 23 |                 resp_chan.send(chan);
 24 |             }
 25 |         }
 26 |     }
 27 | }
 28 | 
 29 | /// Event loop
 30 | impl MyCompositor {
 31 |     fn handle_window_event(&self, native_event: NativeEvent) {
 32 |         let event = NativeEventToServoEvent(native_event);
 33 |         match event {
 34 |             KeyboardEvent => {
 35 |                 let msg = BrowserMsg::KeyboardEvent(event);
 36 |                 self.browser_sender.send(msg);
 37 |             },
 38 |             MouseEvent => {
 39 |                 let current_cursor = …;
 40 |                 // Get browserviews under cursor
 41 |                 let iter = self.compositor.get_browserviews_from_point(current_cursor);
 42 |                 // Get highest browserview 
 43 |                 let browserview = iter.max_by_key(|v| {v.get_frame().z_index});
 44 |                 if Some(browserview) = browserview {
 45 | 
 46 |                     let browser = browserview.get_attached_browser().unwrap();
 47 | 
 48 |                     if !event_is_scroll {
 49 |                         let msg = BrowserMsg::MouseEvent(event, browser);
 50 |                         self.browser_sender.send(msg);
 51 |                         return
 52 |                     }
 53 | 
 54 |                     if self.translate_browserview {
 55 |                         // Scroll event and translate_browserview is true
 56 |                         if event.phase == release {
 57 |                             self.translate_browserview = false;
 58 |                         } else {
 59 |                             self.move_browserview_from_scrollevent(browserview, event);
 60 |                         }
 61 |                         return;
 62 |                     }
 63 | 
 64 |                     // Check if the toolbar should be moved or not. If scroll up and toolbar
 65 |                     // is not collapse for example.
 66 |                     let translate_toolbar = …;
 67 | 
 68 |                     if translate_toolbar {
 69 |                         let y = event.delta_y;
 70 | 
 71 |                         // 1. Move toolbar
 72 |                         // let's assume the toolbar is a DOM element in another browserview,
 73 |                         // and that DOM element is linked to a StackingContextID
 74 |                         let toolbar_browserview = …;
 75 |                         let toolbar_id = …;
 76 |                         let mut composite_and_transform = toolbar_browserview.get_composite_and_transform(toolbar_id).unwrap();
 77 |                         let transform = composite_and_transform.transform.post_translated(0,y,0);
 78 |                         composite_and_transform.transform = transform;
 79 |                         toolbar_browserview.set_composite_and_transform(toolbar_id, composite_and_transform);
 80 | 
 81 |                         // 2. resize and move content
 82 |                         let mut frame = browserview.get_content_frame();
 83 |                         frame.coordinates.size.height += y;
 84 |                         frame.coordinates.origin.y -= y;
 85 |                         browserview.set_content_frame(frame, None);
 86 | 
 87 |                         // Warning! When translate_toolbar is back to false, or the user release the touch pad,
 88 |                         // call browserview.resize_and_scroll_browsers
 89 |                     }
 90 | 
 91 |                     let msg = BrowserMsg::MouseEvent(event, browser);
 92 |                     self.browser_sender.send(msg);
 93 |                 }
 94 |             }
 95 |         }
 96 |     }
 97 | 
 98 |     fn move_browserview_from_scrollevent(&self, browserview, event) {
 99 |         // Only handle vertical scroll
100 |         let delta_y = event.delta.y;
101 |         let mut new_frame = browserview.get_frame();
102 |         new_frame.coordinates.origin.y += delta_y;
103 |         browserview.set_frame(new_frame, None);
104 |     }
105 | 
106 |     fn handle_browser_message(&self, message: CompositorMsg) {
107 |         match message {
108 |             CompositorMsg::CreateBrowserView(sender) => {
109 |                 let framebuffer_size = …; // Size of the GL region
110 |                 let w = framebuffer_size.width;
111 |                 let h = framebuffer_size.height;
112 |                 let toolbar_height = 20;
113 |                 let outer_frame = ViewFrame {
114 |                     coordinates: Rect::new(0,0,w,h),
115 |                     z_index: 0,
116 |                     background_color: Color::White,
117 |                     opacity: 1,
118 |                 }
119 |                 let mut content_frame = frame.clone();
120 |                 content_frame.coordinates.origin.x = toolbar_height;
121 |                 content_frame.coordinates.size.height -= toolbar_height;
122 |                 let browserview = self.compositor.new_browserview(frame, content_frame, browser);
123 |                 sender.send(browserview.get_id());
124 |             },
125 |             CompositorMsg::KillBrowserView(viewpo) {
126 |                 // Destroy browserview
127 |             },
128 |             CompositorMsg::ShowConfirmDialog(browser, title, message) => {
129 |                 // build a popup, draw it somewhere, wait for keyboard or
130 |                 // mouse events to see if the user clicks cancel or ok.
131 |                 // then send boolean back to browser
132 |             },
133 |             CompositorMsg::PreviewManyDocuments(documents) {
134 |                 // Maybe get all views first and hide them
135 | 
136 |                 let framebuffer_size = …; // Size of the GL region
137 | 
138 |                 let w = framebuffer_size.width;
139 |                 let h = framebuffer_size.height;
140 |                 let ratio = documents.len();
141 |                 let rect = Rect::new(0,0,w,h).scale(ratio,ratio);
142 | 
143 |                 let mut offset = 0;
144 | 
145 |                 documents.iter().map(|p| {
146 |                     let mut view_rect = rect.clone();
147 |                     view_rect.origin.x = offset;
148 |                     offset += rect.size.width;
149 |                     let frame = ViewFrame {
150 |                         coordinates: view_rect,
151 |                         z_index: 0,
152 |                         background_color: Color::White,
153 |                         opacity: 1,
154 |                     }
155 |                     self.compositor.new_documentview(frame, p);
156 |                 });
157 |                 
158 | 
159 |             }
160 |             CompositorMsg::UnconsumedScrollEvent(event, browserid) {
161 |                 let browserview = …; // Get browserview from browserid
162 |                 self.move_browserview_from_scrollevent(browserview, event);
163 |             }
164 |             CompositorMsg::ScrollBrowserViewUntilRelease(_) {
165 |                 self.translate_browserview = false;
166 |             }
167 |         }
168 |     }
169 | }
170 | 


--------------------------------------------------------------------------------
/servo_traits/browser/browser.rs:
--------------------------------------------------------------------------------
  1 | /// Browser is the equivalent of a top level Constellation::Frame.
  2 | /// Equivalent of a tab. Browser is a top level browsing context.
  3 | 
  4 | /// More or less equivalent to FrameState (which is very minimal so far).
  5 | pub struct HistoryEntry {
  6 |     load_data: LoadData,
  7 |     current: bool,
  8 |     // Multiple entries can refer to the same document.
  9 |     // Document might not exist anymore (purged document).
 10 |     document_id: Option<TopLevelDocumentID>,
 11 | }
 12 | 
 13 | pub enum DocumentAccessError {
 14 |     NoSuchDocument,
 15 |     NotTopLevelDocument,
 16 |     FrozenDocument,
 17 |     ThawnDocument,
 18 | }
 19 | 
 20 | enum Event {
 21 |     // FIXME: event details missing
 22 |     Mouse(),
 23 |     Touch(),
 24 |     Key(),
 25 |     Scroll(),
 26 |     TouchpadPressure(),
 27 | }
 28 | 
 29 | pub trait Browser {
 30 |     fn new(session: &Session,
 31 |            browsing_context_name: String
 32 |            browserview: BrowserViewID,
 33 |            browser_handler: &BrowserHandler,
 34 |            document_handler: &DocumentHandler,
 35 |            http_handler: &HttpHandler) -> Browser;
 36 |     fn get_id(&self) -> BrowserID;
 37 |     fn get_browsing_context_name(&self) -> String;
 38 |     // Will throttle timers, and disable requestAnimationFrame
 39 |     fn set_visible(&self, visible: bool);
 40 |     // JS module resolver. Will resolve "foo" in `import v from "foo"`
 41 |     // For example, can be used to expose the Browser API or Web Extensions APIs for content
 42 |     // See: https://developer.chrome.com/extensions/content_scripts#execution-environment
 43 |     // and https://tc39.github.io/ecma262/#sec-hostresolveimportedmodule
 44 |     fn register_js_module_resolver(&self, resolver: JSModuleResolver, only_frame_script: bool);
 45 |     // Will fail if entries already exist.
 46 |     // This can be used for session restore, or to undo tab-close.
 47 |     // On success, entries are accessible, current entry's document is not pending.
 48 |     // If necessary, other documents can be restored via restore_document()
 49 |     fn restore_entries(&self, Vec<LoadData> data, current_index: u32) -> impl Future<Item=(), Error=()>;
 50 | 
 51 |     fn get_entries(&self) -> Vec<HistoryEntry>;
 52 |     fn get_entry_count(&self) -> u32;
 53 |     // None if no entry has been loaded yet
 54 |     fn get_current_entry(&self) -> Option<HistoryEntry>;
 55 |     fn get_current_entry_index(&self) -> Option<u32>;
 56 |     // Will fail if index is not reachable. Will cancel any pending document.
 57 |     // On success, the current document is restored and not pending,
 58 |     // and current entry index has been updated.
 59 |     fn set_current_entry_index(&self, index: u32) -> impl Future<Item=(), Error=()>;
 60 | 
 61 |     fn has_pending_document(&self) -> bool;
 62 |     fn cancel_pending_document(&self);
 63 |     // Up to the embedder to eventually release the document from memory.
 64 |     // Will fail if document is current
 65 |     fn purge_document(&self, document: TopLevelDocumentID) -> Result<(),()>;
 66 |     fn restore_document(&self, entry_index: u32);
 67 |     // Use to load a new URL. will create a new document and navigate to the
 68 |     // document once not pending. Will cancel any pending document.
 69 |     fn navigate(&self, data: LoadData, opener: Option<DocumentID>) -> implt Future<Item=(),Error=()>;
 70 |     // Create a prerendering document.
 71 |     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=730101
 72 |     // and: https://www.chromium.org/developers/design-documents/prerender
 73 |     // Used for example while the user types a URL in the urlbar. Before the user presses enter,
 74 |     // the embedder can create such a document to spead up loading.
 75 |     fn build_prerendering_document(&self, LoadData loadData);
 76 |     fn navigate_to_prerendering_document(&self, opener: Option<DocumentID>);
 77 |     fn cancel_prerendering_document(&self);
 78 |     fn has_prerendering_document(&self) -> bool;
 79 |     // BrowserView (owner of the browser) doesn't have the notion of focus.
 80 |     // It's up to the embedder to make sure only one browser is focused.
 81 |     fn set_focus(&self, focus: bool);
 82 |     fn is_focused(&self) -> bool;
 83 |     // Return a Future with boolean telling if the event has been
 84 |     // consumed by the content (scroll actually happened, key event
 85 |     // has been typed, preventDefault() has been called, …)
 86 |     fn handle_event(&self, event: Event) -> impl Future<Item = bool>;
 87 | 
 88 |     fn get_document(&self, id: document_id) -> Result<Document,DocumentAccessError>;
 89 |     fn get_top_level_document(&self, id: document_id) -> Result<TopLevelDocument,DocumentAccessError>;
 90 |     
 91 | 
 92 |     // Used, for example, when a right click event is not consumed by content, to show a context menu
 93 |     fn get_content_from_point(&self, point: Point2D<f32>) -> impl Future<Item=ContentDescriptionAtPoint>;
 94 | }
 95 | 
 96 | pub trait BrowserHandler {
 97 |     // A new document is displayed. Usually after the user
 98 |     // clicked on a link and once the new document has been
 99 |     // created (document is not pending anymore). Also happens
100 |     // when user or page goes back/forward.
101 |     fn current_entry_index_changed(&self, browser: BrowserID, document: DocumentID, index: u32);
102 | 
103 |     // When an entry change. For example after a reload or replaceState.
104 |     fn history_entry_changed(&self, browser: BrowserID, index: u32);
105 | 
106 |     // When the user clicks on a link, the current entry doesn't change
107 |     // right away. A document is created and is only attached to the browser
108 |     // once the HTTP metadata has been retrieved.
109 |     fn document_pending(&self, browser: BrowserID);
110 |     fn no_document_pending(&self, browser: BrowserID);
111 | 
112 |     fn document_restored(&self, browser: BrowserID, document: TopLevelDocumentID);
113 |     fn document_purged(&self, browser: BrowserID, document: TopLevelDocumentID);
114 | }
115 | 
116 | // EXPERIMENTAL AND TEMPORARY
117 | 
118 | // Below interfaces are not optimized for performance but for ease of
119 | // implementation.
120 | // 
121 | // The goal it to be able to experiment with non-linear history. Entries are
122 | // stored in an array. When a user goes back in the history and then navigates,
123 | // the previous forward history is dropped. We want to be able to experiment
124 | // with saving that previous forward history, moving from an array structure to
125 | // a tree structure. This goes against the web specifications, and might
126 | // involve intrusive changes in Servo.
127 | //
128 | // The following interfaces are a temporary solution that doesn't require much
129 | // work on Servo's side, and at the same time make it possible to build a tree
130 | // structure at the API consumer level. There are some drawbacks.  Documents
131 | // are dropped, only the LoadData is saved, and the consumer has to maintain an
132 | // alternate history structure.
133 | 
134 | pub trait BrowserExperimental : Browser {
135 |     // Will drop the back and forward entries and replace with new ones.
136 |     // At that point, all documents are purged. Only the current one stays
137 |     // alive.
138 |     fn replace_entries_but_current(&self,
139 |                                    back_history: Vec<LoadData>,
140 |                                    fwd_history: Vec<LoadData>);
141 | }
142 | 
143 | pub trait BrowserExperimentalHandler : BrowserHandler {
144 |     // This happens on goBack + navigate, and when replaceEntriesButCurrent is
145 |     // called. The forward list of entries is dropped. This event comes with a
146 |     // list of LoadData object that can be used to restore the branch if
147 |     // necessary.
148 |     fn browser_forward_history_branch_dropped(&self,
149 |                                               browser: BrowserID,
150 |                                               entries: Vec<LoadData);
151 | }
152 | 


--------------------------------------------------------------------------------
/servo_traits/browser/content_blocker.rs:
--------------------------------------------------------------------------------
 1 | // A Browser has access to multiple content blockers: Popup blocker, tracking
 2 | // content blocker, mixed content blocker, custom blocker (à la Safari).
 3 | // Blockers are registered at 3 different levels: Session, Browser, Document
 4 | // Blockers can be enabled or disabled.
 5 | // Document blockers take precedence over Browser blockers which take precedence
 6 | // over Session blockers.
 7 | // Blockers can be enabled/disabled just for a document (allowing mixed content
 8 | // for example is per page), just for a browser (we might want to allow popups
 9 | // just for a tab) or for a whole session (block tracking for the whole session)
10 | //
11 | // Not all content blockers are enable on page load. Enabling a content blocker
12 | // for a page doesn't mean it will be activated for the next document.
13 | 
14 | pub enum ContentBlockerType {
15 |     Popup, // Popup blocker
16 |     Tracking, // https://developer.mozilla.org/en-US/Firefox/Privacy/Tracking_Protection
17 |     Mixed, // https://developer.mozilla.org/en-US/docs/Web/Security/Mixed_content
18 |     Custom(String), // adblockers, See https://github.com/servo/servo/issues/9749
19 | }
20 | 
21 | // Is content blocker enabled at the session level.
22 | // See session.rs
23 | pub struct SessionContentBlocker {
24 |     type_: ContentBlockerType,
25 |     enabled: bool,
26 | }
27 | 
28 | // We might want to display the number of blocked elements
29 | // or the number of elements that could have been blocked
30 | // if the blocker would be enabled
31 | pub struct BlockedContentCount {
32 |     blocked: u32,
33 |     blockable: u32,
34 | }
35 | 
36 | // ** Implemented by Session, Browser and Document **
37 | // A content blocker can be enabled just for a page, for a tab,
38 | // or for the whole browser.
39 | pub trait ContentBlockerConfiguration {
40 |     fn enable_content_blocker(&self, type_: ContentBlockerType);
41 |     fn disable_content_blocker(&self, type_: ContentBlockerType);
42 |     fn is_content_blocker_enabled(&self, type_: ContentBlockerType);
43 | }
44 | 


--------------------------------------------------------------------------------
/servo_traits/browser/content_description.rs:
--------------------------------------------------------------------------------
 1 | // From Browser::get_content_from_point(). The node found is called "Target"
 2 | // Used to build context menu
 3 | // Inspired by http://electron.atom.io/docs/api/web-contents/#event-context-menu
 4 | 
 5 | 
 6 | pub enum InputType {
 7 |     PlainText, Password, Other
 8 | }
 9 | 
10 | pub struct ContentDescriptionAtPoint {
11 |     x: f32,
12 |     y: f32,
13 | 
14 |     document_id: DocumentID, // Document owning the target
15 |     link_url: Option<String>, // URL of the link that encloses the target
16 |     link_text: Option<String>, // Text associated with the link. May be an empty string if the contents of the link are an image.
17 |     src_url: Option<String>, // Source URL of the target. Elements with source URLs are images, audio and video.
18 |     has_image_contents: bool, // Whether the target is an image which has non-empty contents.
19 |     title_text: Option<String>, // Title or alt text of the target
20 |     misspelled_word: Option<String>, // The misspelled word, if any.
21 |     frame_charset: Option<String>, // The character encoding of the document owning the target
22 |     input_field_type: Option<InputType>, // If target is an input field, the type of that field.
23 | 
24 |     editable_state: EditableState, // See editable.rs
25 | 
26 |     // See multimedia.rs
27 |     media_type: Option<MediaType>, // Type of the target if media.
28 |     media_flags: MediaState, // State of the media.
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/servo_traits/browser/document.rs:
--------------------------------------------------------------------------------
  1 | pub struct MetaTag {
  2 |   name: String;
  3 |   content: String;
  4 | }
  5 | 
  6 | pub enum WindowDisposition {
  7 |   ForegroundTab,
  8 |   BackgroundTab,
  9 |   NewWindow,
 10 | }
 11 | 
 12 | pub enum PromptType {
 13 |   Alert,
 14 |   Confirm,
 15 | }
 16 | 
 17 | pub enum DocumentState {
 18 |     // Document not created yet.
 19 |     // Period between the time the user clicks on a link and the time the previous document becomes inactive
 20 |     // FIXME: not sure we will ever have access to a pending document
 21 |     Pending,
 22 | 
 23 |     // Couldn't complete HTTP connection. Servo should not redirect to an error page. This should be handled client side.
 24 |     Error(DocumentError),
 25 |     // Document crashed
 26 |     Crash(DocumentError),
 27 | 
 28 |     // Following values are the same as DOM's document.readyState
 29 | 
 30 |     // The document is still loading.
 31 |     Loading,
 32 |     // The document has finished loading and the document has been parsed but sub-resources such as images, stylesheets and frames are still loading.
 33 |     Interactive,
 34 |     // The document and all sub-resources have finished loading. The state indicates that the load event has been fired.
 35 |     Complete,
 36 | }
 37 | 
 38 | pub enum SaveType {
 39 |     // Save only the HTML of the page.
 40 |     HTMLOnly,
 41 |     // Save complete-html page.
 42 |     HTMLComplete,
 43 |     // Save complete-html page as MHTML.
 44 |     MHTML,
 45 | }
 46 | 
 47 | // crash reports, DNS/TCP errors, … Not HTTP error (see Document.HTTPResponse).
 48 | pub struct DocumentError {
 49 |     final_url: String,
 50 |     // Chrome error list: https://cs.chromium.org/chromium/src/net/base/net_error_list.h
 51 |     // FIXME: an enum would be better
 52 |     code: u32,
 53 |     // Human readable
 54 |     description: String,
 55 |     // Backtrace for panics
 56 |     report: Option<String>;
 57 | }
 58 | 
 59 | pub enum SaveRenderingStrategy {
 60 |     Default,
 61 |     Displaylist,
 62 |     Texture,
 63 | }
 64 | 
 65 | pub struct Icon {
 66 |     href: String,
 67 |     sizes: Vec<Size2D<f32>>;
 68 |     rel: String;
 69 | }
 70 | 
 71 | pub struct ConsoleMessageDetails {
 72 |     level: ConsoleLevel,
 73 |     message: String,
 74 |     col: u32,
 75 |     row: u32,
 76 |     source: String,
 77 | }
 78 | 
 79 | 
 80 | // It is likely that the embedder only wants to control the current and top level document. So we
 81 | // could expect Document's and TopLevelDocument's methods to be part of Browser. But we don't want
 82 | // to set that in stone. Maybe in the future we want to give access to inner <iframe>' document, or
 83 | // frozen documents.
 84 | // In term of lifetime, we want to make sure an instance of Document doesn't outlive its internal's
 85 | // counter-part.
 86 | 
 87 | pub trait Document {
 88 |     // URL changes during redirects
 89 |     fn get_url(&self) -> String;
 90 |     fn get_title(&self) -> Option<String>;
 91 |     fn get_http_response(&self) -> Option<HTTPResponse>;
 92 | 
 93 |     fn is_current(&self) -> bool;
 94 | 
 95 |     // Used to replace mozbrowserconnected, mozbrowserloadstart, mozbrowserloadend
 96 |     // Use performance for time stamps.
 97 |     fn get_state(&self) -> DocumentState;
 98 | 
 99 |     // See Performance.webidl and PerformanceTiming.webidl
100 |     // Necessary to implement https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/history/HistoryItem
101 |     fn get_performance(&self) -> Performance;
102 | 
103 |     fn get_icons(&self) -> Iterator<Icon>;
104 |     fn get_metas(&self) -> Iterator<MetaTag>;
105 | 
106 |     fn stop_loading(&self);
107 | 
108 |     // Will destroy that document and create a new one
109 |     fn reload(&self);
110 |     fn clear_cache_and_reload(&self);
111 | 
112 |     fn insertCSS(&self, code: String);
113 | 
114 |     fn evaluateScript(&self, code: String, only_for_frame_script: bool) -> impl Future<Item = JSObject>;
115 | }
116 | 
117 | // Document methods that only work for top level documents
118 | pub trait TopLevelDocument : Document {
119 | 
120 |     fn get_hovered_link(&self) -> Option<String>;
121 |     fn get_connection_security(&self) -> ConnectionSecurity;
122 | 
123 |     // We want to be able to render frozen document, so we need
124 |     // a way to save the rendering.
125 |     // FIXME: do we really want to let the client handle that?
126 |     fn set_save_rendering_strategy(&self, strategy: SaveRenderingStrategy);
127 | 
128 |     fn capture_page(&self, source: Rect, destination: Rect) -> impl Future<Item = Blob>;
129 |     fn save_page(&self, save_type: SaveType) -> impl Future<Item = Blob>;
130 |     fn download_url(&self, url: String) -> impl Future<Item = Blob>;
131 | 
132 |     fn get_blocked_content_count(&self) -> BlockedContentCount;
133 | }
134 | 
135 | 
136 | pub trait DocumentHandler {
137 | 
138 |     // Warning: might not be current!
139 |     fn created(&self, document: DocumentID); // Only after pending
140 |     fn destroyed(&self, document: DocumentID);
141 | 
142 |     fn frozen(&self, document: DocumentID);
143 |     fn thawn(&self, document: DocumentID);
144 | 
145 |     fn url_changed(&self, document: DocumentID);
146 |     fn title_changed(&self, document: DocumentID);
147 |     fn icons_changed(&self, document: DocumentID);
148 |     fn metas_changed(&self, document: DocumentID);
149 |     fn state_changed(&self, document: DocumentID);
150 |     fn hovered_link_changed(&self, document: DocumentID);
151 |     fn connection_security_changed(&self, document: DocumentID);
152 | 
153 |     // Up to the embedder to update the corresponding browserview
154 |     fn resize(&self, document: DocumentID, Size2D<f32>);
155 |     fn move(&self, document: DocumentID, Point2D<f32>);
156 | 
157 |     // Up to the embedder to destroy or not the Browser
158 |     fn close(&self, document: DocumentID);
159 | 
160 |     // Warning: Cmd/Ctrl/Click should not trigger new_window. It's up to
161 |     // the embedder to decide what to do when a link is clicked with a keyboard
162 |     // modifier. See will_navigate and LoadData::TransitionType::LinkClicked.
163 |     fn new_window(&self, document: DocumentID, disposition: WindowDisposition, load_data: LoadData, frame_name: String);
164 |     fn fullscreen(&self, document: DocumentID);
165 |     fn exit_fullscreen(&self, document: DocumentID);
166 |     fn console_message(&self, document: DocumentID, message: ConsoleMessageDetails);
167 |     // It's possible to cancel navigation. For example, pin
168 |     // tabs might want to open links from different domain
169 |     // into a different tab.
170 |     // false: navigation canceled.
171 |     fn will_navigate(&self, document: DocumentID, load_data: LoadData) -> bool;
172 | 
173 |     fn alert(&self, document: DocumentID, title: String, message: String) -> impl Future<>;
174 |     fn confirm(&self, document: DocumentID, title: String, message: String) -> impl Future<Item=bool>;
175 |     fn prompt(&self, document: DocumentID, title: String, message: String) -> impl Future<Item=String>;
176 |     // Send Ok(username,password) or Err() if cancelled.
177 |     fn username_and_password(&self, document: DocumentID) -> impl Future<Item=Result<(String,String),()>>;
178 |     // Send back true if servo should ignore the certificate error
179 |     fn ignore_certificate_error(&self, document: DocumentID, error: String, certificate: CertificateInfo) -> impl Future<Item=bool>;
180 | 
181 |     // One or several content blockers have blocked content or discovered
182 |     // blockable content.
183 |     fn blocked_content_count_changed(&self, document: DocumentID);
184 | }
185 | 


--------------------------------------------------------------------------------
/servo_traits/browser/editable.rs:
--------------------------------------------------------------------------------
 1 | // This is usually used to build the application Edit menu.
 2 | // Implemented by Browser, or maybe Document
 3 | 
 4 | pub struct EditableState {
 5 |     selected_text: String,
 6 |     is_editable: bool,
 7 |     can_undo: bool,
 8 |     can_redo: bool,
 9 |     can_cut: bool,
10 |     can_copy: bool,
11 |     can_paste: bool,
12 |     can_delete: bool,
13 |     can_select_all: bool,
14 | }
15 | 
16 | pub trait Editable {
17 |     fn get_state(&self) -> EditableState;
18 | 
19 |     fn undo(&self);
20 |     fn redo(&self);
21 |     fn cut(&self);
22 |     fn copy(&self);
23 |     fn paste(&self);
24 |     fn paste_and_match_style(&self);
25 |     fn delete(&self);
26 |     fn select_all(&self);
27 |     fn unselect(&self);
28 |     fn replace(&self, text: String);
29 |     fn replace_misspelling(&self, text: String);
30 |     fn insert_text(&self, text: String);
31 | }
32 | 
33 | pub trait EditableHandler {
34 |     fn editable_state_changed(&self);
35 | }
36 | 


--------------------------------------------------------------------------------
/servo_traits/browser/findable.rs:
--------------------------------------------------------------------------------
 1 | pub enum CaseSensitivity {
 2 |     CaseSensitive,
 3 |     CaseInsensitive,
 4 | }
 5 | 
 6 | pub enum StopFindAction {
 7 |     ClearSelection,// Clear the selection
 8 |     KeepSelection, // Translate the selection into a normal selection.
 9 |     ActivateSelection, // Focus and click the selection node
10 | }
11 | 
12 | pub struct FindState {
13 |     is_active: bool,
14 |     text: String,
15 |     match_index: u32,
16 |     matches_count: u32,
17 | }
18 | 
19 | // Implemented by Browser, or maybe Document 
20 | pub trait Findable {
21 |     fn get_state(&self) -> FindState;
22 |     fn find(&self, text: String, case_sensitivity: CaseSensitivity);
23 |     fn findNext(&self);
24 |     fn findPrevious(&self);
25 |     fn stopFind(&self, action: StopFindAction);  
26 | }
27 | 
28 | pub trait FindableHandler {
29 |     fn findable_state_changed(&self);
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/servo_traits/browser/http_observer.rs:
--------------------------------------------------------------------------------
1 | pub trait HttpHandler {
2 |     // FIXME
3 |     // Should be complete enough to implement: https://developer.chrome.com/extensions/webRequest
4 | }
5 | 


--------------------------------------------------------------------------------
/servo_traits/browser/load_data.rs:
--------------------------------------------------------------------------------
 1 | // LoadData is a central structure of the browser. It is used in many places.
 2 | // For example, when the user type a new url and hit enter, Browser::navigate
 3 | // is called with a LoadData.
 4 | // 
 5 | // This is all that is necessary to create a document. It can be (de)serialized and saved on disk.
 6 | // It can be used for session restore, and to undo tab close (Cmd-Shift-T). The creation of a
 7 | // document (navigation, session restore, restore on navigate) relies on this.  See
 8 | // constellation_msg::LoadData Relevant: https://github.com/servo/servo/pull/11893
 9 | 
10 | pub enum HTTPMethod { GET, POST }
11 | 
12 | pub enum TransitionType {
13 |     // How this document has been reached
14 |     // See: https://chromium.googlesource.com/chromium/src/+/master/chrome/common/extensions/api/history.json
15 |     LinkClicked(MouseButton, KeyModifier),
16 |     JavaScript,
17 |     Typed,
18 |     Bookmark,
19 |     FormSubmit,
20 |     Reload,
21 |     Keyword,
22 | }
23 | 
24 | pub struct FormDataEntry {
25 |   String name;
26 |   String value; // FIXME: What about File?
27 | }
28 | 
29 | #[derive(Deserialize, Serialize)]
30 | pub struct LoadData {
31 |   url: String,
32 |   title: Option<String>,
33 |   http_method: HTTPMethod, // Needed for the "want to resend (POST) request?" warning message
34 |   referrer_url: Option<String>,
35 |   transition_type: TransitionType,
36 |   // The user input that lead to load this entry. For example,
37 |   // if the user typed "foo bar" that eventually redirect to a
38 |   // google URL, user typed value is "foo bar"
39 |   user_typed_value: Option<String>,
40 | 
41 |   // FIXME: exposing these is not really required
42 |   http_headers: Option<HTTPHeaders>, // See Headers.webidl
43 |   body: Option<BodyInit>, // See XMLHttpequest.webdil
44 |   scroll_position: Option<Point2D<f32>>,
45 |   scroll_restoration_mode: ScrollRestoration, // See History.webid. Auto by default
46 |   js_state_object: Option<JSObject>, // window.history.pushState & co
47 |   form_data: Option<Vec<FormDataEntry>>,
48 | 
49 |   // FIXME: I don't understand why the referrer policy should be
50 |   // part of the LoadData, it's present in Servo's LoadData, and
51 |   // also in Gecko's session restore code.
52 |   // The LoadData is supposed to be filled according to the referrer
53 |   // policy, so there's no need for it.
54 |   referrer_policy: ReferrerPolicy, // See Request.webidl
55 | 
56 |   // FIXME: how do we save the state of the content blockers?
57 |   // FIXME: Gecko also store user styles
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/servo_traits/browser/multimedia.rs:
--------------------------------------------------------------------------------
 1 | // Basic audio/video management.
 2 | // We want to be able to mute/pause a tab
 3 | // Implemented by Browser
 4 | // See MediaFlags in http://electron.atom.io/docs/api/web-contents/#event-context-menu
 5 | 
 6 | pub enum MediaType {
 7 |     Audio, Video, Plugin
 8 | }
 9 | 
10 | pub struct MediaState {
11 |     in_error: bool, // Whether the media element has crashed.
12 |     is_paused: bool, // Whether the media element is paused.
13 |     is_muted: bool, // Whether the media element is muted.
14 |     has_audio: bool, // Whether the media element has audio.
15 |     is_looping: bool, // Whether the media element is looping.
16 |     is_controls_visible: bool, // Whether the media element’s controls are visible.
17 |     can_rotate: bool, // Whether the media element can be rotated.
18 |     can_toggle_controls: bool, // Whether the media element’s controls are toggleable.
19 | }
20 | 
21 | pub trait Media {
22 |     fn get_type(&self) -> MediaType;
23 |     fn get_state(&self) -> MediaState;
24 |     fn mute(&self);
25 |     fn unmute(&self);
26 |     fn play(&self);
27 |     fn pause(&self);
28 |     fn toggle_controls(&self);
29 | }
30 | 
31 | pub trait MultimediaManager {
32 |     fn get_all_media(&self) -> Vec<Media>,
33 |     fn get_media_from_point(&self) -> Option<Media>;
34 | }
35 | 
36 | pub trait MultimediaManagerHander {
37 |     fn media_state_changed(&self, media: &Media);
38 | }
39 | 


--------------------------------------------------------------------------------
/servo_traits/browser/printable.rs:
--------------------------------------------------------------------------------
 1 | pub enum PrintMarginsType {
 2 |     Default,
 3 |     NoMargin,
 4 |     MinimumMargin,
 5 | }
 6 | 
 7 | pub enum PrintPageSize {
 8 |     Custom(Size2D<f32>),
 9 |     A3,
10 |     A4,
11 |     A5,
12 |     Legal,
13 |     Letter,
14 |     Tabloid,
15 | }
16 | 
17 | pub enum PrintOrientation {
18 |     Landscape,
19 |     Portrait,
20 | }
21 | 
22 | pub struct PrintOptions {
23 |     margin_type: MarginsType,
24 |     page_size: PrintPageSize,
25 |     orientation: PrintOrientation,
26 |     print_background: bool,
27 |     print_selection_only: bool,
28 | }
29 | 
30 | // Implemented by Browser, or maybe Document
31 | pub trait Printable {
32 |     fn printPage(&self, options: PrintOptions) -> impl Future<Item=(),Error=()>;
33 |     fn printPageToPDF(&self, options: PrintOptions) -> impl Future<Item=(),Error=()>;
34 | }
35 | 


--------------------------------------------------------------------------------
/servo_traits/browser/security.rs:
--------------------------------------------------------------------------------
 1 | pub struct ConnectionSecurity {
 2 |   // Note: Tracking and content blocking has been removed from this interface.
 3 |     certificate_info: Option<CertificateInfo>,
 4 |     state: ConnectionSecurityState,
 5 |   // Organization name has been verified, not just the domain.
 6 |   // Marks the difference from a green lock and a green lock + org name.
 7 |     is_extended_validation: bool,
 8 | };
 9 | 
10 | pub enum ConnectionSecurityState {
11 |   // indicates that the data corresponding to the request was
12 |   // received over an insecure channel.
13 |   Insecure,
14 |   // indicates an unknown security state.  This may mean that
15 |   // the request is being loaded as part of a page in which some
16 |   // content was received over an insecure channel.
17 |   Broken,
18 |   // indicates that the data corresponding to the request was
19 |   // received over a secure channel.
20 |   Secure,
21 | };
22 | 
23 | pub struct CertificateInfo {
24 |   common_name: String;
25 |   organization: String;
26 |   organizational_unit: String;
27 |   issuer_common_name: String;
28 |   issuer_organization: String;
29 |   issuer_organization_unit: String;
30 |   sha256_fingerprint: String;
31 |   sha1_fingerprint: String;
32 |   valid_not_before_local_day: String;
33 |   valid_not_after_local_day: String;
34 | };
35 | 
36 | 


--------------------------------------------------------------------------------
/servo_traits/browser/session.rs:
--------------------------------------------------------------------------------
 1 | // A page is part of a Browser which is part of a Session.
 2 | // 
 3 | // A session is:
 4 | // - SessionData (all info shared across tabs). Session's SessionData are (de)serializable.
 5 | // - A list of list of list of LoadData (multiple history entries, for multiple tabs, for multiple windows). LoadData are (de)serializable.
 6 | // - The state of the app (which window is active, which tab is foreground, …). Up to the embedder to save and restore that state.
 7 | // Storing and restoring a session require saving these 3 states are regular intervals,
 8 | // and recover them on launch. All up to the embedder.
 9 | // Embedder should save the session on:
10 | // - SessionHandler::invalidated
11 | // - BrowserHandler::current_entry_index_changed
12 | // - BrowserHandler::history_entry_changed
13 | 
14 | 
15 | enum StorageType {
16 |   All,
17 |   AppCache,
18 |   Cookies,
19 |   FileSystem,
20 |   Indexedb,
21 |   LocalStorage,
22 |   ServiceWorkers,
23 | }
24 | 
25 | #[derive(Deserialize, Serialize)]
26 | pub struct SessionData {
27 |     private: bool,
28 |     content_blockers: Vec<SessionContentBlocker>,
29 |     http_cache_directory: String,
30 |     storage_data_directory: String,
31 |     // FIXME: any persistent data
32 | }
33 | 
34 | pub trait Session {
35 |     fn new(handler: &SessionHandler, data: Option<SessionData>) -> Session;
36 |     fn get_session_data(&self) -> SessionData;
37 |     fn clear_http_cache(&self, origin: String); // "*" will clear data for all origins
38 |     fn clear_storage_data(&self, origin: String, type_: StorageType);
39 | }
40 | 
41 | pub trait SessionHandler {
42 |     // This will probably be throttled by the engine.
43 |     // Might be a good time to save the session data.
44 |     fn invalidated(&self);
45 | 
46 |     // In the cahse of http cache and storage data, we probably
47 |     // want to let Servo do the IO.
48 |     fn get_http_cache_directory(&self);
49 |     fn get_storage_data_directory(&self);
50 | }
51 | 


--------------------------------------------------------------------------------
/servo_traits/compositor/browserview.rs:
--------------------------------------------------------------------------------
 1 | pub struct CompositeAndTransform {
 2 |     composite: CompositeKind,
 3 |     transform: Matrix4D<f32>,
 4 | }
 5 | 
 6 | pub trait BrowserView: View {
 7 |     fn get_id(&self) -> BrowserViewID;
 8 | 
 9 |     // Not displayed if not visible.
10 |     // Skipped by get_browserview_from_point if not visible
11 |     fn set_visibility(&self, visible: bool);
12 |     fn get_visibility(&self) -> bool;
13 | 
14 |     fn get_content_frame(&self) -> ContentFrame;
15 | 
16 |     // None if no content
17 |     fn get_content_size(&self, ) -> Option<Size2D<f32>>;
18 | 
19 |     fn set_overscroll_options(&self, options: PageOverscrollOptions);
20 | 
21 |     // We want to dissociate clipping area and content boundaries.
22 |     //
23 |     // Content coordinate are defined by content_frame. The region between the outer
24 |     // frame and the content frame is still painted (layers are clipped by outer
25 |     // frame). A position:fixed;top:0; element sticks to the content frame.
26 |     // 
27 |     // Use cases:
28 |     // - pinch to zoom. content_frame keeps the same ratio. pixel_ratio changes.
29 |     // - having a half transparent toolbar in the chrome.
30 |     //   outer_frame height: 600px, toolbar height: 100px, content_frame height: 500px
31 |     //   content_frame vertical position: 100px.
32 |     //   The toolbar covers the outer frame. Page's background are visible through the
33 |     //   the toolbar.
34 |     //   When the user scrolls up 10px, the outer_frame doesn't change, the toolbar
35 |     //   height is set to 90px, the content_frame is height is set to 510px, vertical
36 |     //   position set to 90px. Any position:fixed;bottom:0; elements still stick to
37 |     //   the bottom of the content frame.
38 |     //
39 |     // When the content frame is move or resized, the top left corner of the page sticks
40 |     // to the top left corner of the content frame. It's possible to compensate the translation
41 |     // of the content with scroll_offset, making it so the content appears to not move
42 |     // relatively to the native display.
43 |     //
44 |     // The content will be resized and/or scrolled. DOM events are sent only once
45 |     // resize_and_scroll_browsers is called.
46 | 
47 |     fn set_content_frame(&self, content_frame: ContentFrame, Option<Animation>) -> impl Future<Item = ContentFrame>;
48 | 
49 |     // Will reflow and send resize and scroll events to document
50 |     fn resize_and_scroll_browsers(&self);
51 | 
52 |     // The embedder, at the compositor level, might want to move an element of the page without
53 |     // a roundtrip to the pipeline. This will provide a reference to the stacking context linked
54 |     // to an element.
55 |     // This is useful for example in the scenario describe in the above comment, where a toolbar
56 |     // can be moved at the same time as a content frame. Both in 2 different browserviews.
57 |     // It is important for these 2 operations to be totally in sync.
58 |     // FIXME: eventually, the stacking context will be destroyed. We should be notified of that.
59 |     // FIXME: This is poorly designed. idealy, we could use the Houdini API.
60 |     fn get_stacking_context_id_for(&self, document: DocumentID, selector: String) -> impl Future<Item=StackingContextID,Error=()>;
61 |     fn set_composite_and_transform(&self, id: StackingContextID, transform: CompositeAndTransform, Option<Animation>) -> Result<(),()>;
62 |     fn get_composite_and_transform(&self, id: StackingContextID) -> Result<CompositeAndTransform,()>;
63 | }
64 | 


--------------------------------------------------------------------------------
/servo_traits/compositor/compositor.rs:
--------------------------------------------------------------------------------
 1 | pub struct PageOverscrollOptions {
 2 |     top: OverscrollOptions,
 3 |     right: OverscrollOptions,
 4 |     bottom: OverscrollOptions,
 5 |     left: OverscrollOptions,
 6 | }
 7 | 
 8 | pub enum OverscrollOptions {
 9 |     Enabled(OverscrollDetails),
10 |     Disabled,
11 | }
12 | 
13 | pub struct OverscrollDetails {
14 |   minPanDistanceRatio: f32,
15 |   springFiction: f32,
16 |   springStiffness: f32,
17 |   stopDistanceThreshold: f32,
18 |   stopVelocityThreshold: f32,
19 | }
20 | 
21 | pub struct Animation {
22 |     duration: Time,
23 |     timing_function: TransitionTimingFunction,
24 | }
25 | 
26 | pub struct ViewFrame {
27 |     viewport: glViewport, // http://docs.gl/gl3/glViewport
28 |     z_index: i32,
29 |     background_color: Color,
30 |     opacity: f32,
31 | }
32 | 
33 | pub struct ContentFrame {
34 |     // Content frame is screen_rect here:
35 |     // https://github.com/servo/webrender/blob/00a8818d97aa651ac4670ad85c429729c2046e9d/webrender/src/tiling.rs#L2041
36 |     coordinates: Rect<f32>,
37 |     pixel_ratio: f32,
38 |     scroll_position: Point2D<f32>,
39 | }
40 | 
41 | pub trait View {
42 |     // glViewport is set here:
43 |     // https://github.com/servo/webrender/blob/00a8818d97aa651ac4670ad85c429729c2046e9d/webrender/src/device.rs#L894
44 |     fn get_frame(&self) -> ViewFrame;
45 |     fn set_frame(&self, frame: ViewFrame, animation: Option<Animation>);
46 |     fn is_under_point(&self, point: Point2D<u32>) -> bool;
47 | }
48 | 
49 | pub trait Compositor {
50 |     // One per native window
51 |     fn new(drawable: &Drawable) -> Compositor;
52 |     fn get_id(&self) -> CompositorID;
53 |     fn invalidate_frame(&self);
54 |     fn new_browserview(&self, outer_frame: ViewFrame, content_frame: ContentFrame) -> BrowserView;
55 |     fn get_browserviews(&self) -> Iterator<BrowserView>;
56 |     fn get_browserviews_from_point(&self, Point2D<f32>) -> Iterator<Item = BrowserView>;
57 |     fn new_documentview(&self, frame:  ViewFrame, document: DocumentID) -> DocumentView;
58 | }
59 | 
60 | pub trait DocumentView : View {
61 |     // preview any document (even frozen pipelines) and mirror
62 |     // anything happening in that pipeline.
63 |     // This view doesn't contrain the geometry of the pipeline in any way.
64 |     // It's possible to render a pipeline multiple times.
65 |     // This is usually used to preview a frozen pipeline from history.
66 |     // 
67 |     // No method?
68 | }
69 | 
70 | pub trait Drawable {
71 |     fn get_gl_context(&self) -> GlContext;
72 |     fn get_frame(&self) -> Rect<i32>;
73 |     fn get_hidpi_factor(&self) -> f32;
74 |     fn set_cursor(&self, cursor: Cursor);
75 | }
76 | 


--------------------------------------------------------------------------------