Fill and stroke for all pattern types and check the zero size gradient.

components/canvas/canvas_paint_task.rs

@@ -250,6 +250,10 @@ impl<'a> CanvasPaintTask<'a> {
     }
 
     fn fill_rect(&self, rect: &Rect<f32>) {
+        if is_zero_size_gradient(&self.state.fill_style) {
+            return; // Paint nothing if gradient size is zero.
+        }
+
         let draw_rect = Rect::new(rect.origin,
             match self.state.fill_style {
                 Pattern::Surface(ref surface) => {
@@ -281,14 +285,19 @@ impl<'a> CanvasPaintTask<'a> {
     }
 
     fn stroke_rect(&self, rect: &Rect<f32>) {
-        match self.state.stroke_style {
-            Pattern::Color(ref color) => {
-                self.drawtarget.stroke_rect(rect, color, &self.state.stroke_opts, &self.state.draw_options)
-            }
-            _ => {
-                // TODO(pcwalton)
-            }
-        };
+        if is_zero_size_gradient(&self.state.stroke_style) {
+            return; // Paint nothing if gradient size is zero.
+        }
+
+        if self.need_to_draw_shadow() {
+            self.draw_with_shadow(&rect, |new_draw_target: &DrawTarget| {
+                new_draw_target.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(),
+                                            &self.state.stroke_opts, &self.state.draw_options);
+            });
+        } else {
+            self.drawtarget.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(),
+                                        &self.state.stroke_opts, &self.state.draw_options);
+        }
     }
 
     fn begin_path(&mut self) {
@@ -300,26 +309,24 @@ impl<'a> CanvasPaintTask<'a> {
     }
 
     fn fill(&self) {
-        match self.state.fill_style {
-            Pattern::Color(ref color) => {
-                self.drawtarget.fill(&self.path_builder.finish(), color, &self.state.draw_options);
-            }
-            _ => {
-                // TODO(pcwalton)
-            }
-        };
+        if is_zero_size_gradient(&self.state.fill_style) {
+            return; // Paint nothing if gradient size is zero.
+        }
+
+        self.drawtarget.fill(&self.path_builder.finish(),
+                             self.state.fill_style.to_pattern_ref(),
+                             &self.state.draw_options);
     }
 
     fn stroke(&self) {
-        match self.state.stroke_style {
-            Pattern::Color(ref color) => {
-                self.drawtarget.stroke(&self.path_builder.finish(),
-                                       color, &self.state.stroke_opts, &self.state.draw_options);
-            }
-            _ => {
-                // TODO
-            }
-        };
+        if is_zero_size_gradient(&self.state.stroke_style) {
+            return; // Paint nothing if gradient size is zero.
+        }
+
+        self.drawtarget.stroke(&self.path_builder.finish(),
+                               self.state.stroke_style.to_pattern_ref(),
+                               &self.state.stroke_opts,
+                               &self.state.draw_options);
     }
 
     fn clip(&self) {
@@ -733,6 +740,15 @@ fn write_pixels(draw_target: &DrawTarget,
                              draw_options);
 }
 
+fn is_zero_size_gradient(pattern: &Pattern) -> bool {
+    if let &Pattern::LinearGradient(ref gradient) = pattern {
+        if gradient.is_zero_size() {
+            return true;
+        }
+    }
+    return false;
+}
+
 pub trait SizeToi32 {
     fn to_i32(&self) -> Size2D<i32>;
 }

components/gfx/paint_context.rs

@@ -19,7 +19,7 @@ use azure::azure_hl::{DrawOptions, DrawSurfaceOptions, DrawTarget, ExtendMode, F
 use azure::azure_hl::{GaussianBlurAttribute, StrokeOptions, SurfaceFormat};
 use azure::azure_hl::{GaussianBlurInput, GradientStop, Filter, FilterNode, LinearGradientPattern};
 use azure::azure_hl::{JoinStyle, CapStyle};
-use azure::azure_hl::{PatternRef, Path, PathBuilder, CompositionOp, AntialiasMode};
+use azure::azure_hl::{Pattern, PatternRef, Path, PathBuilder, CompositionOp, AntialiasMode};
 use azure::scaled_font::ScaledFont;
 use azure::{AzFloat, struct__AzDrawOptions, struct__AzGlyph};
 use azure::{struct__AzGlyphBuffer, struct__AzPoint, AzDrawTargetFillGlyphs};
@@ -291,7 +291,9 @@ impl<'a> PaintContext<'a> {
         let mut path_builder = self.draw_target.create_path_builder();
         self.create_border_path_segment(&mut path_builder, bounds, direction, border, radii);
         let draw_options = DrawOptions::new(1.0, CompositionOp::Over, AntialiasMode::None);
-        self.draw_target.fill(&path_builder.finish(), &ColorPattern::new(color), &draw_options);
+        self.draw_target.fill(&path_builder.finish(),
+                              Pattern::Color(ColorPattern::new(color)).to_pattern_ref(),
+                              &draw_options);
     }
 
     fn push_rounded_rect_clip(&self, bounds: &Rect<f32>, radii: &BorderRadii<AzFloat>) {
@@ -1023,7 +1025,7 @@ impl<'a> PaintContext<'a> {
 
         // Draw the shadow, and blur if we need to.
         temporary_draw_target.draw_target.fill(&path,
-                                               &ColorPattern::new(color),
+                                               Pattern::Color(ColorPattern::new(color)).to_pattern_ref(),
                                                &DrawOptions::new(1.0, CompositionOp::Over, AntialiasMode::None));
         self.blur_if_necessary(temporary_draw_target, blur_radius);