Reduce max line length from 150 to 120 characters

Part of #6041

components/canvas/canvas_paint_task.rs

@@ -213,7 +213,8 @@ impl<'a> CanvasPaintTask<'a> {
                             Canvas2dMsg::Fill => painter.fill(),
                             Canvas2dMsg::Stroke => painter.stroke(),
                             Canvas2dMsg::Clip => painter.clip(),
-                            Canvas2dMsg::DrawImage(imagedata, image_size, dest_rect, source_rect, smoothing_enabled) => {
+                            Canvas2dMsg::DrawImage(imagedata, image_size, dest_rect, source_rect,
+                                                   smoothing_enabled) => {
                                 painter.draw_image(imagedata, image_size, dest_rect, source_rect, smoothing_enabled)
                             }
                             Canvas2dMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled) => {
@@ -245,7 +246,8 @@ impl<'a> CanvasPaintTask<'a> {
                             Canvas2dMsg::SetTransform(ref matrix) => painter.set_transform(matrix),
                             Canvas2dMsg::SetGlobalAlpha(alpha) => painter.set_global_alpha(alpha),
                             Canvas2dMsg::SetGlobalComposition(op) => painter.set_global_composition(op),
-                            Canvas2dMsg::GetImageData(dest_rect, canvas_size, chan) => painter.get_image_data(dest_rect, canvas_size, chan),
+                            Canvas2dMsg::GetImageData(dest_rect, canvas_size, chan)
+                                => painter.get_image_data(dest_rect, canvas_size, chan),
                             Canvas2dMsg::PutImageData(imagedata, image_data_rect, dirty_rect)
                                 => painter.put_image_data(imagedata, image_data_rect, dirty_rect),
                         }

components/canvas/webgl_paint_task.rs

@@ -30,9 +30,9 @@ unsafe impl Send for WebGLPaintTask {}
 impl WebGLPaintTask {
     fn new(size: Size2D<i32>) -> Result<WebGLPaintTask, &'static str> {
         // TODO(ecoal95): Get the GLContextAttributes from the `GetContext` call
-        let context = try!(GLContext::create_offscreen_with_color_attachment(size,
-                                                                             GLContextAttributes::default(),
-                                                                             ColorAttachmentType::TextureWithSurface));
+        let context = try!(
+            GLContext::create_offscreen_with_color_attachment(
+                size, GLContextAttributes::default(), ColorAttachmentType::TextureWithSurface));
         Ok(WebGLPaintTask {
             size: size,
             original_context_size: size,
@@ -50,10 +50,13 @@ impl WebGLPaintTask {
             CanvasWebGLMsg::CreateBuffer(chan) => self.create_buffer(chan),
             CanvasWebGLMsg::DrawArrays(mode, first, count) => self.draw_arrays(mode, first, count),
             CanvasWebGLMsg::EnableVertexAttribArray(attrib_id) => self.enable_vertex_attrib_array(attrib_id),
-            CanvasWebGLMsg::GetAttribLocation(program_id, name, chan) => self.get_attrib_location(program_id, name, chan),
+            CanvasWebGLMsg::GetAttribLocation(program_id, name, chan) =>
+                self.get_attrib_location(program_id, name, chan),
             CanvasWebGLMsg::GetShaderInfoLog(shader_id, chan) => self.get_shader_info_log(shader_id, chan),
-            CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, chan) => self.get_shader_parameter(shader_id, param_id, chan),
-            CanvasWebGLMsg::GetUniformLocation(program_id, name, chan) => self.get_uniform_location(program_id, name, chan),
+            CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, chan) =>
+                self.get_shader_parameter(shader_id, param_id, chan),
+            CanvasWebGLMsg::GetUniformLocation(program_id, name, chan) =>
+                self.get_uniform_location(program_id, name, chan),
             CanvasWebGLMsg::CompileShader(shader_id) => self.compile_shader(shader_id),
             CanvasWebGLMsg::CreateProgram(chan) => self.create_program(chan),
             CanvasWebGLMsg::CreateShader(shader_type, chan) => self.create_shader(shader_type, chan),

components/devtools/actors/console.rs

@@ -151,7 +151,9 @@ impl Actor for ConsoleActor {
                                 timeStamp: 0,
                                 errorMessage: "page error test".to_string(),
                             };
-                            messages.push(json::from_str(json::encode(&message).as_slice()).unwrap().as_object().unwrap().clone());*/
+                            messages.push(
+                                json::from_str(
+                                    json::encode(&message).as_slice()).unwrap().as_object().unwrap().clone());*/
                         }
 
                         "LogMessage" => {
@@ -161,7 +163,9 @@ impl Actor for ConsoleActor {
                                 timeStamp: 0,
                                 message: "log message test".to_string(),
                             };
-                            messages.push(json::from_str(json::encode(&message).as_slice()).unwrap().as_object().unwrap().clone());*/
+                            messages.push(
+                                json::from_str(
+                                    json::encode(&message).as_slice()).unwrap().as_object().unwrap().clone());*/
                         }
 
                         s => println!("unrecognized message type requested: \"{}\"", s),

components/devtools/actors/root.rs

@@ -2,7 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-/// Liberally derived from the [Firefox JS implementation](http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/root.js).
+/// Liberally derived from the [Firefox JS implementation]
+/// (http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/root.js).
 /// Connection point for all new remote devtools interactions, providing lists of know actors
 /// that perform more specific actions (tabs, addons, browser chrome, etc.)
 

components/gfx/paint_context.rs

@@ -914,15 +914,17 @@ impl<'a> PaintContext<'a> {
         if accum_blur > Au(0) {
             // Set the correct size.
             let side_inflation = accum_blur * BLUR_INFLATION_FACTOR;
-            size = Size2D(size.width + (side_inflation.to_nearest_px() * 2) as i32, size.height + (side_inflation.to_nearest_px() * 2) as i32);
+            size = Size2D(size.width + (side_inflation.to_nearest_px() * 2) as i32,
+                          size.height + (side_inflation.to_nearest_px() * 2) as i32);
 
             // Calculate the transform matrix.
             let old_transform = self.draw_target.get_transform();
             let inflated_size = Rect(Point2D(0.0, 0.0), Size2D(size.width as AzFloat,
                                                                size.height as AzFloat));
             let temporary_draw_target_bounds = old_transform.transform_rect(&inflated_size);
-            matrix = Matrix2D::identity().translate(-temporary_draw_target_bounds.origin.x as AzFloat,
-                                                    -temporary_draw_target_bounds.origin.y as AzFloat).mul(&old_transform);
+            matrix = Matrix2D::identity().translate(
+                -temporary_draw_target_bounds.origin.x as AzFloat,
+                -temporary_draw_target_bounds.origin.y as AzFloat).mul(&old_transform);
         }
 
         let temporary_draw_target =

components/gfx/paint_task.rs

@@ -481,7 +481,8 @@ impl WorkerThreadProxy {
                   layer_buffer: Option<Box<LayerBuffer>>,
                   stacking_context: Arc<StackingContext>,
                   scale: f32) {
-        self.sender.send(MsgToWorkerThread::PaintTile(thread_id, tile, layer_buffer, stacking_context, scale)).unwrap()
+        let msg = MsgToWorkerThread::PaintTile(thread_id, tile, layer_buffer, stacking_context, scale);
+        self.sender.send(msg).unwrap()
     }
 
     fn get_painted_tile_buffer(&mut self) -> Box<LayerBuffer> {

components/gfx/platform/freetype/font_list.rs

@@ -91,13 +91,15 @@ pub fn get_variations_for_family<F>(family_name: &str, mut callback: F)
         for i in 0..((*matches).nfont as isize) {
             let font = (*matches).fonts.offset(i);
             let mut file: *mut FcChar8 = ptr::null_mut();
-            let file = if FcPatternGetString(*font, FC_FILE.as_ptr() as *mut c_char, 0, &mut file) == FcResultMatch {
+            let result = FcPatternGetString(*font, FC_FILE.as_ptr() as *mut c_char, 0, &mut file);
+            let file = if result == FcResultMatch {
                 c_str_to_string(file as *const c_char)
             } else {
                 panic!();
             };
             let mut index: libc::c_int = 0;
-            let index = if FcPatternGetInteger(*font, FC_INDEX.as_ptr() as *mut c_char, 0, &mut index) == FcResultMatch {
+            let result = FcPatternGetInteger(*font, FC_INDEX.as_ptr() as *mut c_char, 0, &mut index);
+            let index = if result == FcResultMatch {
                 index
             } else {
                 panic!();

components/gfx/text/shaping/harfbuzz.rs

@@ -198,7 +198,8 @@ impl Shaper {
             let hb_funcs: *mut hb_font_funcs_t = RUST_hb_font_funcs_create();
             RUST_hb_font_funcs_set_glyph_func(hb_funcs, glyph_func, ptr::null_mut(), None);
             RUST_hb_font_funcs_set_glyph_h_advance_func(hb_funcs, glyph_h_advance_func, ptr::null_mut(), None);
-            RUST_hb_font_funcs_set_glyph_h_kerning_func(hb_funcs, glyph_h_kerning_func, ptr::null_mut(), ptr::null_mut());
+            RUST_hb_font_funcs_set_glyph_h_kerning_func(
+                hb_funcs, glyph_h_kerning_func, ptr::null_mut(), ptr::null_mut());
             RUST_hb_font_set_funcs(hb_font, hb_funcs, font as *mut Font as *mut c_void, None);
 
             Shaper {

components/layout/construct.rs

@@ -1344,7 +1344,8 @@ impl<'a> PostorderNodeMutTraversal for FlowConstructor<'a> {
                 };
                 (munged_display, style.get_box().float, style.get_box().position)
             }
-            Some(NodeTypeId::CharacterData(CharacterDataTypeId::Text)) => (display::T::inline, float::T::none, position::T::static_),
+            Some(NodeTypeId::CharacterData(CharacterDataTypeId::Text)) =>
+                (display::T::inline, float::T::none, position::T::static_),
             Some(NodeTypeId::CharacterData(CharacterDataTypeId::Comment)) |
             Some(NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction)) |
             Some(NodeTypeId::DocumentType) |

components/layout/display_list_builder.rs

@@ -42,7 +42,8 @@ use std::iter::repeat;
 use std::sync::Arc;
 use style::computed_values::filter::Filter;
 use style::computed_values::transform::ComputedMatrix;
-use style::computed_values::{background_attachment, background_clip, background_origin, background_repeat, background_size};
+use style::computed_values::{background_attachment, background_clip, background_origin,
+                             background_repeat, background_size};
 use style::computed_values::{border_style, image_rendering, overflow_x, position, visibility};
 use style::properties::ComputedValues;
 use style::properties::style_structs::Border;
@@ -477,7 +478,8 @@ impl FragmentDisplayListBuilding for Fragment {
                     (absolute_bounds.origin.x, absolute_bounds.origin.y)
                 }
                 background_attachment::T::fixed => {
-                    // If the ‘background-attachment’ value for this image is ‘fixed’, then 'background-origin' has no effect.
+                    // If the ‘background-attachment’ value for this image is ‘fixed’, then
+                    // 'background-origin' has no effect.
                     origin_x = Au(0);
                     origin_y = Au(0);
                     (Au(0), Au(0))

components/layout/model.rs

@@ -131,7 +131,8 @@ impl MarginCollapseInfo {
         let state = match self.state {
             MarginCollapseState::AccumulatingCollapsibleTopMargin => {
                 match fragment.style().content_block_size() {
-                    LengthOrPercentageOrAuto::Auto | LengthOrPercentageOrAuto::Length(Au(0)) | LengthOrPercentageOrAuto::Percentage(0.) => {
+                    LengthOrPercentageOrAuto::Auto | LengthOrPercentageOrAuto::Length(Au(0)) |
+                    LengthOrPercentageOrAuto::Percentage(0.) => {
                         match fragment.style().min_block_size() {
                             LengthOrPercentage::Length(Au(0)) | LengthOrPercentage::Percentage(0.) => {
                                 FinalMarginState::MarginsCollapseThrough

components/layout/traversal.rs

@@ -50,7 +50,8 @@ type Generation = u32;
 /// Since a work-stealing queue is used for styling, sometimes, the bloom filter
 /// will no longer be the for the parent of the node we're currently on. When
 /// this happens, the task local bloom filter will be thrown away and rebuilt.
-thread_local!(static STYLE_BLOOM: RefCell<Option<(Box<BloomFilter>, UnsafeLayoutNode, Generation)>> = RefCell::new(None));
+thread_local!(
+    static STYLE_BLOOM: RefCell<Option<(Box<BloomFilter>, UnsafeLayoutNode, Generation)>> = RefCell::new(None));
 
 /// Returns the task local bloom filter.
 ///

components/layout/wrapper.rs

@@ -125,21 +125,24 @@ pub trait TLayoutNode {
 
     fn get_renderer(&self) -> Option<Sender<CanvasMsg>> {
         unsafe {
-            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> =
+                HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
             canvas_element.and_then(|elem| elem.get_renderer())
         }
     }
 
     fn get_canvas_width(&self) -> u32 {
         unsafe {
-            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> =
+                HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
             canvas_element.unwrap().get_canvas_width()
         }
     }
 
     fn get_canvas_height(&self) -> u32 {
         unsafe {
-            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> = HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
+            let canvas_element: Option<LayoutJS<HTMLCanvasElement>> =
+                HTMLCanvasElementCast::to_layout_js(self.get_jsmanaged());
             canvas_element.unwrap().get_canvas_height()
         }
     }

components/msg/constellation_msg.rs

@@ -311,7 +311,8 @@ impl MozBrowserEvent {
             MozBrowserEvent::AsyncScroll | MozBrowserEvent::Close | MozBrowserEvent::ContextMenu |
             MozBrowserEvent::Error | MozBrowserEvent::IconChange | MozBrowserEvent::LoadEnd |
             MozBrowserEvent::LoadStart | MozBrowserEvent::OpenWindow | MozBrowserEvent::SecurityChange |
-            MozBrowserEvent::ShowModalPrompt | MozBrowserEvent::UsernameAndPasswordRequired | MozBrowserEvent::OpenSearch => None,
+            MozBrowserEvent::ShowModalPrompt | MozBrowserEvent::UsernameAndPasswordRequired |
+            MozBrowserEvent::OpenSearch => None,
             MozBrowserEvent::LocationChange(ref new_location) => Some(new_location.clone()),
             MozBrowserEvent::TitleChange(ref new_title) => Some(new_title.clone()),
         }

components/net/cookie_storage.rs

@@ -86,7 +86,8 @@ impl CookieStorage {
     // http://tools.ietf.org/html/rfc6265#section-5.4
     pub fn cookies_for_url(&mut self, url: &Url, source: CookieSource) -> Option<String> {
         let filterer = |c: &&mut Cookie| -> bool {
-            info!(" === SENT COOKIE : {} {} {:?} {:?}", c.cookie.name, c.cookie.value, c.cookie.domain, c.cookie.path);
+            info!(" === SENT COOKIE : {} {} {:?} {:?}",
+                  c.cookie.name, c.cookie.value, c.cookie.domain, c.cookie.path);
             info!(" === SENT COOKIE RESULT {}", c.appropriate_for_url(url, source));
             // Step 1
             c.appropriate_for_url(url, source)