Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:46:06Z

Apkulkar: /* Goals */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

<code>[http://en.wikipedia.org/wiki/Rust_(programming_language) Rust] </code> is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

<code>[http://en.wikipedia.org/wiki/Servo_(layout_engine) Servo ] </code> is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the <code> [https://wiki.mozilla.org/DOM:Home_Page DOM] </code> mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, <code> [http://en.wikipedia.org/wiki/SpiderMonkey_(JavaScript_engine) Spidermonkey.] </code>

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:43:41Z

Apkulkar: /* Servo */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

<code>[http://en.wikipedia.org/wiki/Rust_(programming_language) Rust] </code> is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

<code>[http://en.wikipedia.org/wiki/Servo_(layout_engine) Servo ] </code> is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:43:32Z

Apkulkar: /* Servo */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

<code>[http://en.wikipedia.org/wiki/Rust_(programming_language) Rust] </code> is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

<code>[http://en.wikipedia.org/wiki/Servo_(layout_engine)Servo ] </code> is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:43:20Z

Apkulkar: /* Servo */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

<code>[http://en.wikipedia.org/wiki/Rust_(programming_language) Rust] </code> is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

<code>[http://en.wikipedia.org/wiki/Servo_(layout_engine) Servo ] </code> is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:41:53Z

Apkulkar: /* Rust */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

<code>[http://en.wikipedia.org/wiki/Rust_(programming_language) Rust] </code> is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:40:16Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:38:53Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo[[References]]

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:36:08Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo<ref name="a"> https://github.com/mozilla/servo - Getting started with servo
which is being implemented in the Rust programming language.</ref>

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:33:03Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element CANVAS] </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:32:30Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a<code> [http://en.wikipedia.org/wiki/Canvas_element] CANVAS </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:31:37Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS<code> http://en.wikipedia.org/wiki/Canvas_element </code> for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:28:43Z

Apkulkar: /* References */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust -Getting started with Rust

2. https://github.com/mozilla/servo - Getting started with servo

3. https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding - Adding a new webidl binding.

4. https://github.com/Aalhad/CanvasRenderingContext2DMozilla - Our Project on github.

5. http://www.2ality.com/2012/02/servo.html - Future Scope

6. http://en.wikipedia.org/wiki/Rust_(programming_language) - Rust

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:27:50Z

Apkulkar: /* References */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:27:06Z

Apkulkar: /* Appendix */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust (follow the link) - [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust]

2. Build Servo (follow the link) - [https://github.com/mozilla/servo]

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust] -Getting started with Rust

2. [https://github.com/mozilla/servo] - Getting started with servo

3. [https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding] - Adding a new webidl binding.

4. [https://github.com/Aalhad/CanvasRenderingContext2DMozilla] - Our Project on github.

5. [http://www.2ality.com/2012/02/servo.html] - Future Scope

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:25:43Z

Apkulkar: /* Appendix */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust

2. Build Servo (follow the link)

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust] -Getting started with Rust

2. [https://github.com/mozilla/servo] - Getting started with servo

3. [https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding] - Adding a new webidl binding.

4. [https://github.com/Aalhad/CanvasRenderingContext2DMozilla] - Our Project on github.

5. [http://www.2ality.com/2012/02/servo.html] - Future Scope

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:20:04Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

==Appendix==

Steps to run the project

1. Install and Build Rust <a href="https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust">follow the link</a>

2. Build Servo (follow the link)

3. Write the code for canvasrenderingcontext2d.rs and htmlcanvaselement.rs

4. Generate a Binding for CanvasRenderingContext2D.webidl, HTMLCanvasElement.webidl

5. Run Servo

==References==

1. [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust] -Getting started with Rust

2. [https://github.com/mozilla/servo] - Getting started with servo

3. [https://github.com/mozilla/servo/wiki/Adding-a-new-WebIDL-binding] - Adding a new webidl binding.

4. [https://github.com/Aalhad/CanvasRenderingContext2DMozilla] - Our Project on github.

5. [http://www.2ality.com/2012/02/servo.html] - Future Scope

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:14:28Z

Apkulkar: /* Screenshots */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:14:09Z

Apkulkar: /* Screenshots */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===

'''Make and Build Servo'''
[[File:Sc1.jpg]]

'''Make Check Successful'''
[[File:Sc2.jpg]]

'''Run Servo Engine'''
[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:13:41Z

Apkulkar: /* Screenshots */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:13:00Z

Apkulkar: /* Screenshots */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===
'''Make and Build Servo'''

[[File:Sc1.jpg]]

'''Make Check Successful'''

[[File:Sc2.jpg]]

'''Run Servo Engine'''

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:12:24Z

Apkulkar: /* Screenshots */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===
Make and Build Servo

[[File:Sc1.jpg]]

Make Check Successful

[[File:Sc2.jpg]]

Run Servo Engine

[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

File:Sc3.png

2013-10-31T01:11:45Z

Apkulkar: uploaded a new version of "File:Sc3.png"

File:Sc2.jpg

2013-10-31T01:11:31Z

Apkulkar: uploaded a new version of "File:Sc2.jpg"

File:Sc1.jpg

2013-10-31T01:11:15Z

Apkulkar: uploaded a new version of "File:Sc1.jpg"

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:08:55Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

===Screenshots===
Make and Build Servo
[[File:Sc1.jpg]]

Make Check Successful
[[File:Sc2.jpg]]

Run Servo Engine
[[File:Sc3.png]]

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

File:Sc3.png

2013-10-31T01:07:04Z

Apkulkar:

File:Sc2.jpg

2013-10-31T01:06:50Z

Apkulkar:

File:Sc1.jpg

2013-10-31T01:06:27Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:01:12Z

Apkulkar: /* Project Description */

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==
 
• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T01:00:47Z

Apkulkar:

''' CANVAS 2D with RUST and MOZILLA SERVO '''

This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language.

== Introduction ==

Mozilla are working on a project called Servo which is being implemented in the Rust programming language.

== Design ==

=== Rust ===

Rust is a curly-brace, block-structured expression language.

It visually resembles the C language family, but differs significantly in syntactic and semantic details.

Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

Example:
fn main() {
println("hello, world");
}

=== Servo ===

Servo is an experimental web browser layout engine being developed by Mozilla.

The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are handled by fine-grained, isolated tasks.

The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine. Although Servo is a research project, it is designed to be "productizable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

==== Design Diagrams ====

'''Task Supervision Diagram'''

[[File:Diagram1.jpg]]

'''Task Communication Diagram'''

[[File:Diagram2.jpg]]

• ''Each box'' represents a Rust task.

• ''Blue boxes'' represent the primary tasks in the browser pipeline.

• ''Gray boxes'' represent tasks auxiliary to the browser pipeline.

• ''White boxes'' represent worker tasks. Each such box represents several tasks, the precise number of which will vary with the workload.

• ''Dashed lines'' indicate supervisor relationships.

• ''Solid lines'' indicate communication channels.

==Project Description==

• The project requirement stated us to develop a ''Binding'' for a '''CanvasRenderingContext2D.webidl''' and the '''HTMLCanvasElement.webidl''' interface.

• We had to write a '''canvasrenderingcontext2d.rs''' file, which is written in the Rust programming language. We needed a struct containing a Reflector at minimum, as well as implementation of the Reflectable and BindingObject traits.

• We also had to write an '''htmlcanvaselement.rs''' file which is also written in the Rust Language.

• The above files get compiled to generate ''Binding Files'' named '''CanvasRenderingContext2DBinding.rs''' and '''HTMLCanvasELementBinding.rs'''

• We then added '''<canvas>''' element support to the ''HTML parser'' using the '''hubbub_html_parser.rs''' file.

• Then we successfully built and compiled our project on the Servo Engine.

• This was Part one of our Mozilla project.

• Our Final Project of OOLS will consist of Part two of the Mozilla project which includes implementing '''Canvas API''' for Mozilla using the '''CanvasRenderingContext2D''' and the '''HTMLCanvasElement''' interfaces.

==Future Scope==
 
Servo is predicted to be – the next Firefox

Note that Servo is a research project, it may or may not become an actual product. Firefox is evolved in parallel and making great progress. In other words, Mozilla does not make the mistake of betting the farm on Servo. A complete rewrite of parts of the Navigator web browser (the flagship product) for version 4 brought Mozilla’s ancestor Netscape much trouble.

===Goals===
• The Servo project is about building a parallel browser:

• Use Rust instead of C++ which is safer and better equipped for parallelism.

• Try to parallelize as many stages of the rendering process as possible (ongoing research).

• Implement the DOM mostly in JavaScript (which makes it faster, because there are less context switches).

• Browser innovation only: For the foreseeable future, Servo will use Firefox’s JavaScript engine, Spidermonkey.

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:58:34Z

Apkulkar: /* Project Description */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:58:18Z

Apkulkar: /* Project Description */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:57:19Z

Apkulkar: /* Project Description */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:54:44Z

Apkulkar: /* Project Description */

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:54:03Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:52:26Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:50:31Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:49:40Z

Apkulkar:

File:Diagram2.jpg

2013-10-31T00:48:15Z

Apkulkar: uploaded a new version of "File:Diagram2.jpg"

File:Diagram1.jpg

2013-10-31T00:47:46Z

Apkulkar: uploaded a new version of "File:Diagram1.jpg"

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:35:18Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:33:20Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:30:10Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:29:23Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:28:50Z

Apkulkar:

File:Diagram2.jpg

2013-10-31T00:28:11Z

Apkulkar: uploaded a new version of "File:Diagram2.jpg"

File:Diagram2.jpg

2013-10-31T00:28:10Z

Apkulkar:

File:Diagram1.jpg

2013-10-31T00:27:21Z

Apkulkar:

CSC/ECE 517 Fall 2013/oss M803 ana

2013-10-31T00:16:52Z

Apkulkar: Created page with "''' CANVAS 2D with RUST and MOZILLA SERVO ''' This wiki deals with our implementation of a CANVAS for the Mozilla Servo Project using the Rust Programming Language. == Introduc..."

CSC/ECE 517 Fall 2013

2013-10-31T00:09:59Z

Apkulkar:

* [[ CSC/ECE 517 Fall 2012/ch1 1w23 ph ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w30 nn]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w21 w]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w01 aj]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w24 nv]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w29 rkld]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w25 aras]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w30 ps]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w19 rj]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w18 bs]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w17 pk]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w22 ss]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w12 vn]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w14 st]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w08 cc]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w10 ga ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w26 as ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w27 ma ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w13 aa ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w11 sv ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w07 d ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w20 gq ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w03 ss ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w28 nm ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w02 pp ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w6 zs ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w04 y ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w05 st ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w09 hs ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w32 av ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w48 x ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w43 av]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w46 ka]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w33 aa]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w35 sa ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w39 as ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w31 vm ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w43 sm ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w44 s ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w47 ka ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w34 fs ]]
* [[ CSC/ECE 517 Fall 2013/ch1 1w40 ao ]]
* [[ CSC/ECE 517 Fall 2013/oss fmv ]]
* [[ CSC/ECE 517 Fall 2013/oss vna ]]
* [[ CSC/ECE 517 Fall 2013/oss paa ]]
* [[ CSC/ECE 517 Fall 2013/oss mapFeeds ]]
* [[ CSC/ECE 517 Fall 2013/oss ssp ]]
* [[ CSC/ECE 517 Fall 2013/ch2 0e808 nsv ]]
* [[ CSC/ECE 517 Fall 2013/oss aoa ]]
* [[ CSC/ECE 517 Fall 2013/oss cmh ]]
* [[ CSC/ECE 517 Fall 2013/oss ans ]]
* [[ CSC/ECE 517 Fall 2013/oss ssv]]
* [[ CSC/ECE 517 Fall 2013/oss E818 mra ]]
* [[ CSC/ECE 517 Fall 2013/oss SocialMediaFeeds ]]
* [[ CSC/ECE 517 Fall 2013/oss E811 syn ]]
* [[ CSC/ECE 517 Fall 2013/oss E804 spb ]]
* [[ CSC/ECE 517 Fall 2013/oss E812 amp ]]
* [[ CSC/ECE 517 Fall 2013/oss S805 ahs ]]
* [[ CSC/ECE 517 Fall 2013/oss E820 gzs ]]
* [[ CSC/ECE 517 Fall 2013/oss E816 cyy ]]
* [[ CSC/ECE 517 Fall 2013/oss M801 as ]]
* [[ CSC/ECE 517 Fall 2013/oss E814 vd ]]
* [[ CSC/ECE 517 Fall 2013/oss E815 saa]]
* [[ CSC/ECE 517 Fall 2013/oss E810 aas ]]
* [[ CSC/ECE 517 Fall 2013/oss E805 kkn ]]
* [[ CSC/ECE 517 Fall 2013/oss M803 ana ]]