Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-08T21:03:54Z

Jmehta2: /* Test Cases */ updated the passing tests

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() and final_charset()
** final_mime_type() method returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type
** final_charset() method returns the final charset<ref>https://xhr.spec.whatwg.org/#final-charset</ref> depending on override charset and response charset
** We have also determined encoding of text_response by calling the final_charset() helper method. But if final charset is not set (i.e. it is None) then UTF-8 is set as the default encoding. The step 4 mentioned in the [https://xhr.spec.whatwg.org/#text-response text response] documentation in order to add support for XML encoding guess stuff using XML spec was not to be implemented and hence FIXME was added in the code.

* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file.
** The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest.
** If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response. As suggested by the Servo focal for this project, we have not implemented the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs first sub-task] for withCredentials API.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. New methods were created which contain handling for different mime types. A document object is created and its JS value is returned. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>.For mime type text/html if any of the charset is NONE the requirement was to scan the first 1024 bytes of the header to identify the charset, this part has not been implemented in this project. The following new methods were added to file XMLHttprequest.rs as part of this task -
**document_response - This method creates a document as per mime type returned by the final_mime_type() method created as part of OSS project. It internally calls other methods listed below.
**document_text_html - This method creates a document flagged as an HTML document. This method is called by document_response in case the mime type is text/html. It calls the new_doc helper method.
**handle_xml - This method creates a document flagged as a non HTML document. This method is called by document_response in case the mime type subtype is XML. It calls the new_doc helper method.
**new_doc - This method creates a new document which is the final response based on the input received from document_text_response and handle_xml methods.

==Test Cases==
The tests have already been written for the XMLHttpRequest(XHR) APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XHR is in unsent state, then overrideMimeType() is able to enforce Shift-JIS charset encoding (overridemimetype-unsent-state-force-shiftjis.htm)
* If XHR is in open state, then overrideMimeType() is able to enforce UTF-8 charset encoding (overridemimetype-open-state-force-utf-8.htm)
* If XHR with XML MIME type is in open state, then overrideMimeType() is able to enforce UTF-8 charset encoding (overridemimetype-open-state-force-xml.htm)
* If XHR is in HEADERS RECEIVED state, then overrideMimeType() is able to enforce Shift-JIS charset encoding (overridemimetype-headers-received-state-force-shiftjis.htm)
* The various responseXML document properties like title, contentType, doctype, cookie, etc. are correctly initialized (responsexml-document-properties.htm)
* In XHR, parsing of different responseXML MIME type is successful (responsexml-media-type.htm)
* In XHR, parsing of document received from responseXML is successful (send-redirect-no-location.htm, status-async.htm, status-basic.htm)
* In XHR, throw InvalidStateError if response type is not null or document (responsexml-non-document-types.htm)

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-07T00:20:29Z

Jmehta2: /* Implementation Details */ restructuring sub task

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() and final_charset()
** final_mime_type() method returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type
** final_charset() method returns the final charset<ref>https://xhr.spec.whatwg.org/#final-charset</ref> depending on override charset and response charset
** We have also determined encoding of text_response by calling the final_charset() helper method. But if final charset is not set (i.e. it is None) then UTF-8 is set as the default encoding. The step 4 mentioned in the [https://xhr.spec.whatwg.org/#text-response text response] documentation in order to add support for XML encoding guess stuff using XML spec was not to be implemented and hence FIXME was added in the code.

* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file.
** The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest.
** If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response. As suggested by the Servo focal for this project, we have not implemented the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs first sub-task] for withCredentials API.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. New methods were created which contain handling for different mime types. A document object is created and its JS value is returned. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>.For mime type text/html if any of the charset is NONE the requirement was to scan the first 1024 bytes of the header to identify the charset, this part has not been implemented in this project. The following new methods were added to file XMLHttprequest.rs as part of this task -
**document_response - This method creates a document as per mime type returned by the final_mime_type() method created as part of OSS project. It internally calls other methods listed below.
**document_text_html - This method creates a document flagged as an HTML document. This method is called by document_response in case the mime type is text/html. It calls the new_doc helper method.
**handle_xml - This method creates a document flagged as a non HTML document. This method is called by document_response in case the mime type subtype is XML. It calls the new_doc helper method.
**new_doc - This method creates a new document which is the final response based on the input received from document_text_response and handle_xml methods.

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-06T23:55:45Z

Jmehta2: /* Implementation Details */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
*'''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() and final_charset()
**final_mime_type() method returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type
**final_charset() method returns the final charset<ref>https://xhr.spec.whatwg.org/#final-charset</ref> depending on override charset and response charset
**We have also determined encoding of text_response by calling the final_charset() helper method. But if final charset is not set (i.e. it is None) then UTF-8 is set as the default encoding. The step 4 mentioned in the [https://xhr.spec.whatwg.org/#text-response text response] documentation in order to add support for XML encoding guess stuff using XML spec was not to be implemented and hence FIXME was added in the code.

* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest. If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. New methods were created which contain handling for different mime types. A document object is created and its JS value is returned. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>.For mime type text/html if any of the charset is NONE the requirement was to scan the first 1024 bytes of the header to identify the charset, this part has not been implemented in this project. The following new methods were added to file XMLHttprequest.rs as part of this task -
**document_response - This method creates a document as per mime type returned by the final_mime_type() method created as part of OSS project. It internally calls other methods listed below.
**document_text_html - This method creates a document flagged as an HTML document. This method is called by document_response in case the mime type is text/html. It calls the new_doc helper method.
**handle_xml - This method creates a document flagged as a non HTML document. This method is called by document_response in case the mime type subtype is XML. It calls the new_doc helper method.
**new_doc - This method creates a new document which is the final response based on the input received from document_text_response and handle_xml methods.

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-06T23:55:04Z

Jmehta2: /* Implementation Details */ updated 1st task

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
*'''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() and final_charset()
**final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type
**final_charset() method which returns the final charset<ref>https://xhr.spec.whatwg.org/#final-charset</ref> depending on override charset and response charset
**We have also determined encoding of text_response by calling the final_charset() helper method. But if final charset is not set (i.e. it is None) then UTF-8 is set as the default encoding. The step 4 mentioned in the [https://xhr.spec.whatwg.org/#text-response text response] documentation in order to add support for XML encoding guess stuff using XML spec was not to be implemented and hence FIXME was added in the code.

* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest. If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. New methods were created which contain handling for different mime types. A document object is created and its JS value is returned. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>.For mime type text/html if any of the charset is NONE the requirement was to scan the first 1024 bytes of the header to identify the charset, this part has not been implemented in this project. The following new methods were added to file XMLHttprequest.rs as part of this task -
**document_response - This method creates a document as per mime type returned by the final_mime_type() method created as part of OSS project. It internally calls other methods listed below.
**document_text_html - This method creates a document flagged as an HTML document. This method is called by document_response in case the mime type is text/html. It calls the new_doc helper method.
**handle_xml - This method creates a document flagged as a non HTML document. This method is called by document_response in case the mime type subtype is XML. It calls the new_doc helper method.
**new_doc - This method creates a new document which is the final response based on the input received from document_text_response and handle_xml methods.

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-06T19:47:05Z

Jmehta2: /* Implementation Details */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We have also determined encoding of text_response by calling this final_charset() helper method. But if final charset is not set (i.e. it is None) then UTF-8 is set as the default encoding.

* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest. If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-06T19:31:56Z

Jmehta2: /* Implementation Details */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. The default value of credentials_flag is set to true. credentials_flag is assigned value for cross-origin requests in Send() method of xmlhttprequest.rs file using the withCredentials attribute of XMLHttpRequest. If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-06T19:24:52Z

Jmehta2: /* Implementation Details */ edited few lines

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. The default value given for it is true. credentials_flag is set for cross-origin requests in Send() method of xmlhttprequest.rs file using the WithCredentials() attribute of XMLHttpRequest. If the credentials_flag is false then cookies will not be set from the cookie jar for the HTTP request for which the code is added in http_loader.rs file. Also if the credentials_flag is false, then the cookies are not set in the cookie jar from HTTP response.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-05T01:30:17Z

Jmehta2: /* Project Description */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_Details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. credentials_flag is set in Send() method of xmlhttprequest.rs file. If the credentials_flag is false then cookies will not be set for the HTTP request for which the code is added in http_loader.rs file.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-05T01:29:22Z

Jmehta2: Updated project description

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs.<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref> The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The implementation of the final project is described in a [[#Implementation_details|section below]].

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. credentials_flag is set in Send() method of xmlhttprequest.rs file. If the credentials_flag is false then cookies will not be set for the HTTP request for which the code is added in http_loader.rs file.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-05T01:16:22Z

Jmehta2: /* Project Description */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project comprises:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing support for withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. credentials_flag is set in Send() method of xmlhttprequest.rs file. If the credentials_flag is false then cookies will not be set for the HTTP request for which the code is added in http_loader.rs file.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-05T00:58:57Z

Jmehta2: Test Cases Updated

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project comprises:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. credentials_flag is set in Send() method of xmlhttprequest.rs file. If the credentials_flag is false then cookies will not be set for the HTTP request for which the code is added in http_loader.rs file.

* '''Support for document response in responseXML API :''' Added Document to the list of response type checks. A new method document_response() is called which contains handling for different mime types based on value returned by the final_mime_type() method. A document object is created and its JS value is returned by the method. The document object is stored in response_xml member of XHR, on subsequent calls to the method this object is returned if it has already been set previously.<ref>https://xhr.spec.whatwg.org/#response-document-object</ref>

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that pass after our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-12-05T00:20:26Z

Jmehta2: Added Implementation details section

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project comprises:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:component_flow_f15_m1504.png]]

The XMLHttpRequest API receives request from the web server, the implementation then checks the response type, if it is a text response then we use the charset from final_charset else we use the default charset that was received with the request. The same applies to document response.


Note :- UML diagram is not included because we do not have much class interaction in this project.


==Design Patterns ==
We have used "State Pattern" for our final project implementation. Our implementation stores the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value, the design pattern ensures the system behaves as per this new value.

[[File: design_pattern_f15_m1504.png]]

==Implementation Details==
The implementation for the final project involved following tasks:
* '''Implement the specified behavior for the override MIME type/final MIME type and override charset/final charset :''' We created two helper methods in xmlhttprequest.rs file: final_mime_type() method which returns the final MIME type<ref>https://xhr.spec.whatwg.org/#final-mime-type</ref> depending on override MIME type and response MIME type and final_charset() method which returns the final charset.<ref>https://xhr.spec.whatwg.org/#final-charset</ref> We also added final charset support for text_response by calling this final_charset() helper method.
* '''Support the withCredentials API :''' We have implemented basic network level support to conditionally exclude cookies from the HTTP request by adding a boolean member: credentials_flag to LoadData structure in lib.rs file. credentials_flag is set in Send() method of xmlhttprequest.rs file. If the credentials_flag is false then cookies will not be set for the HTTP request for which the code is added in http_loader.rs file.

==Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in open state with XML MIME type, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null
* withCredentials must have a default value of false and after setting the variable it is correctly set as true
* When XMLHttpRequest is not in UNSENT or OPENED state setting withCredentials variable should throw InvalidStateError exception
* When synchronous flag is set, trying to set withCredentials variable must throw an InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-14T01:25:02Z

Jmehta2: Add image citation

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[Image:task.jpg]]

<ref group="image">https://github.com/servo/servo/wiki/Design</ref>

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project comprises:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:flow_f15_m1504.png]]

==Design Patterns ==
We will be using "State Pattern" for our final project implementation. Our implementation will store the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value which in turns ensures the system behaves as per this new value.

[[File: Component flow diagram.png]]

==Proposed Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in open state with XML MIME type, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null
* withCredentials must have a default value of false and after setting the variable it is correctly set as true
* When XMLHttpRequest is not in UNSENT or OPENED state setting withCredentials variable should throw InvalidStateError exception
* When synchronous flag is set, trying to set withCredentials variable must throw an InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>
===Images===
<references group="image"/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-14T00:58:30Z

Jmehta2: /* Project Description */

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[File:task.jpg]]

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
... //read the response as XML object
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] included implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically incorporated implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project comprises:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:flow_f15_m1504.png]]

==Design Patterns ==
We will be using "State Pattern" for our final project implementation. Our implementation will store the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value which in turns ensures the system behaves as per this new value.

[[File: Component flow diagram.png]]

==Proposed Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in open state with XML MIME type, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null
* withCredentials must have a default value of false and after setting the variable it is correctly set as true
* When XMLHttpRequest is not in UNSENT or OPENED state setting withCredentials variable should throw InvalidStateError exception
* When synchronous flag is set, trying to set withCredentials variable must throw an InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-13T22:57:31Z

Jmehta2: /* XMLHttpRequest */ Reduced code in overrideMimeType

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-13T22:52:12Z

Jmehta2: /* Requirement Analysis */ Reformatting of few sentences

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[File:task.jpg]]

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
if (client.readyState !== 4) return;
try{
var str = client.responseXML.documentElement.tagName+
client.responseXML.documentElement.firstChild.tagName+
client.responseXML.documentElement.firstChild.textContent;
}catch(e){
assert_unreached('Exception when reading responseXML');
}
assert_equals( client.responseXML.documentElement.tagName, 'test' );
assert_equals( client.responseXML.documentElement.firstChild.tagName, 'message' );
assert_equals( client.responseXML.documentElement.firstChild.textContent, 'Hello World！' );
test.done();
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] involved implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically involved implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project involves:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis and corresponding places in code in which these steps would be implemented:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure in [https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L130 lib.rs file] which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:flow_f15_m1504.png]]

==Design Patterns ==
We will be using "State Pattern" for our final project implementation. Our implementation will store the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value which in turns ensures the system behaves as per this new value.

[[File: Component flow diagram.png]]

==Proposed Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in open state with XML MIME type, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null
* withCredentials must have a default value of false and after setting the variable it is correctly set as true
* When XMLHttpRequest is not in UNSENT or OPENED state setting withCredentials variable should throw InvalidStateError exception
* When synchronous flag is set, trying to set withCredentials variable must throw an InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-13T22:24:05Z

Jmehta2: Restructured Proposed Test Cases section

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[File:task.jpg]]

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
if (client.readyState !== 4) return;
try{
var str = client.responseXML.documentElement.tagName+
client.responseXML.documentElement.firstChild.tagName+
client.responseXML.documentElement.firstChild.textContent;
}catch(e){
assert_unreached('Exception when reading responseXML');
}
assert_equals( client.responseXML.documentElement.tagName, 'test' );
assert_equals( client.responseXML.documentElement.firstChild.tagName, 'message' );
assert_equals( client.responseXML.documentElement.firstChild.textContent, 'Hello World！' );
test.done();
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] involved implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically involved implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project involves:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods for final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:flow_f15_m1504.png]]

==Design Patterns ==
We will be using "State Pattern" for our final project implementation. Our implementation will store the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value which in turns ensures the system behaves as per this new value.

[[File: Component flow diagram.png]]

==Proposed Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* If XMLHttpRequest is in unsent state, then overrideMimeType() should be able to enforce Shift-JIS charset encoding
* If XMLHttpRequest is in open state, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in open state with XML MIME type, then overrideMimeType() should be able to enforce UTF-8 charset encoding
* If XMLHttpRequest is in HEADERS RECEIVED state, then overrideMimeType() will be able to enforce Shift-JIS charset encoding
* responseXML attribute should throw InvalidStateError if response type is not null or document
* The various responseXML document properties like domain, URL, title, body, images, etc. must be correctly initialized
* If the state of XMLHttpRequest is not done then responseXML must be null
* withCredentials must have a default value of false and after setting the variable it is correctly set as true
* When XMLHttpRequest is not in UNSENT or OPENED state setting withCredentials variable should throw InvalidStateError exception
* When synchronous flag is set, trying to set withCredentials variable must throw an InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-13T17:44:35Z

Jmehta2: Project Description section reduced in size

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

==Servo task Architecture==

[[File:task.jpg]]

===Description===

* Each box corresponds to a Rust task.
* The primary tasks in the browser pipeline are represented by Blue boxes.
* Dashed lines indicate supervisor relationships.
* Gray boxes indicate tasks auxiliary to the browser pipeline.
* Communication channels are represented as solid lines.
* White boxes are represented as worker tasks. Each such box represents several tasks which varies with the workload.<ref>https://github.com/servo/servo/wiki/Design</ref>

==Background==
===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a specification which defines [https://en.wikipedia.org/wiki/Application_programming_interface APIs] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

Some of the APIs and properties present in XMLHttpRequest specification are '''overrideMimeType()''' , '''responseXML''' and '''withCredentials'''. The following javascript code snippets briefly explain about each of these APIs.

;overrideMimeType<ref>https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/XMLHttpRequest/overridemimetype-open-state-force-xml.htm</ref>

<pre>

//override the Mime type to retrieve the response as an XML Object

var client = new XMLHttpRequest();
client.onreadystatechange = function() {
if (client.readyState !== 4) return;
try{
var str = client.responseXML.documentElement.tagName+
client.responseXML.documentElement.firstChild.tagName+
client.responseXML.documentElement.firstChild.textContent;
}catch(e){
assert_unreached('Exception when reading responseXML');
}
assert_equals( client.responseXML.documentElement.tagName, 'test' );
assert_equals( client.responseXML.documentElement.firstChild.tagName, 'message' );
assert_equals( client.responseXML.documentElement.firstChild.textContent, 'Hello World！' );
test.done();
};
client.open("GET", "resources/status.py?type="
+encodeURIComponent('text/plain;charset=Shift-JIS')
+'&content='+ encodeURIComponent('<test><message>Hello World！</message></test>'));
client.overrideMimeType('application/xml;charset=UTF-8');
client.send();

</pre>

;responseXML property<ref>https://msdn.microsoft.com/en-us/library/ms534370(v=vs.85).aspx</ref>
<pre>
//read the response from the server as an XML Object

var oReq = new XMLHttpRequest();
oReq.open("GET", "http://localhost/books.xml", false);
oReq.send();
console.log(oReq.responseXML.xml);
</pre>

;withCredentials property<ref>http://arunranga.com/examples/access-control/credentialedRequest.html</ref>
<pre>

//create cross site requests using cookies as credentials

var invocation = new XMLHttpRequest();
var url = 'http://crossoriginurl.com/resources/access-control-with-credentials/';
invocation.open('GET', url, true);
invocation.withCredentials = "true";
invocation.onreadystatechange = handler;
invocation.send();

</pre>

The above mentioned APIs and properties for XMLHttpRequest are currently unimplemented in servo.

==Project Description==

Our project aim is to implement few of the missing XMLHttpRequest APIs. The [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2015/oss_M1504_JJD OSS project] involved implementing initial steps of the [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs specifications]. It basically involved implementing overrideMimeType method and adjusting related test expectations.

The current scope of the project involves:<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>
* Implementing the specified behavior of the final MIME type and final charset based on the implemented override_mime_type() method in the initial steps
* Implementing responseXML API and document response type according to the XHR specifications
* Implementing withCredentials API

==Requirement Analysis==

Below is an overview of the various steps identified as a part of the requirement analysis:

''' XMLHttpRequest Interface '''
* We have to uncomment the responseXML API
* A webpage can make use of this API to read the document response

'''XMLHttpRequest DOM '''

# Create helper methods for final_mime_type and final_charset
#* Implement the two methods as per the behavior mentioned in the [https://xhr.spec.whatwg.org/#final-mime-type specification]
# Implement correct behavior for the text_response method
#* Make use of the final_charset and final_mime_type helper methods to determine the correct encoding for the response and decode the response using this encoding
# Create and implement a new method "document_response" according to the [https://xhr.spec.whatwg.org/#document-response xhr specification]
# Implement the correct behavior for the responseXML API to handle exceptions and return the document response using the method implemented above <ref>https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml</ref>
# Implement the withCredentials APIs (setter and getter) as per the [https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials specification]
# Add support to the send() and open() API to test the value of the withCredentials attribute where necessary

''' net_traits '''
* Add a new member to the LoadData Structure which will be used by the http_loader to conditionally exclude cookies from the XHR request based on the value of the member.

''' XHR Tests '''
* We need to pass [[#Proposed_Test_Cases | most tests]] related to overrideMimeType, responseXML and withCredentials present in the [https://github.com/servo/servo/tree/master/tests/wpt/web-platform-tests/XMLHttpRequest XHR test-suite]

==Component Flow Diagram==

[[File:flow_f15_m1504.png]]

==Design Patterns ==
We will be using "State Pattern" for our final project implementation. Our implementation will store the new CHARSET and MIME type based on what user has requested. So once user has requested for override in this value which in turns ensures the system behaves as per this new value.

[[File: Component flow diagram.png]]

==Proposed Test Cases==
The tests have already been written for the XMLHttpRequest APIs related to our project. So the test cases that could validate our changes to the code are as follows:

* overrideMimeType() in unsent state enforces Shift-JIS encoding
* overrideMimeType() in open state enforces UTF-8 encoding
* overrideMimeType() in open state and XML MIME type with UTF-8 charset is correctly enforced
* overrideMimeType() in HEADERS RECEIVED state enforces Shift-JIS encoding
* responseXML attribute throws InvalidStateError if response type is not null or document
* The various responseXML document properties are correctly initialized
* The type of the responseXML stylesheets and implementation must be object
* If the state of XMLHttpRequest is not done then responseXML is null
* Check withCredentials defaults to false and set value is true
* Setting withCredentials when not in UNSENT, OPENED state throws InvalidStateError exception
* Setting withCredentials when synchornous flag is set throws InvalidAccessError exception

==Appendix==
* Steps for installing [https://github.com/rust-lang/rust rust]
* Building [https://github.com/servo/servo Servo]

==References==
<references/>

File:Flow f15 m1504.png

2015-11-10T04:36:45Z

Jmehta2:

File:Flow.png

2015-11-10T04:35:22Z

Jmehta2: uploaded a new version of "File:Flow.png": Reverted to version as of 23:14, 10 February 2012

File:Flow.png

2015-11-10T04:30:33Z

Jmehta2: uploaded a new version of "File:Flow.png": M 1504 diagram Fall 15

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-10T01:03:14Z

Jmehta2: reordering of sections

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-10T00:41:43Z

Jmehta2: Added Project Description

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-09T23:34:16Z

Jmehta2: Added Architecture section

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-09T01:51:00Z

Jmehta2: Added Proposed Test Cases section

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-08T22:19:33Z

Jmehta2: Added Appendix section

CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs

2015-11-08T22:01:40Z

Jmehta2: Added Introduction section

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-06T00:52:59Z

Jmehta2: reordering of sections

M1504: Implement support for missing XMLHttpRequest APIs 
[https://xhr.spec.whatwg.org/ XMLHttpRequest] is one of the implemented API specifications of Servo that relies upon JavaScript and is used for making dynamic HTTP requests. The goal of the project was to implement support for less common but missing features of the XMLHttpRequest API for [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo].<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a definition of an [https://en.wikipedia.org/wiki/Application_programming_interface API] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

==Scope==
The scope of the project was to complete the initial steps mentioned [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs here].

The steps are as follows:
* compile Servo and ensure that it runs on tests/html/about-mozilla.html
* uncomment the overrideMimeType API in XMLHttpRequest.webidl, and add a stub method that allows Servo to compile again to xmlhttprequest.rs.
* run the tests via ./mach test-wpt tests/wpt/web-platform-tests/XMLHttpRequest/ and adjust the expectations for any that now pass (tests/wpt/metadata/XMLHttpRequest/)
* add new override_charset and override_mime_type fields to the XMLHttpRequest structure
* implement the overrideMimeType steps described in the specification
* update any tests that now pass

The subsequent steps mentioned [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs here] are to be done for the final project.

==Design Pattern==
Design patterns are not applicable as our task involved just implementing a method. However, the [[CSC/ECE_517_Fall_2015/oss_M1504_JJD#Implementation|Implementation]] section below provides details of the steps as why it was implemented, the way it was implemented.

==Implementation==

The following steps were followed to meet the project requirements as per this [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs github page].

===Step 1===

As we need to implement the overrideMimeType() method, we have uncommented the overrideMimeType() method from the XMLHttpRequest interface (components/script/dom/webidls/XMLHttpRequest.webidl).

[[File:Uncomment-overrideMimeType.png]]

===Step 2===

As two new fields are necessary for overrideMimeType() method implementation, override_mime_type to store the mime type of the mime passed in the argument and override_charset to store the charset of the mime passed in the argument.
Hence, we have added two new fields: override_mime_type and override_charset to the XMLHttpRequest structure.

[[File:XHRStruct.png]]

===Step 3===

Finally, we have implemented the overrideMimeType method according to the [https://xhr.spec.whatwg.org/#the-overridemimetype%28%29-method XHR specifications].
* If the state is loading or done, we have returned Invalid State Error
* Then we have parsed the mime passed in the argument
* If the parsing of mime was successful, we have saved the appropriate values in override_mime_type and override_charset

[[File:overrideMimeType.png]]

== Testing ==

Following are the steps to run all the tests for XMLHttpRequest:

# Install the pre-requisites required for servo as mentioned [https://github.com/servo/servo/blob/master/README.md here]
# Run the following commands

<code>
cd
</code>

<code>
git clone https://github.com/jitendra29/servo.git
</code>

<code>
cd servo
</code>

<code>
git checkout -b test origin/overrideMimeType
</code>

<code>
./mach build --release
</code>

Note: It may take around 30 mins to build

<code>
./mach test-wpt XMLHttpRequest/ --release
</code>

You will see that all tests pass as expected.

'''Note:''' We have not added any new tests to the test suite as servo follows TDD and tests were previously written for XMLHttpRequest. We have just adjusted some of the test expectations for the tests which now pass due to our implementation.

=== Testing From UI ===

Our project cannot be tested from UI since it is basically improving some javascript features (XMLHttpRequest) in servo. However you can check that it doesn't break the existing code and the browser runs correctly by running a test page on servo after performing the build as mentioned above.

Run the following command after the project is build:

<code>
./mach run tests/html/about-mozilla.html
</code>

==Pull Request==
Here is our [https://github.com/servo/servo/pull/8182 pull request]. In the link you can see all code snippets changed due to implementing the above steps, as well as integration test progression information.

==References==
<references/>

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-05T23:16:06Z

Jmehta2: Added Scope section

M1504: Implement support for missing XMLHttpRequest APIs 
[https://xhr.spec.whatwg.org/ XMLHttpRequest] is one of the implemented API specifications of Servo that relies upon JavaScript and is used for making dynamic HTTP requests. The goal of the project was to implement support for less common but missing features of the XMLHttpRequest API for [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo].<ref>https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs</ref>

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is not to create a full browser but is rather to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

Servo is built on top of Rust to provide a secure and reliable foundation and is focused on creating a reliable and fast browser engine.

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

Rust is a modern, fast, memory safe and multithreaded programming language that focuses on speed and safety for developing reliable and efficient systems. It eliminates all data races by having numerous compile-time safety checks that adds no runtime overhead.<ref> http://doc.rust-lang.org/nightly/book/README.html</ref>

===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a definition of an [https://en.wikipedia.org/wiki/Application_programming_interface API] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

==Design Pattern==
Design patterns are not applicable as our task involved just implementing a method. However, the [[CSC/ECE_517_Fall_2015/oss_M1504_JJD#Implementation|Implementation]] section below provides details of the steps as why it was implemented, the way it was implemented.

==Scope==
The scope of the project was to complete the initial steps mentioned [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs here].

The steps are as follows:
* compile Servo and ensure that it runs on tests/html/about-mozilla.html
* uncomment the overrideMimeType API in XMLHttpRequest.webidl, and add a stub method that allows Servo to compile again to xmlhttprequest.rs.
* run the tests via ./mach test-wpt tests/wpt/web-platform-tests/XMLHttpRequest/ and adjust the expectations for any that now pass (tests/wpt/metadata/XMLHttpRequest/)
* add new override_charset and override_mime_type fields to the XMLHttpRequest structure
* implement the overrideMimeType steps described in the specification
* update any tests that now pass

The subsequent steps mentioned [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs here] are to be done for the final project.

==Implementation==

The following steps were followed to meet the project requirements as per this [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs github page].

===Step 1===

As we need to implement the overrideMimeType() method, we have uncommented the overrideMimeType() method from the XMLHttpRequest interface (components/script/dom/webidls/XMLHttpRequest.webidl).

[[File:Uncomment-overrideMimeType.png]]

===Step 2===

As two new fields are necessary for overrideMimeType() method implementation, override_mime_type to store the mime type of the mime passed in the argument and override_charset to store the charset of the mime passed in the argument.
Hence, we have added two new fields: override_mime_type and override_charset to the XMLHttpRequest structure.

[[File:XHRStruct.png]]

===Step 3===

Finally, we have implemented the overrideMimeType method according to the [https://xhr.spec.whatwg.org/#the-overridemimetype%28%29-method XHR specifications].
* If the state is loading or done, we have returned Invalid State Error
* Then we have parsed the mime passed in the argument
* If the parsing of mime was successful, we have saved the appropriate values in override_mime_type and override_charset

[[File:overrideMimeType.png]]

==Pull Request==
Here is our [https://github.com/servo/servo/pull/8182 pull request]. In the link you can see all code snippets changed due to implementing the above steps, as well as integration test progression information.

==References==
<references/>

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-05T22:50:33Z

Jmehta2: Added Design Patterns section

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-05T22:39:59Z

Jmehta2: Description of the steps performed.

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-01T01:31:17Z

Jmehta2: Added content to Introduction section

File:OverrideMimeType.png

2015-11-01T01:08:37Z

Jmehta2: uploaded a new version of "File:OverrideMimeType.png"

File:XHRStruct.png

2015-11-01T01:04:59Z

Jmehta2: uploaded a new version of "File:XHRStruct.png"

File:XHRStruct.png

2015-11-01T01:03:23Z

Jmehta2: uploaded a new version of "File:XHRStruct.png"

File:Uncomment-overrideMimeType.png

2015-11-01T01:00:16Z

Jmehta2: uploaded a new version of "File:Uncomment-overrideMimeType.png"

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-11-01T00:04:44Z

Jmehta2: Added information before introduction.

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-10-31T23:33:43Z

Jmehta2: Formatting.

M1504: Implement support for missing XMLHttpRequest APIs 
The goal of this project was to implement support for missing less-common features of the XMLHttpRequest API for [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo].

==Introduction==

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a definition of an [https://en.wikipedia.org/wiki/Application_programming_interface API] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

=='''Implementation'''==
===Initial Steps===
The following steps were followed to meet the project requirements as per this [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs github page].

*compile Servo and ensure that it runs on tests/html/about-mozilla.html
*uncomment the overrideMimeType API in XMLHttpRequest.webidl, and add a stub method that allows Servo to compile again to xmlhttprequest.rs.
*run the tests via ./mach test-wpt tests/wpt/web-platform-tests/XMLHttpRequest/ and adjust the expectations for any that now pass (tests/wpt/metadata/XMLHttpRequest/)
*add new override_charset and override_mime_type fields to the XMLHttpRequest structure
*implement the overrideMimeType steps described in the [https://xhr.spec.whatwg.org/#the-overridemimetype%28%29-method specifications]
*update any tests that now pass

===Accepted Pull Request===
Here is our [https://github.com/servo/servo/pull/8182 pull request]. In the link you can see all code snippets changed, as well as integration test progression information.

===Design Patterns and Principles===

==References==
<references/>

CSC/ECE 517 Fall 2015/oss M1504 JJD

2015-10-31T23:04:15Z

Jmehta2:

=='''M1504: Implement support for missing XMLHttpRequest APIs'''==
The goal of this project was to implement support for missing less-common features of the XMLHttpRequest API for [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo].

===Servo===

Servo <ref> https://github.com/servo/servo </ref> is a web browser layout engine written in [https://github.com/rust-lang/rust Rust]<ref>https://github.com/rust-lang/rust</ref> and is currently being developed by [https://en.wikipedia.org/wiki/Mozilla Mozilla Research]. The aim of the project is to create a highly parallel environment that allows for many components be handled by fine-grained, isolated tasks.<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>

===Rust===

[https://en.wikipedia.org/wiki/Rust_(programming_language) Rust] is a multi-paradigm, compiled programming language that is a good language for creating highly safe systems. Rust and Servo have a symbiotic relationship as the development of servo has influenced the design of the language.

===XMLHttpRequest===
"[https://xhr.spec.whatwg.org/ XMLHttpRequest] is a definition of an [https://en.wikipedia.org/wiki/Application_programming_interface API] that provides scripted client functionality for transferring data between a client and a server."<ref>https://xhr.spec.whatwg.org/</ref> XMLHttpRequest provides a way for data to be retrieved from a URL without having to retrieve the entire page. It supports protocols other than HTTP and can be used to retrieve any type of data.<ref>https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest</ref>

=='''Implementation'''==
===Initial Steps===
The following steps were followed to meet the project requirements as per this [https://github.com/servo/servo/wiki/Implement-support-for-missing-XMLHttpRequest-APIs github page].

*compile Servo and ensure that it runs on tests/html/about-mozilla.html
*uncomment the overrideMimeType API in XMLHttpRequest.webidl, and add a stub method that allows Servo to compile again to xmlhttprequest.rs.
*run the tests via ./mach test-wpt tests/wpt/web-platform-tests/XMLHttpRequest/ and adjust the expectations for any that now pass (tests/wpt/metadata/XMLHttpRequest/)
*add new override_charset and override_mime_type fields to the XMLHttpRequest structure
*implement the overrideMimeType steps described in the [https://xhr.spec.whatwg.org/#the-overridemimetype%28%29-method specifications]
*update any tests that now pass

===Accepted Pull Request===
Here is our [https://github.com/servo/servo/pull/8182 pull request]. In the link you can see all code snippets changed, as well as integration test progression information.

===Design Patterns and Principles===

==References==
<references/>