In our last blog (wow, it’s already been almost a month!) we mentioned a sEcReT bLoG pOsT!
Here is our series on implementing the new Doge API for those are interested in contributing to Servo!:
Part 1: How to implement a new DOM API for Servo
Part 2: How to test a DOM API for Servo
Yesterday we gave a talk about our summer at Donut.js! It was a lot of fun talking about Servo to a crowd of mostly(?) web developers. More info about this to come….
Today is the last day of RGSoC. We are incredibly sad, and proud of our summer!
A couple failing tests and their reasons:
assert_equals: response type is basic expected "basic" but got "default"FetchMetadata will need to be changed.assert_equals: Content-Type is text/html; charset=utf-8 expected "text/html;charset=utf-8" but got "text/html; charset=utf-8"There’s a lot of debate what to do with a space.
We’re having our end of summer party. We’re going to see thousands of swift birds fly into a chimney for the night! So excited.
fetch/api/basic tests. >90% of failing tests were due to fetch is not defined. The remaining two failures were due to assert_equals: Request.text() should decode data as UTF-8 and assert_equals: Response.text() should decode data as UTF-8 expected. In the afternoon fetch got merged into master, so I retested response and basic at that point….now there is a lot of assert_equals: Request.text() should decode data as UTF-8 expected and assert_equals: Response's type is basic expected "basic" but got "default". Started trying to figure out what’s wrong with body’s text() Looked into request/request-consume.html and /basic/text-utf8.html….not sure how to fix!
Our goodbye-blog post was published on the RGSoC blog! spoiler: fetch demo! :O
Also, we had our very last team-wide video call! Boo hoo! Everyone (almost) teared up!
Tonight we’re going to Papers We Love PDX tonight!
fetch/api/basic!!
Json() method.Promise<any> instead of Promise<JSON>.formdata::read_formdata requires a reader, and I’m not entirely sure how we can use this parser without stream or HttpReader.
We started thinking about what to do after this Friday when the summer of code is over…fn foo(object: &Trait) (this is trait object) and fn foo<T: Trait>(object: &T). The former will result in the compiler generating less code, so the compile time will be faster. However, this puts a little more strain during run time, because it will have to check whether the parameter object implements the &Trait. The latter generates more code during compilation because it will create unique functions for each type that implements Trait. This saves time during run time because the functions for each type is already defined. As Josh said “classic tradeoff between time and space!”
cors/ and redirect/ seemed to fail intermittently, so we decided to skip those tests for now.git cherry-pick is sometimes easier than git rebase
git clean -f -d gets rid of untracked files and directories. I used this today right before a git reset.WebIDL.WebIDLError: error: Unresolved type '<unresolved scope>::JSON'
FormData() when MIMEType is “multipart/form-data”
body.rs and pulled out consume_body and run_package_data_algorithm into it, and created a BodyTrait. The project was oddly compiling without complaints for most of the day. I mentioned this to Jeena, who reminded me that I have to list new dom files it in dom/mod.rs……haha. :) I did, and then all my bugs were then revealed upon the next compile. :Pnet_traits had changed! So I had to modify the process_response() method to accomodate the changes. It is more secure now as it allows the fetched data to be filtered. Filter exists to protect sites from having their data stolen by other sites.
) Json(), Blob(), and part of FormData().pub enum Animal {
Cat,
Dog,
}
pub enum HavePet {
No,
Yes {
animal: Animal,
how_many: i32,
}
}
let me = HavePet::Yes {
animal: Animal::Dog,
how_many: 1,
};This match statement won’t work!
match me {
HavePet::No => println!("I wish I had a pet!"),
HavePet::Yes => println!("I have a pet!"),
}The compiler will say that:
error: `HavePet::Yes` does not name a tuple variant or a tuple struct [--explain E0164]
--> <anon>:22:5
|>
22 |> HavePet::Yes => println!("I have a pet!"),
|> ^^^^^^^^^^^^The correct way to write the match statement is:
match me {
HavePet::No => println!("I wish I had a pet!"),
HavePet::Yes {
animal: Animal::Dog,
how_many: _,
} => println!("I have dog(s)!"),
HavePet::Yes {
animal: Animal::Cat,
how_many: _,
} => println!("I have cat(s)!"),
}Link to play-rust is here. Or even simpler:
match me {
HavePet::No => println!("I wish I had a pet!"),
HavePet::Yes { animal, .. } => match animal {
Animal::Dog => println!("I have dog(s)!"),
Animal::Cat => println!("I have cat(s)!"),
}
}Link to play-rust is here. There is a github issue open for rust-lang to print out more helpful hints about this matter.
Blob() and FormData(). Then work on Body for Request.FormData() when MIMEType is “multipart/form-data”.
consume_body and making it into a public function. That way, it can be called by both Request and Response. At this moment, consume_body is customized for Response specifically, and it will be redundant to do the write the same function for Request.
text() function to the point that it compiles, but additional tests are not passing. I keep getting the same error Promise is not defined in testharness.js.T doesn’t derive clone, or has a clone implementation, the compiler makes another reference when .clone() is called to a &T, ending up with &&T. When .clone() is called, the compiler derefs &T to T, realizes T cannot be cloned, and so it creates a clone to the reference, hence creating a double reference.
Today is our first day back from Strange Loop…more about that in the next couple days! P.S. It was really cool!
text()) prior to a PR.
Today, we were on our way to St. Louis, MO for StrangeLoop!!!!! We are super excited :D
Day 50! Today was a good day. We listened to our mentor Josh give a great talk about Optimizing your project for contribution. As mentees, we really appreciate all the work that’s put into making Servo accessible to beginners.
JSCompartment::wrap had a parameter with a null pointer, which was the reason Servo was crashing. Josh recommended looking at dom/testbinding.rs to see how JSAutoCompartment is used, and to copy it in fetch.rs. After a little bit of wrestling with fetch.rs (because I mistakenly looked at the wrong code), fetch, at least for now, works!
promise didn’t enter any compartment, because JSAutoCompartment::new() wasn’t called. promise had not entered any compartment, and therefore, when SpiderMonkey (JS Engine) called JSCompartment::wrap(), which would take a JSContext to the compartment of a JSObject, a null pointer was given. Apparently in order to enter a compartment, JSContext has to already have entered a compartment. And that’s why Servo crashed!JSAutoCompartment::new() is called. In a browser, one tab (one window) will have at least one compartment. Two tabs will have at least two compartments. Compartment is important for security, because there can be little cross-over that will be strictly controlled. You wouldn’t want data jumping back and forth between different compartments.Ran 104 tests finished in 100.0 seconds.
- 53 ran as expected. 0 tests skipped.
- 2 tests crashed unexpectedly
- 4 tests timed out unexpectedly
- 48 tests had unexpected subtest results
We went to RustConf last Saturday, and it was AWESOME.
Malisa is sick 
and focused on getting better 
Rc<Promise> with Trusted didn’t work. Over the weekend Josh pushed another commit to enable Trusted<Promise> and TrustedPromise::root() that will return a Rc<Promise>. On Sunday, I encountered two borrow check errors:
&mut self as a parameter (not mut self). When I try to get the root of TrustedPromise, it throws an error saying “cannot move out of borrowed content”. lines 122, 124, 136, and 138
root() of TrustedPromise requires self parameter. In line 101, with let context = fetch_context.lock().unwrap(); which is type MutexGuard, which derefs to &T. When we try to access the Rc<Promise> via context.fetch_promise.root(), the compiler throws a borrow error.
. I started debugging (which means, me = stressed out) and learned a few things:
metadata that is used for process_response looks good. It’s Ok(_) and has the fields that look not incorrect.self.fetch_promise.take(), no other line is called… WEIRD. WHY. Well, luckily, I was working at the Mozilla Office, and three(!) people helped me debug. Special thanks to @sanxiyn, @fitzgen, and @jimblandy.frame #6 is called before frame #5.frame #6 shows that to_jsval was called. This in turn calls JS_WrapValue in frame #5. This in turn calls JSCompartment::wrap in frame #4.JSCompartment::wrap is a C++ code in SpiderMonkey, a JavaScript engine. JSCompartment::wrap has a parameter that is this=&0x0. 0x0 is a null pointer!!! We have a memory-unsafety here!!! Woohoo!. after an object, it automatically derefs! For example, if I do fetch_context.lock(), I’m derefing fetch_context then applying the lock() method.0x0 is the synonym to null pointer in C++! If your stack backtrace includes 0x0 that’s probably not something you wanted :)--debug tag, i.e. ./mach run -d ~/src/fetch_example.html --debug. Servo uses lldb debugger by default.rust_panic function, you can write b rust_panic <ENTER> run.bt which will print all the backtrace! COOL.Rc and Trusted has to maintain a 1:1 relationship, and therefore, Trusted should not have a &self parameter because that could break that 1:1 constraint. In Servo’s promise, Rc counts the references, and therefore TrustedPromise has to be connected to the one and only Rc<Promise>, because otherwise, the reference count will be incorrect.
process_response method. I think the remaining relevant FetchResponseListener methods are process_response_eof (invoked when fetching response is complete) and process_response_chunk (invoked when fetching response body). But process_response_eof requires response trailer support, which is not implemented, and process_response_chunk can probably wait until the response body is implemented.Promise::maybe_resolve_native() and the like, it needs a JS Context parameter. JS Context can be obtained through self.global().r().get_cx(). JSContext is a context in which JS can be invoked, and is required by APIs that interact with the JS engine (or it can use a JSRuntime argument). It’s confusing to me, but for now, I’ll just think of it as a connector to the JS world! (probably not 100% accurate).vec.drain(..3); removes the first 3 elements of a vec.
. Special thanks to Scott for the pep talk! Also, we picked and ate figs from the fig tree by Jeena’s home as a break 
.FetchResponseListener. FetchResponseListener is invoked when (I think) the network level fetch gets some data back. For example, a method in FetchResponseListener is process_response, which will update the response object with the data it got back from fetching.FetchContext) has to be Arc<Mutex<T>>. Inside FetchContext, there will be response_object with type Response and promise with type Rc<Promise>. Both response_object and promise will need to be wrapped with Trusted to be shared across threads safely. Trusted is a “safe wrapper around a raw pointer to a DOM object”, so response_object and promise can be Trusted<Response> and Trusted<Promise>.response_object should be wrapped wtih DOMRefCell to allow inner mutability, but we shall see. If this is true, response_object will be DOMRefCell<Trusted<Response>>..? Josh said that since FetchResponseListener will be implemented on FetchContext, calling self.response_object.root() will obtain a Root<Response> value in the callbacks that can be manipulated like usual.promise is Rc<T> so we will need a method that will pull out Rc<T> from Trusted<T>, like self.response_object.root() would.& mut or for mutex lock() and unlock(). What makes Mutex special? It is specifically designed for sharing across threads (often used in conjunction with Arc), whereas regular mutable borrow is not. So, only one thread can safely access the same data at one time. On the other hand, regular-ol’-& mut will not be allowed by the borrow checker if you try to use it across threads.Rc<T> is not thread-safe, but Trusted<T> is, like in Trusted<XMLHttpRequest>.maybe_reject_error, etc.)
What I get is that there needs to be an object (probably FetchContext) that will hold the intermediate Response, and communicate with Promise to get the status of fetch. Hopefully tomorrow will be different!
Yesterday was Labor Day, so we celebrated it by not working! Woohoo! Malisa is traveling back today, so I (Jeena) worked alone today.
The rust compiler still panics instead of throwing error as it uses the older rust version, but that’s ok! I can work around it.fetch so I spent the day trying to understand what I need to do. Roughly, there are two things I can do:
fetch. Promise::maybe_resolve_native is probably a better choice than Promise::maybe_resolve because they take regular DOM objects. This seems partially dependent on the next thing.FetchResponseListener in fetch.rs. This turns out to have a lot more pre-requisite infrastructure! fetch.rs needs a FetchContext struct that will store the intermediate fetch. XMLHttpRequest is done very similarly to fetch, so I should look into how XHR is implemented in Servo. How XHR implements FetchResponseListener is here.
XMLHttpRequest interacts with resource thread and XHRContext
FetchContext structImpl FetchResponseListener for FetchContext (may require helper functions)
Fetch.webidl and window.rs/workerglobalscope.rs state that fetch() returns a void, and fetch() does return a void, it compiles.Fetch.webidl and window.rs/workerglobalscope.rs state that fetch() returns a void, but fetch() returns Promise, it compiles. This is strange because the compiler should throw a type mismatch error.Fetch.webidl or window.rs/workerglobalscope.rs state that fetch() returns a Promise, and fetch()does return Promise, compiler fails with this error.jdm:promises on top of the latest servo:master, a lot of conflicts happen and I’m not sure how to resolve them as I’m unfamiliar with the changes. I tried a few approaches (not really organized…) and they all have failed
Waiting for merge/squash time!pub body: Option<Option<UnionTypes::BlobOrFormDataOrStringOrURLSearchParams >> (thanks Jeena! :D)get and getAll functions!
internal_response, now that there is no longer a net_traits::Response in dom::Response.h = new Headers
> Headers { }
h.append("foo", "bar")
> undefined
h.get("foo")
> "bar"
Fetch.webidl states that it returns a void (not Promise), the code compiles! I’ll keep building on top of it…1 absolutely not work-related
Promise.-idl.html test file that are currently timing out. I’m not exactly sure what they do, but it looks like once webidls are fully implemented, these tests will pass.readableStreamfail. I’m not sure if stream is something we can implement or is already implemented. Will have to ask someone knows more about this.extract method.for ... of loops and for ... in loops. E.g.
for x in foo is the same as in JS, for (x of foo). In this case, x is the object you ultimately want to view or manipulate.for x in foo.keys() is the same as in JS, for (x in foo). In this case, x is the key to the dictionary you might what to iterate over.extract as well as I can w/o ReadableStream
move, clone, and copy!Promise in fetch(). Strangely, it’s causing the Rust compiler panics unexpectedly. I’m not sure how to move forward…let hello = b"hello";, an array is created. An array has a static length. So in our Headers code, we ended up making unnecessary transformations here. We wrote combined_value.push(b","[0]); which means, “create an array that has length of 1, and whose only element is a comma byte. Then, take the first element of it and add that to combined_value. We can improve this line by writing combined_value.push(b',');
net_traits).fetch() on top of jdm’s branch
Like this!
WindowOrWorkerGlobalScope.webidl which is a newer addition to the spec and was not present in Servo. I had to add it to Servo, and WindowOrWorkerGlobalScope is not a interface object, so no bindings were created. The compiler told me that dom/window.rs and dom/workerglobalscope.rs had to implement Fetch(). So what we decided to do is have a script/fetch.rs where the Fetch method will live, and have dom/window.rs and dom/workerglobalscope.rs delegate the Fetch method to script/fetch.rs.RawStatus (which takes a utf-8 encoded Cow-str) in Servo’s codebase with (u16, Vec<u8>), which is not UTF-8-dependent. I spent the whole day re-building and finding new places in the codebase which were affected by this change, fixing, and re-building again! Finally the relevant test is passing though :)net/fetch/method.rs. Figure out how to wrap script/fetch.rs around net/fetch.
Vec<Vec<u8>> in which the inner vector is one header value. Not sure how this will mesh with hyper::header::Header existing methods. (Or, how do I separate the different header values? Will the comma have to be added as a separate vector?)
git checkout remote-name/branch /path/to/file
WindowOrWorkerGlobalScope which is not implemented yet. Hear what Josh has to say, and do that!
net_traits::CoreResourceMsg. The resource thread calls the actual HttpRequest. The response is sent back to the script thread and the original Promise is resolved. Yay! This is just a broad overview…fetch. Decided to start working on fetch (one of jdm’s suggestions). He wrote:
“Start working on the actual fetch() API, focusing on the code that deals with the arguments and initiating the request and ignoring the return value for now.” At this moment, I won’t have to worry about Promise because “there’s enough work that goes into dealing with the arguments to the function and initiating the request that the promise-related bits can be done separately and subsequently.”
We both enjoyed our long weekends. It featured swimming, the Seattle Opera, a movie triathlon, air conditioning, and Thai food. We feel energized for the second half of RGSoC!
Type, Url, Redirected, Status, Ok, and StatusText.ref and & in a match statement, which helped me understand those concepts a little more. (Malisa)GlobalRef
mime crate.Error and Redirect.ResultsGlobalRef
promise to get merged in).mime and see if I can use it for the PR I opened today.
content-type header namehyper::header::Headers objects, and the nuances of implementing for Servo (for now).hyper::header::Headers in dom::Headers…Rc or Arc types, which are for sharing within a process).
This is a cross post from Jeena's blog.
My friend Malisa and I have been hacking on Servo this summer. We started from scratch, with no experience writing Rust, let alone compiled langauges. It's been challenging and fun! One of the trickier Rust concepts to understand for me was Rust's references and borrowing.
Ownership in Rust is in many ways like owning a coloring book. You can have all your friends come look at it together and flip through the pages. However, they can't color in it. This is an immutable borrow in Rust lingo.
But say you actually want to create a collective art piece with the coloring book. You can lend it to one friend at a time and tell them they can color however they want, or mutably borrow in Rust lingo. They have to give the book back to you when they're done, and you may lend it to the next friend, and so on0. If you tried to let two friends color at the same time, they can end up fighting to color the same spot.
These are the two rules of Rust's borrow system:
In both cases, if the lender wants to color the book, then they must get it back from the borrowers first. How else would you color a book you don't have in your hands?!
I've found that making the compilation fail, and then reading the compiler's detailed messages is a great way to learn these new concepts. Steve Klabnik, the author of "The Book", wrote an awesome introduction to Rust's borrow system, so let's mess with one of its examples, break things, and learn!
Let's start with something simple that compiles:
fn main() {
let mut x = 5;
let mut y = x;
y += 1;
println!("x is: {}", x);
println!("y is: {}", y);
}warning: variable does not need to be mutable, #[warn(unused_mut)] on by default
--> <anon>:2:9
2 |> let mut x = 5;
|> ^^^^^
x is: 5
y is: 6
The compiler helpfully warns that x didn't have to be
mutable. But why? It's because y ends up being a separate
copy of 5, and x is never modified in the
code. You can tell that x and y are two
different things in the memory, because the printed values are
different.
What if we didn't want to copy x into y,
and wanted changes to y to apply to x?
fn main() {
let mut x = 5;
let mut y = &x;
*y += 1;
println!("y is: {}", y);
}error: cannot assign to immutable borrowed content `*y`
--> <anon>:5:5
5 |> *y += 1;
|> ^^^^^^^
error: aborting due to previous error What happened? This time, y is not a copy
of x. Instead, y is a reference
to x, and therefore, it had to be dereferenced
before 1 is added to y. One important thing to note is
that y is an immutable reference, even
though y itself is mutable! That is why the compilation
fails. y didn't have the permission to change the value,
yet it tried to do so anyways.
Now that we know what's going on, let's fix this code and make the compiler happy again!
fn main() {
let mut x = 5;
let mut y = &mut x;
*y += 1;
println!("y is: {}", y);
}y is: 6
y takes a mutable borrow of x, and it
can change x's value. So when we print y it
successfully prints 6.
What happens if we try to print x instead? This
brings us
to one
of the Book's examples.
fn main() {
let mut x = 5;
let mut y = &mut x;
*y += 1;
println!("x is: {}", x);
}error: cannot borrow `x` as immutable because it is also borrowed as mutable [--explain E0502]
--> <anon>:7:26
3 |> let mut y = &mut x;
|> - mutable borrow occurs here
...
7 |> println!("x is: {}", x);
|> ^ immutable borrow occurs here
8 |> }
|> - mutable borrow ends here
<std macros>:2:27: 2:58: note: in this expansion of format_args!
<std macros>:3:1: 3:54: note: in this expansion of print! (defined in <std macros>)
<anon>:7:5: 7:29: note: in this expansion of println! (defined in <std macros>)
error: aborting due to previous errorCompilation
fails! The compiler gives a pretty good explanation. It says that
println! cannot immutably borrow x
because x is already mutably borrowed
by y. This violates the first rule of Rust's borrow
system: when something is mutably borrowed, there cannot be other
borrows.
The Book shows a way to correct this code by using curly brackets to introduce a nested scope.
fn main() {
let mut x = 5;
{
let y = &mut x;
*y += 1;
}
println!("x is: {}", x);
}x is: 6The Book does a better job in explaining scopes than I can, so I highly recommend reading the Book about this section.
Let's break this code one last time.
fn main() {
let mut x = 5;
{
let y = &mut x;
*y += 1;
}
println!("y is: {}", y);
}error: unresolved name `y`. Did you mean `x`? [--explain E0425]
--> <anon>:7:26
7 |> println!("y is: {}", y);
|> ^
<std macros>:2:27: 2:58: note: in this expansion of format_args!
<std macros>:3:1: 3:54: note: in this expansion of print! (defined in <std macros>)
<anon>:7:5: 7:29: note: in this expansion of println! (defined in <std macros>)
error: aborting due to previous errorThe compiler lets us know that y does not exist. This is
because y is defined inside the inner scope delineated by the pair of curly brackets, and outside
of them, y doesn't exist! Introducing inner scopes gets very handy
when you want to define things only temporarily.
The Rust compiler does a great job of pointing out possible sources of error in the code. Compilation errors are not scary, and they're in fact a great conversation starter with the compiler. Try introducing different kinds of errors, and see how the compiler responds. From these conversations, I find myself learning new concepts that I didn't know before, and writing better code over time.
Now you should go break some code! Thanks for reading!
Special thanks to Nick Fitzgerald and Malisa Smith for providing feedback on drafts.
0 Or maybe you'll give the book to your friend forever, in which case you're giving away your ownership, but we won't cover that concept in this blog post.
hyper::header::Headers in Rc. This solution may or may not work for the Response API, however, because Rc doesn’t work across threads. Instead of manipulating the same object in multiple places, I might end up having to just work with one version of hyper::header::Headers, or replace Rc with Arc.Rc PR, and then finally work on dom::Response
net_traits::response::Response’s headers (hyper::headers) with Rc and RefCell.clone for net_traits::response::Response and dealt with side-effects of using internal Rc types… x_Xrequest.rs in the comments.Parentheses are useful! Long story short, wrapping parentheses around (*gadget1.owner) applies the deref * to just gadget1.owner, which is just what I needed. :)
Reflog is what git uses to keep track of updates to the tip of branches, including those that are invisible on git log! This acts as a great safety net. For example, if you want to undo git rebase, you can find the HEAD of pre-rebase, and git reset --hard to that HEAD.
You cannot modify a field that is in a borrowed context. This is a sample code.
fn Referrer(&self) -> USVString {
let r = self.request.borrow();
let referrer = r.referer.borrow();
USVString(match &*referrer {
&Referer::NoReferer => String::from("no-referrer"),
&Referer::Client => String::from("client"),
&Referer::RefererUrl(ref u) => {
let u_c = u.clone();
u_c.into_string()
}
})
}r and referrer is that if it’s written into one line (let r_referrer = self.request.borrow().referer.borrow()), it will throw a life time error. See here.match if referrer does not have &*, it will throw a type mismatch error. This is because referrer is a Ref<> type, and it is trying to match against Referer enum.*referrer) so that you can use referrer as a Referer enum type through deref coercions. However, that will be trying to move referrer out of borrowed context.referrer is borrowed object, while dereferencing it: &*referrer
u_c is created because u is a ref. If you were to write u.into_string(), you will be trying to move u out of borrowed context.Rc and RefCell are appearing in places like fetch/methods.rs, uh oh)net_traits::request::Request and dom::headers as well……RefCell in dom::Headers
Response struct.
out of Request, not Headers!How to use reference-counted boxes: Rc<>. They are a way to refer to the same internal object in multiple places. Different from RefCell, which I believe is more of a way to provide mutability of already-borrowed objects.
When debugging a Rust code, you can print the memory address of the object through:
let x = 5;
println!("{:p}", &x);A Fun Debugging Tale
Below is the test that was failing, and I was debugging:
test(function() {
var initialHeaders = new Headers([["Content-Type", "potato"]]);
var initialRequest = new Request("", {"headers" : initialHeaders});
var request = new Request(initialRequest);
assert_equals(request.headers.get("Content-Type"), "potato");
}, "Request should get its content-type from the init request");The test creates an initialRequest with initialHeaders, and creates a request with the initialRequest. Then tries to assert that request has the same Headers as the initialHeaders. For some reason, request’s Headers becomes an empty object, so I was trying to figure out why.
Here is the spec for constructing a Request object. request’s Headers is emptied at Step 29. It gets filled with headers_copy at Step 31. It turns out headers_copy was empty, and therefore at Step 29, the request’s Headers was getting filled with an empty Headers object.
headers_copy is set at Step 28. It states “If init’s headers member is present, set headers to init’s headers member.” It turns out that init’s headers didn’t exist when request was constructed. But it did exist when initialRequest was constructed.
So I had a hunch that maybe it was mixing up init and input. Constructor takes input: RequestInfo and init: &RequestInit. I printed out input.headers, and it was the same as initialHeaders. Once I added another logic in Step 28 to match input to Request and set headers_copy to input.headers, the test passed! I guess it was the cause for a few other tests to fail, so more tests are passing now. 
net_traits::Response and net_traits::Request and dom::headers::Headers to wrap Rc<> around their internal hyper::header::Headers objects. That way they will be clonable into reference-counted boxes.
is_field_content and Append functions in the Headers API. After fixing these, more of the Headers API tests passed! Oops…Headers::Get does not get the correct value.--log-mach /path/to/log/output can be added when running servo tests to see verbose output and println’s, for help in debugging out of Headers.
p_ConstValueByteString function to WebIDL.py and modified CodegenRust.py. Currently dealing with build errors.lex and yacc for string parsing, with the help of Nick.>>> def add(a, b):
... """Adds a to b"""
... return a + b
...
>>> add(1, 2)
3
>>> add.__doc__
'Adds a to b'M-g g, then enter line number. 
Our blog post is published!
new function, and added fill function.Lifetime Error
Say you have a one line of code that is:
let method_string = init_method.clone().to_lower().as_str();If you try to compile it, you may get an error that looks like:
The reason is that to_lower() gives back a String, and as_str() tries to give a reference to that String created by to_lower(). However, that String would not exist anymore because it was consumed by as_str() and therefore, the compiler throws an error saying that the borrowed value doesn’t live long enough.
To fix this issue, the compiler suggests using let binding to increase its life time. In other words, the one line code can be expanded as following:
let method_lower = init_method.to_lower();
let method_string = method_lower.as_str();This way, as_str() can return a reference to the String (method_lower) which would exist in its scope, i.e. between curly brackets.
Similarly, this won’t compile and will throw lifetime errors:
DOMString::from_string(self.request.borrow().integrity_metadata.borrow().clone())Again, it would try to borrow integrity_metadata from self.request which would be transformed to Ref<'_, net_traits::request::Request> after self.request.borrow(). This error can be resolved by expanding the code above to this:
let r = self.request.borrow();
let integrity = r.integrity_metadata.borrow();
DOMString::from_string(integrity.clone())
It’s Malisa’s birthday!
match init.mode.as_ref() {
Some(init_mode) => mode = Some(init_mode.clone().into()),
None => mode = Some(fallback_mode.unwrap()),
}let mode = init.mode.as_ref().map(|m| m.clone().into()).or(fallback_mode);ByteString types, which are basically sequences of 8-bit unsigned integers, and characters or Strings. Many of the specs we have to follow reference these encodings. Knowing hexadecimal representation of characters is also useful.
dom::bindings::js::MutNullableHeap allows lazy construction of objects (they can be initialized only when you need them)cache-control header “directives control who can cache the response, under which conditions, and for how long”.zsh-autosuggestions and zsh-syntax-highlighting. Also Charles for web debugging.obtain_response in methods.rs.obtain_response contains a line req.send(request_body). req is a NetworkHttpRequestFactory whose create method returns a WrappedHttpRequest.send function then calls request.start(), and subsequently request_writer.send().hyper::client::response::Response’s with_message function, which calls HttpMessage’s get_incoming functionget_incoming is a trait. Where is its implementation? We don’t know….
set-cookie header names.&, but you can also have “user-defined custom smart pointers” or wrappers with particular behavior for references, like Ref and RefCell. A helpful explanation is here and here.use hyper and writing hyper::header::Headers throughout the code, you can use use hyper::header::Headers as HyperHeaders and use HyperHeaders in the code body.
dom::bindings::error::{Error, ErrorResult, Fallible} when neededmatch self.header_list.borrow_mut().get_raw(&valid_name) {
Some(v) => Ok(Some(ByteString::new(v[0].clone()))),
None => Ok(None),
}The following code takes advantage of map for Option types.
Ok(self.header_list.borrow().get_raw(&valid_name).map(|v| {
ByteString::new(v[0].clone())
}))set-cookie is the header name.
iterable<ByteString, ByteString> just quite yet.This first version only ever deals with one memory location on the stack
let mut valid_name = something;
valid_name = something_else;This second version instructs Rust to create two memory locations for each valid_name. Only due to the Rust optimizer does the computer realize that it can reuse the same spot.
let valid_name = something;
let valid_name = something_else;RefCell, wrap the content with Ref which can be done through Ref::map.fn get_associated_url(req: &net_traits::request::Request) -> Option<Ref<url::Url>> {
// if into_inner() is used, req is no longer accessible
let url_list = req.url_list.borrow();
if url_list.len() > 0 {
// .first() returns an Option, and therefor needs unwrap()
Some(Ref::map(url_list, |urls| urls.first().unwrap()))
} else {
None
}
}
hyper::header::Headers set_raw() and get_raw() act as though there is only one entry for a given unique header name.append() method or re-write hyper::header::Headers?), piecing together instructions from various specs, and planning the next steps –> Decided to go with the current hyper::header::Headers implementation.append() method and other Header API functions.if let is handy if you want to match for only certain cases. For example, following code snippets are the same.if let RequestOrUSVString::Request(req) = input {
// Do stuff
}
match input {
RequestOrUSVString::Request(req) => // Do stuff,
RequestOrUSVString::USVString(_) => {},
};hyper::header::Headers better.has
get
delete, set, and iterable
get and has
clone()
Clone().has method.get method.has
get
delete, set, and iterable
get and has
Clone methodclone()
Into implementation to allow translation between the two.Into implementation.Into allows Rust to “translate” between two different objects.In a garbage collected language (such as JavaScript and Python, but not Rust), GC manages the memory by freeing it when the memory occupant is no longer in use. Whenever a new object is created, it is done so through GC and GC will add to its set of objects created.
Once in a while, GC will be triggered, probably through the danger of memory running out. GC is expensive, and therefore, it should not be triggered too often. When GC is triggered, it traces memory, checking which objects are referenced, in other words, still in use. Tri-color marking is the one we learned about, and its wikipedia page provides an excellent summary.
Long story short, GC has the ability to compare the sets of objects created and objects that are still used. GC will free the memory occupied by whatever is in the difference.
get and has
Request object and request, and they are different! Request object is exposed to JS. request that is part of Request object is used internally.match (not if).match requires addressing every possible situation, so _ might be necessary.get and has
request in Request
git stash is useful for switching branches on the flyget and has
git rebase -i <remote>/<branch> allows you to squash the commits between the current HEAD and the HEAD of <remote>/<branch>. If you are on local features branch and know that local master is untouched, you can git rebase -i master.get and has
new_inherited method (somewhat related to Reflectors).
new() for our Headers struct.append_the_header method.Append, i.e. putting every helper function together. Wrote if/then logic for going through Append method.DOMRefCell instead of RefCell because DOMRefCell implements JSTraceable. With RefCell, the compiler threw an error saying it requires JSTraceable implementation.RefCell is that it allows interior mutability to immutable borrowed content. The header_list needs to be mutated while auto-generated HeadersBindings.rs will borrow Headers immutably.return can only return from the current function, i.e. you can’t return from an enclosing function in a closure.match doesn’t introduce a new function or closure, so it is fine to return from a match armmatch x {
Ok(value) => y = x,
Err(e) => return Err(e),
}try! is awesome. Below two snippets would do the same thing.try!(something_that_returns_a_result())match something_that_returns_a_result() {
Ok(v) => v,
Err(e) => return Err(e),
}try! without unpacking Ok():let result_of_function = try!(something_that_returns_a_result());'static is either (1) a reference that is valid for the whole program’s runtime, or (2) an owned pointer.Append.
hyper::headers::Headers.
header_list: hyper::header::Headers.#[ignore_heap_size_of = "Defined in hyper"].*ByteString -> [u8]
& creates a slice of a view of some number of elements&(*ByteString) -> &[u8]
&*(&ByteString) -> &[u8]
Cow derefs to str (needs double checking).bytes::Regex::new(r"(\x20|\x09)+?").unwrap().is_match(&u8)ByteString will be a valid input type, so we’ll just keep this knowledge in the back of our mind.new() for our Headers struct.Append.
set.set requires the header name (which is a ByteString) to implement Into<Cow<'static, str>>, we might have to implement it ourselves (impl Into<Cow<'static, str>> for ByteString).
.guard to our Headers struct.enum Guard for guard.Result<>.script is the root directory of our files):
components/script/lib.rs, add extern crate unicase;.components/script/Cargo.toml, add use unicase="1.4.0".Cow automatically handles copy and writing when you have a borrowed immutable reference.C-x ( (define macro) C-x ) C-e (execute macro)String is guaranteed to be UTF8 and is heap-allocated (and therefore growable). &str is a string-slice. dom::bindings::str::ByteString is not guaranteed to be UTF8.Result only returns an error, use Result<(), Error>.&&.#[derive(JSTraceable, HeapSizeOf)].regex supports pattern matching on bytes. Add use regex::bytes to the code.hyper::headers::Headers. Ask jdm!Append method.
Append method for the Headers API, which is validating name and value of the HTTP headers.lib.rs.
for byte in &value[first_index..last_index + 1] {
normalized_value.push(*byte); // dereferencing here
} for &byte in &value[first_index..last_index + 1] { // destructuring here
normalized_value.push(byte);
}
Yesterday we attended the PDX Rust meet-up and saw Andy Grover give a presentation on his project Froyo.
Today we worked at the Portland Mozilla office to program on a really easy Servo issue just to get used to the workflow. With the help of our coach Nick we were able to submit our first pull request, which was accepted. :)
rust-mode, and learned some best practices for using Emacs
#[dom_struct] before our headers.rs struct declaration, and the first field of the struct has to either be a Reflector or the object it inherits
We had a nice long Independence Day weekend and are happy to be back coding on Servo!
./mach clean command in order to clear the “build cache” prior to running ./mach build --dev. Also ./mach bootstrap-rust --force
jeenalee and malisas)
Hello World!
Tomorrow, our summer begins. We will hack on Servo, a web browser engine built with Rust. Our goal of the summer is to implement the JS Fetch API in Servo. We are blessed to have support from our wonderful coaches (Morgan, Nick, and Stefan), mentor (Josh), supervisor (Scott), and of course Rails Girls Summer of Code! Many many thanks to everyone.
Tonight, we learned about the big picture of the Fetch API.