Revert unnecessary changes

components/canvas/canvas_data.rs

@@ -371,7 +371,7 @@ pub enum Filter {
 
 pub struct CanvasData<'a> {
     backend: Box<dyn Backend>,
-    draw_target: Box<dyn GenericDrawTarget>,
+    drawtarget: Box<dyn GenericDrawTarget>,
     path_state: Option<PathState>,
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
@@ -399,7 +399,7 @@ impl<'a> CanvasData<'a> {
         let draw_target = backend.create_drawtarget(size);
         CanvasData {
             backend,
-            draw_target,
+            drawtarget: draw_target,
             path_state: None,
             state: CanvasPaintState::new(antialias),
             saved_states: vec![],
@@ -449,7 +449,7 @@ impl<'a> CanvasData<'a> {
             // TODO(pylbrecht) pass another closure for raqote
             self.draw_with_shadow(&rect, writer);
         } else {
-            writer(&mut *self.draw_target);
+            writer(&mut *self.drawtarget);
         }
     }
 
@@ -460,8 +460,8 @@ impl<'a> CanvasData<'a> {
     pub fn restore_context_state(&mut self) {
         if let Some(state) = self.saved_states.pop() {
             let _ = mem::replace(&mut self.state, state);
-            self.draw_target.set_transform(&self.state.transform);
-            self.draw_target.pop_clip();
+            self.drawtarget.set_transform(&self.state.transform);
+            self.drawtarget.pop_clip();
         }
     }
 
@@ -481,7 +481,7 @@ impl<'a> CanvasData<'a> {
             })
             .collect();
 
-        self.draw_target.fill_text(
+        self.drawtarget.fill_text(
             text,
             x,
             y,
@@ -541,7 +541,7 @@ impl<'a> CanvasData<'a> {
                 );
             });
         } else {
-            self.draw_target.fill_rect(
+            self.drawtarget.fill_rect(
                 &draw_rect,
                 self.state.fill_style.clone(),
                 Some(&self.state.draw_options),
@@ -550,7 +550,7 @@ impl<'a> CanvasData<'a> {
     }
 
     pub fn clear_rect(&mut self, rect: &Rect<f32>) {
-        self.draw_target.clear_rect(rect);
+        self.drawtarget.clear_rect(rect);
     }
 
     pub fn stroke_rect(&mut self, rect: &Rect<f32>) {
@@ -570,15 +570,15 @@ impl<'a> CanvasData<'a> {
         } else if rect.size.width == 0. || rect.size.height == 0. {
             let mut stroke_opts = self.state.stroke_opts.clone();
             stroke_opts.set_line_cap(LineCapStyle::Butt);
-            self.draw_target.stroke_line(
+            self.drawtarget.stroke_line(
                 rect.origin,
                 rect.bottom_right(),
                 self.state.stroke_style.clone(),
                 &stroke_opts,
                 &self.state.draw_options,
             );
         } else {
-            self.draw_target.stroke_rect(
+            self.drawtarget.stroke_rect(
                 rect,
                 self.state.stroke_style.clone(),
                 &self.state.stroke_opts,
@@ -600,7 +600,7 @@ impl<'a> CanvasData<'a> {
         // If there's no record of any path yet, create a new builder in user-space.
         if self.path_state.is_none() {
             self.path_state = Some(PathState::UserSpacePathBuilder(
-                self.draw_target.create_path_builder(),
+                self.drawtarget.create_path_builder(),
                 None,
             ));
         }
@@ -635,7 +635,7 @@ impl<'a> CanvasData<'a> {
         let new_state = match *self.path_state.as_mut().unwrap() {
             PathState::DeviceSpacePathBuilder(ref mut builder) => {
                 let path = builder.finish();
-                let inverse = match self.draw_target.get_transform().inverse() {
+                let inverse = match self.drawtarget.get_transform().inverse() {
                     Some(m) => m,
                     None => {
                         warn!("Couldn't invert canvas transformation.");
@@ -667,7 +667,7 @@ impl<'a> CanvasData<'a> {
         }
 
         self.ensure_path();
-        self.draw_target.fill(
+        self.drawtarget.fill(
             &self.path().clone(),
             self.state.fill_style.clone(),
             &self.state.draw_options,
@@ -680,7 +680,7 @@ impl<'a> CanvasData<'a> {
         }
 
         self.ensure_path();
-        self.draw_target.stroke(
+        self.drawtarget.stroke(
             &self.path().clone(),
             self.state.stroke_style.clone(),
             &self.state.stroke_opts,
@@ -691,7 +691,7 @@ impl<'a> CanvasData<'a> {
     pub fn clip(&mut self) {
         self.ensure_path();
         let path = self.path().clone();
-        self.draw_target.push_clip(&path);
+        self.drawtarget.push_clip(&path);
     }
 
     pub fn is_point_in_path(
@@ -704,7 +704,7 @@ impl<'a> CanvasData<'a> {
         self.ensure_path();
         let result = match self.path_state.as_ref() {
             Some(PathState::UserSpacePath(ref path, ref transform)) => {
-                let target_transform = self.draw_target.get_transform();
+                let target_transform = self.drawtarget.get_transform();
                 let path_transform = transform.as_ref().unwrap_or(&target_transform);
                 path.contains_point(x, y, path_transform)
             },
@@ -724,7 +724,7 @@ impl<'a> CanvasData<'a> {
     fn path_builder(&mut self) -> PathBuilderRef {
         if self.path_state.is_none() {
             self.path_state = Some(PathState::UserSpacePathBuilder(
-                self.draw_target.create_path_builder(),
+                self.drawtarget.create_path_builder(),
                 None,
             ));
         }
@@ -766,7 +766,7 @@ impl<'a> CanvasData<'a> {
                 PathState::DeviceSpacePathBuilder(ref mut builder) => {
                     return PathBuilderRef {
                         builder,
-                        transform: self.draw_target.get_transform(),
+                        transform: self.drawtarget.get_transform(),
                     };
                 },
                 _ => unreachable!(),
@@ -780,7 +780,7 @@ impl<'a> CanvasData<'a> {
             },
             PathState::DeviceSpacePathBuilder(ref mut builder) => PathBuilderRef {
                 builder,
-                transform: self.draw_target.get_transform(),
+                transform: self.drawtarget.get_transform(),
             },
             PathState::UserSpacePathBuilder(..) | PathState::UserSpacePath(..) => unreachable!(),
         }
@@ -910,12 +910,12 @@ impl<'a> CanvasData<'a> {
 
     pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) {
         self.backend
-            .set_fill_style(style, &mut self.state, &*self.draw_target);
+            .set_fill_style(style, &mut self.state, &*self.drawtarget);
     }
 
     pub fn set_stroke_style(&mut self, style: FillOrStrokeStyle) {
         self.backend
-            .set_stroke_style(style, &mut self.state, &*self.draw_target);
+            .set_stroke_style(style, &mut self.state, &*self.drawtarget);
     }
 
     pub fn set_line_width(&mut self, width: f32) {
@@ -935,7 +935,7 @@ impl<'a> CanvasData<'a> {
     }
 
     pub fn get_transform(&self) -> Transform2D<f32> {
-        self.draw_target.get_transform()
+        self.drawtarget.get_transform()
     }
 
     pub fn set_transform(&mut self, transform: &Transform2D<f32>) {
@@ -946,12 +946,12 @@ impl<'a> CanvasData<'a> {
             Some(PathState::UserSpacePathBuilder(_, ref mut transform)) |
             Some(PathState::UserSpacePath(_, ref mut transform)) => {
                 if transform.is_none() {
-                    *transform = Some(self.draw_target.get_transform());
+                    *transform = Some(self.drawtarget.get_transform());
                 }
             },
         }
         self.state.transform = transform.clone();
-        self.draw_target.set_transform(transform)
+        self.drawtarget.set_transform(transform)
     }
 
     pub fn set_global_alpha(&mut self, alpha: f32) {
@@ -963,7 +963,7 @@ impl<'a> CanvasData<'a> {
     }
 
     pub fn recreate(&mut self, size: Size2D<u64>) {
-        self.draw_target = self
+        self.drawtarget = self
             .backend
             .create_drawtarget(Size2D::new(size.width, size.height));
         self.state = self.backend.recreate_paint_state(&self.state);
@@ -982,15 +982,15 @@ impl<'a> CanvasData<'a> {
     }
 
     pub fn send_pixels(&mut self, chan: IpcSender<IpcSharedMemory>) {
-        self.draw_target.snapshot_data(&|bytes| {
+        self.drawtarget.snapshot_data(&|bytes| {
             let data = IpcSharedMemory::from_bytes(bytes);
             chan.send(data).unwrap();
             vec![]
         });
     }
 
     pub fn send_data(&mut self, chan: IpcSender<CanvasImageData>) {
-        let size = self.draw_target.get_size();
+        let size = self.drawtarget.get_size();
 
         let descriptor = webrender_api::ImageDescriptor {
             size: webrender_api::units::DeviceIntSize::new(size.width, size.height),
@@ -999,7 +999,7 @@ impl<'a> CanvasData<'a> {
             offset: 0,
             flags: webrender_api::ImageDescriptorFlags::empty(),
         };
-        let data = self.draw_target.snapshot_data_owned();
+        let data = self.drawtarget.snapshot_data_owned();
         let data = webrender_api::ImageData::Raw(Arc::new(data));
 
         let mut updates = vec![];
@@ -1037,14 +1037,14 @@ impl<'a> CanvasData<'a> {
         assert_eq!(rect.size.area() as usize, imagedata.len() / 4);
         pixels::rgba8_byte_swap_and_premultiply_inplace(&mut imagedata);
         let source_surface = self
-            .draw_target
+            .drawtarget
             .create_source_surface_from_data(
                 &imagedata,
                 rect.size.to_i32(),
                 rect.size.width as i32 * 4,
             )
             .unwrap();
-        self.draw_target.copy_surface(
+        self.drawtarget.copy_surface(
             source_surface,
             Rect::from_size(rect.size.to_i32()),
             rect.origin.to_i32(),
@@ -1076,12 +1076,12 @@ impl<'a> CanvasData<'a> {
     }
 
     fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> Box<dyn GenericDrawTarget> {
-        let mut draw_target = self.draw_target.create_similar_draw_target(
+        let mut draw_target = self.drawtarget.create_similar_draw_target(
             &Size2D::new(
                 source_rect.size.width as i32,
                 source_rect.size.height as i32,
             ),
-            self.draw_target.get_format(),
+            self.drawtarget.get_format(),
         );
         let matrix = Transform2D::identity()
             .pre_translate(-source_rect.origin.to_vector().cast::<f32>())
@@ -1097,7 +1097,7 @@ impl<'a> CanvasData<'a> {
         let shadow_src_rect = self.state.transform.transform_rect(rect);
         let mut new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect);
         draw_shadow_source(&mut *new_draw_target);
-        self.draw_target.draw_surface_with_shadow(
+        self.drawtarget.draw_surface_with_shadow(
             new_draw_target.snapshot(),
             &Point2D::new(
                 shadow_src_rect.origin.x as f32,
@@ -1126,7 +1126,7 @@ impl<'a> CanvasData<'a> {
             return vec![];
         }
 
-        self.draw_target.snapshot_data(&|bytes| {
+        self.drawtarget.snapshot_data(&|bytes| {
             pixels::rgba8_get_rect(bytes, canvas_size, read_rect).into_owned()
         })
     }