stylo: Create error reporters linked to documents (bug 1352669)

components/layout_thread/lib.rs

@@ -219,9 +219,6 @@ pub struct LayoutThread {
     /// All the other elements of this struct are read-only.
     rw_data: Arc<Mutex<LayoutThreadData>>,
 
-    /// The CSS error reporter for all CSS loaded in this layout thread
-    error_reporter: CSSErrorReporter,
-
     webrender_image_cache: Arc<RwLock<FnvHashMap<(ServoUrl, UsePlaceholder),
                                                  WebRenderImageInfo>>>,
     /// The executor for paint worklets.
@@ -532,10 +529,6 @@ impl LayoutThread {
                     text_index_response: TextIndexResponse(None),
                     nodes_from_point_response: vec![],
                 })),
-            error_reporter: CSSErrorReporter {
-                pipelineid: id,
-                script_chan: Arc::new(Mutex::new(script_chan)),
-            },
             webrender_image_cache:
                 Arc::new(RwLock::new(FnvHashMap::default())),
             timer:
@@ -580,7 +573,6 @@ impl LayoutThread {
                 guards: guards,
                 running_animations: self.running_animations.clone(),
                 expired_animations: self.expired_animations.clone(),
-                error_reporter: &self.error_reporter,
                 local_context_creation_data: Mutex::new(thread_local_style_context_creation_data),
                 timer: self.timer.clone(),
                 quirks_mode: self.quirks_mode.unwrap(),

components/style/animation.rs

@@ -508,7 +508,6 @@ fn compute_style_for_animation_step(context: &SharedStyleContext,
                                                previous_style,
                                                /* cascade_info = */ None,
                                                /* visited_style = */ None,
-                                               &*context.error_reporter,
                                                font_metrics_provider,
                                                CascadeFlags::empty(),
                                                context.quirks_mode);

components/style/context.rs

@@ -12,7 +12,6 @@ use bloom::StyleBloom;
 use cache::LRUCache;
 use data::{EagerPseudoStyles, ElementData};
 use dom::{OpaqueNode, TNode, TElement, SendElement};
-use error_reporting::ParseErrorReporter;
 use euclid::Size2D;
 use fnv::FnvHashMap;
 use font_metrics::FontMetricsProvider;
@@ -122,9 +121,6 @@ pub struct SharedStyleContext<'a> {
     /// Guards for pre-acquired locks
     pub guards: StylesheetGuards<'a>,
 
-    ///The CSS error reporter for all CSS loaded in this layout thread
-    pub error_reporter: &'a ParseErrorReporter,
-
     /// The current timer for transitions and animations. This is needed to test
     /// them.
     pub timer: Timer,

components/style/error_reporting.rs

@@ -139,7 +139,7 @@ impl<'a> ContextualParseError<'a> {
 }
 
 /// A generic trait for an error reporter.
-pub trait ParseErrorReporter : Sync {
+pub trait ParseErrorReporter {
     /// Called when the style engine detects an error.
     ///
     /// Returns the current input being parsed, the source position it was
@@ -188,8 +188,3 @@ impl ParseErrorReporter for NullReporter {
         // do nothing
     }
 }
-
-/// Create an instance of the default error reporter.
-pub fn create_error_reporter() -> RustLogReporter {
-    RustLogReporter
-}

components/style/gecko/generated/bindings.rs

@@ -6,6 +6,7 @@ use gecko_bindings::structs::nsTArray;
 type nsACString_internal = nsACString;
 type nsAString_internal = nsAString;
 use gecko_bindings::structs::mozilla::css::GridTemplateAreasValue;
+use gecko_bindings::structs::mozilla::css::ErrorReporter;
 use gecko_bindings::structs::mozilla::css::ImageValue;
 use gecko_bindings::structs::mozilla::css::URLValue;
 use gecko_bindings::structs::mozilla::css::URLValueData;
@@ -71,6 +72,7 @@ use gecko_bindings::structs::nsChangeHint;
 use gecko_bindings::structs::nsCursorImage;
 use gecko_bindings::structs::nsFont;
 use gecko_bindings::structs::nsIAtom;
+use gecko_bindings::structs::nsIURI;
 use gecko_bindings::structs::nsCompatibility;
 use gecko_bindings::structs::nsMediaFeature;
 use gecko_bindings::structs::nsRestyleHint;
@@ -2262,7 +2264,8 @@ extern "C" {
                                value: *const nsACString,
                                data: *mut RawGeckoURLExtraData,
                                parsing_mode: ParsingMode,
-                               quirks_mode: nsCompatibility)
+                               quirks_mode: nsCompatibility,
+                               loader: *mut Loader)
      -> RawServoDeclarationBlockStrong;
 }
 extern "C" {
@@ -2411,7 +2414,8 @@ extern "C" {
 extern "C" {
     pub fn Servo_ParseStyleAttribute(data: *const nsACString,
                                      extra_data: *mut RawGeckoURLExtraData,
-                                     quirks_mode: nsCompatibility)
+                                     quirks_mode: nsCompatibility,
+                                     loader: *mut Loader)
      -> RawServoDeclarationBlockStrong;
 }
 extern "C" {
@@ -2480,8 +2484,8 @@ extern "C" {
                                               is_important: bool,
                                               data: *mut RawGeckoURLExtraData,
                                               parsing_mode: ParsingMode,
-                                              quirks_mode: nsCompatibility)
+                                              quirks_mode: nsCompatibility,
-     -> bool;
+                                              loader: *mut Loader) -> bool;
 }
 extern "C" {
     pub fn Servo_DeclarationBlock_SetPropertyById(declarations:
@@ -2493,7 +2497,8 @@ extern "C" {
                                                       *mut RawGeckoURLExtraData,
                                                   parsing_mode: ParsingMode,
                                                   quirks_mode:
-                                                      nsCompatibility)
+                                                      nsCompatibility,
+                                                  loader: *mut Loader)
      -> bool;
 }
 extern "C" {
@@ -2891,3 +2896,23 @@ extern "C" {
                                      ServoComputedValuesBorrowedOrNull)
      -> *const nsStyleEffects;
 }
+extern "C" {
+    pub fn Gecko_CreateCSSErrorReporter(sheet: *mut ServoStyleSheet,
+                                        loader: *mut Loader, uri: *mut nsIURI)
+     -> *mut ErrorReporter;
+}
+extern "C" {
+    pub fn Gecko_DestroyCSSErrorReporter(reporter: *mut ErrorReporter);
+}
+extern "C" {
+    pub fn Gecko_ReportUnexpectedCSSError(reporter: *mut ErrorReporter,
+                                          message:
+                                              *const ::std::os::raw::c_char,
+                                          param:
+                                              *const ::std::os::raw::c_char,
+                                          paramLen: u32,
+                                          source:
+                                              *const ::std::os::raw::c_char,
+                                          sourceLen: u32, lineNumber: u32,
+                                          colNumber: u32, aURI: *mut nsIURI);
+}

components/style/gecko/wrapper.rs

@@ -23,7 +23,7 @@ use data::ElementData;
 use dom::{self, DescendantsBit, LayoutIterator, NodeInfo, TElement, TNode, UnsafeNode};
 use dom::{OpaqueNode, PresentationalHintsSynthesizer};
 use element_state::{ElementState, DocumentState, NS_DOCUMENT_STATE_WINDOW_INACTIVE};
-use error_reporting::create_error_reporter;
+use error_reporting::ParseErrorReporter;
 use font_metrics::{FontMetrics, FontMetricsProvider, FontMetricsQueryResult};
 use gecko::data::PerDocumentStyleData;
 use gecko::global_style_data::GLOBAL_STYLE_DATA;
@@ -478,8 +478,9 @@ impl<'le> GeckoElement<'le> {
     /// Parse the style attribute of an element.
     pub fn parse_style_attribute(value: &str,
                                  url_data: &UrlExtraData,
-                                 quirks_mode: QuirksMode) -> PropertyDeclarationBlock {
+                                 quirks_mode: QuirksMode,
-        parse_style_attribute(value, url_data, &create_error_reporter(), quirks_mode)
+                                 reporter: &ParseErrorReporter) -> PropertyDeclarationBlock {
+        parse_style_attribute(value, url_data, reporter, quirks_mode)
     }
 
     fn flags(&self) -> u32 {

components/style/matching.rs

@@ -401,7 +401,6 @@ trait PrivateMatchMethods: TElement {
                              layout_parent_style,
                              visited_values_to_insert,
                              Some(&mut cascade_info),
-                             &*shared_context.error_reporter,
                              font_metrics_provider,
                              cascade_flags,
                              shared_context.quirks_mode));

components/style/properties/helpers.mako.rs

@@ -314,8 +314,7 @@
                                 default_style: &ComputedValues,
                                 context: &mut computed::Context,
                                 cacheable: &mut bool,
-                                cascade_info: &mut Option<<&mut CascadeInfo>,
+                                cascade_info: &mut Option<<&mut CascadeInfo>) {
-                                error_reporter: &ParseErrorReporter) {
             let declared_value = match *declaration {
                 PropertyDeclaration::${property.camel_case}(ref value) => {
                     DeclaredValue::Value(value)
@@ -424,15 +423,14 @@
                                 }
                             }
                         }
-                    }, error_reporter, quirks_mode);
+                    }, quirks_mode);
                 }
 
                 % if property.custom_cascade:
                     cascade_property_custom(declaration,
                                             inherited_style,
                                             context,
-                                            cacheable,
+                                            cacheable);
-                                            error_reporter);
                 % endif
             % else:
                 // Do not allow stylesheets to set derived properties.

components/style/properties/helpers/animated_properties.mako.rs

@@ -523,7 +523,6 @@ impl AnimationValue {
     /// Construct an AnimationValue from a property declaration
     pub fn from_declaration(decl: &PropertyDeclaration, context: &mut Context,
                             initial: &ComputedValues) -> Option<Self> {
-        use error_reporting::create_error_reporter;
         use properties::LonghandId;
         use properties::DeclaredValue;
 
@@ -587,7 +586,6 @@ impl AnimationValue {
             },
             PropertyDeclaration::WithVariables(id, ref variables) => {
                 let custom_props = context.style().custom_properties();
-                let reporter = create_error_reporter();
                 match id {
                     % for prop in data.longhands:
                     % if prop.animatable:
@@ -612,7 +610,6 @@ impl AnimationValue {
                                 };
                                 result = AnimationValue::from_declaration(&declaration, context, initial);
                             },
-                            &reporter,
                             quirks_mode);
                         result
                     },

components/style/properties/longhand/box.mako.rs

@@ -136,8 +136,7 @@
         fn cascade_property_custom(_declaration: &PropertyDeclaration,
                                    _inherited_style: &ComputedValues,
                                    context: &mut computed::Context,
-                                   _cacheable: &mut bool,
+                                   _cacheable: &mut bool) {
-                                   _error_reporter: &ParseErrorReporter) {
             longhands::_servo_display_for_hypothetical_box::derive_from_display(context);
             longhands::_servo_text_decorations_in_effect::derive_from_display(context);
             longhands::_servo_under_display_none::derive_from_display(context);

components/style/properties/longhand/text.mako.rs

@@ -261,8 +261,7 @@ ${helpers.single_keyword("unicode-bidi",
         fn cascade_property_custom(_declaration: &PropertyDeclaration,
                                    _inherited_style: &ComputedValues,
                                    context: &mut computed::Context,
-                                   _cacheable: &mut bool,
+                                   _cacheable: &mut bool) {
-                                   _error_reporter: &ParseErrorReporter) {
             longhands::_servo_text_decorations_in_effect::derive_from_text_decoration(context);
         }
     % endif

components/style/properties/properties.mako.rs

@@ -21,10 +21,10 @@ use app_units::Au;
 #[cfg(feature = "servo")] use cssparser::RGBA;
 use cssparser::{Parser, TokenSerializationType, serialize_identifier};
 use cssparser::{ParserInput, CompactCowStr};
-use error_reporting::ParseErrorReporter;
 #[cfg(feature = "servo")] use euclid::SideOffsets2D;
 use computed_values;
 use context::QuirksMode;
+use error_reporting::NullReporter;
 use font_metrics::FontMetricsProvider;
 #[cfg(feature = "gecko")] use gecko_bindings::bindings;
 #[cfg(feature = "gecko")] use gecko_bindings::structs::{self, nsCSSPropertyID};
@@ -377,7 +377,6 @@ impl PropertyDeclarationIdSet {
             % endif
             custom_properties: &Option<Arc<::custom_properties::CustomPropertiesMap>>,
             f: &mut F,
-            error_reporter: &ParseErrorReporter,
             quirks_mode: QuirksMode)
             % if property.boxed:
                 where F: FnMut(&DeclaredValue<Box<longhands::${property.ident}::SpecifiedValue>>)
@@ -392,7 +391,6 @@ impl PropertyDeclarationIdSet {
                                                             with_variables.from_shorthand,
                                                             custom_properties,
                                                             f,
-                                                            error_reporter,
                                                             quirks_mode);
             } else {
                 f(value);
@@ -408,7 +406,6 @@ impl PropertyDeclarationIdSet {
                 from_shorthand: Option<ShorthandId>,
                 custom_properties: &Option<Arc<::custom_properties::CustomPropertiesMap>>,
                 f: &mut F,
-                error_reporter: &ParseErrorReporter,
                 quirks_mode: QuirksMode)
                 % if property.boxed:
                     where F: FnMut(&DeclaredValue<Box<longhands::${property.ident}::SpecifiedValue>>)
@@ -421,12 +418,10 @@ impl PropertyDeclarationIdSet {
                 .ok()
                 .and_then(|css| {
                     // As of this writing, only the base URL is used for property values:
-                    //
+                    let reporter = NullReporter;
-                    // FIXME(pcwalton): Cloning the error reporter is slow! But so are custom
-                    // properties, so whatever...
                     let context = ParserContext::new(Origin::Author,
                                                      url_data,
-                                                     error_reporter,
+                                                     &reporter,
                                                      None,
                                                      PARSING_MODE_DEFAULT,
                                                      quirks_mode);
@@ -2514,8 +2509,7 @@ pub type CascadePropertyFn =
                      default_style: &ComputedValues,
                      context: &mut computed::Context,
                      cacheable: &mut bool,
-                     cascade_info: &mut Option<<&mut CascadeInfo>,
+                     cascade_info: &mut Option<<&mut CascadeInfo>);
-                     error_reporter: &ParseErrorReporter);
 
 /// A per-longhand array of functions to perform the CSS cascade on each of
 /// them, effectively doing virtual dispatch.
@@ -2577,7 +2571,6 @@ pub fn cascade(device: &Device,
                layout_parent_style: Option<<&ComputedValues>,
                visited_style: Option<Arc<ComputedValues>>,
                cascade_info: Option<<&mut CascadeInfo>,
-               error_reporter: &ParseErrorReporter,
                font_metrics_provider: &FontMetricsProvider,
                flags: CascadeFlags,
                quirks_mode: QuirksMode)
@@ -2625,7 +2618,6 @@ pub fn cascade(device: &Device,
                        layout_parent_style,
                        visited_style,
                        cascade_info,
-                       error_reporter,
                        font_metrics_provider,
                        flags,
                        quirks_mode)
@@ -2641,7 +2633,6 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
                                     layout_parent_style: &ComputedValues,
                                     visited_style: Option<Arc<ComputedValues>>,
                                     mut cascade_info: Option<<&mut CascadeInfo>,
-                                    error_reporter: &ParseErrorReporter,
                                     font_metrics_provider: &FontMetricsProvider,
                                     flags: CascadeFlags,
                                     quirks_mode: QuirksMode)
@@ -2795,8 +2786,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
                                              default_style,
                                              &mut context,
                                              &mut cacheable,
-                                             &mut cascade_info,
+                                             &mut cascade_info);
-                                             error_reporter);
         }
         % if category_to_cascade_now == "early":
             let writing_mode = get_writing_mode(context.style.get_inheritedbox());
@@ -2869,8 +2859,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
                                                      default_style,
                                                      &mut context,
                                                      &mut cacheable,
-                                                     &mut cascade_info,
+                                                     &mut cascade_info);
-                                                     error_reporter);
                     % if product == "gecko":
                         context.style.mutate_font().fixup_none_generic(context.device);
                     % endif
@@ -2884,8 +2873,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
                                                  default_style,
                                                  &mut context,
                                                  &mut cacheable,
-                                                 &mut cascade_info,
+                                                 &mut cascade_info);
-                                                 error_reporter);
             % if product == "gecko":
             // Font size must be explicitly inherited to handle lang changes and
             // scriptlevel changes.
@@ -2902,8 +2890,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
                                                  default_style,
                                                  &mut context,
                                                  &mut cacheable,
-                                                 &mut cascade_info,
+                                                 &mut cascade_info);
-                                                 error_reporter);
             % endif
             }
         % endif

components/style/stylist.rs

@@ -10,7 +10,6 @@ use bit_vec::BitVec;
 use context::{CascadeInputs, QuirksMode};
 use dom::TElement;
 use element_state::ElementState;
-use error_reporting::create_error_reporter;
 use font_metrics::FontMetricsProvider;
 #[cfg(feature = "gecko")]
 use gecko_bindings::structs::{nsIAtom, StyleRuleInclusion};
@@ -639,7 +638,6 @@ impl Stylist {
                                 parent.map(|p| &**p),
                                 None,
                                 None,
-                                &create_error_reporter(),
                                 font_metrics,
                                 cascade_flags,
                                 self.quirks_mode);
@@ -748,7 +746,6 @@ impl Stylist {
                                     Some(inherited_style),
                                     None,
                                     None,
-                                    &create_error_reporter(),
                                     font_metrics,
                                     CascadeFlags::empty(),
                                     self.quirks_mode);
@@ -780,7 +777,6 @@ impl Stylist {
                                 Some(parent_style),
                                 visited_values,
                                 None,
-                                &create_error_reporter(),
                                 font_metrics,
                                 CascadeFlags::empty(),
                                 self.quirks_mode);
@@ -1367,7 +1363,6 @@ impl Stylist {
                                      Some(parent_style),
                                      None,
                                      None,
-                                     &create_error_reporter(),
                                      &metrics,
                                      CascadeFlags::empty(),
                                      self.quirks_mode))

ports/geckolib/error_reporter.rs

@@ -0,0 +1,97 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+//! Wrapper around Gecko's CSS error reporting mechanism.
+
+#![allow(unsafe_code)]
+
+use cssparser::{Parser, SourcePosition};
+use style::error_reporting::{ParseErrorReporter, ContextualParseError};
+use style::gecko_bindings::bindings::{Gecko_CreateCSSErrorReporter, Gecko_DestroyCSSErrorReporter};
+use style::gecko_bindings::bindings::Gecko_ReportUnexpectedCSSError;
+use style::gecko_bindings::structs::{Loader, ServoStyleSheet, nsIURI};
+use style::gecko_bindings::structs::ErrorReporter as GeckoErrorReporter;
+use style::gecko_bindings::structs::URLExtraData as RawUrlExtraData;
+use style::gecko_bindings::sugar::refptr::RefPtr;
+use style::stylesheets::UrlExtraData;
+
+/// Wrapper around an instance of Gecko's CSS error reporter.
+pub struct ErrorReporter(*mut GeckoErrorReporter);
+
+impl ErrorReporter {
+    /// Create a new instance of the Gecko error reporter.
+    pub fn new(sheet: *mut ServoStyleSheet,
+               loader: *mut Loader,
+               url: *mut RawUrlExtraData) -> ErrorReporter {
+        unsafe {
+            let url = RefPtr::from_ptr_ref(&url);
+            ErrorReporter(Gecko_CreateCSSErrorReporter(sheet, loader, url.mBaseURI.raw::<nsIURI>()))
+        }
+    }
+}
+
+impl Drop for ErrorReporter {
+    fn drop(&mut self) {
+        unsafe {
+            Gecko_DestroyCSSErrorReporter(self.0);
+        }
+    }
+}
+
+trait ErrorHelpers<'a> {
+    fn to_gecko_message(&self) -> (&'static [u8], &'a str);
+}
+
+impl<'a> ErrorHelpers<'a> for ContextualParseError<'a> {
+    fn to_gecko_message(&self) -> (&'static [u8], &'a str) {
+        match *self {
+            ContextualParseError::UnsupportedPropertyDeclaration(decl, _) =>
+                (b"PEUnknownProperty\0", decl),
+            ContextualParseError::UnsupportedFontFaceDescriptor(decl, _) =>
+                (b"PEUnknwnFontDesc\0", decl),
+            ContextualParseError::InvalidKeyframeRule(rule, _) =>
+                (b"PEKeyframeBadName\0", rule),
+            ContextualParseError::UnsupportedKeyframePropertyDeclaration(decl, _) =>
+                (b"PEBadSelectorKeyframeRuleIgnored\0", decl),
+            ContextualParseError::InvalidRule(rule, _) =>
+                (b"PEDeclDropped\0", rule),
+            ContextualParseError::UnsupportedRule(rule, _) =>
+                (b"PEDeclDropped\0", rule),
+            ContextualParseError::UnsupportedViewportDescriptorDeclaration(..) |
+            ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(..) |
+            ContextualParseError::InvalidCounterStyleWithoutSymbols(..) |
+            ContextualParseError::InvalidCounterStyleNotEnoughSymbols(..) |
+            ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols |
+            ContextualParseError::InvalidCounterStyleExtendsWithSymbols |
+            ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols =>
+                (b"PEUnknownAtRule\0", ""),
+        }
+    }
+}
+
+impl ParseErrorReporter for ErrorReporter {
+    fn report_error<'a>(&self,
+                        input: &mut Parser,
+                        position: SourcePosition,
+                        error: ContextualParseError<'a>,
+                        url: &UrlExtraData,
+                        line_number_offset: u64) {
+        let location = input.source_location(position);
+        let line_number = location.line + line_number_offset as u32;
+
+        let (name, param) = error.to_gecko_message();
+        let source = "";
+        unsafe {
+            Gecko_ReportUnexpectedCSSError(self.0,
+                                           name.as_ptr() as *const _,
+                                           param.as_ptr() as *const _,
+                                           param.len() as u32,
+                                           source.as_ptr() as *const _,
+                                           source.len() as u32,
+                                           line_number as u32,
+                                           location.column as u32,
+                                           url.mBaseURI.raw::<nsIURI>());
+        }
+    }
+}

ports/geckolib/glue.rs

@@ -17,7 +17,7 @@ use style::data::{ElementData, ElementStyles, RestyleData};
 use style::dom::{AnimationOnlyDirtyDescendants, DirtyDescendants};
 use style::dom::{ShowSubtreeData, TElement, TNode};
 use style::element_state::ElementState;
-use style::error_reporting::RustLogReporter;
+use style::error_reporting::{NullReporter, ParseErrorReporter};
 use style::font_metrics::{FontMetricsProvider, get_metrics_provider_for_product};
 use style::gecko::data::{GeckoStyleSheet, PerDocumentStyleData, PerDocumentStyleDataImpl};
 use style::gecko::global_style_data::{GLOBAL_STYLE_DATA, GlobalStyleData, STYLE_THREAD_POOL};
@@ -118,6 +118,7 @@ use style::traversal::{resolve_style, resolve_default_style};
 use style::values::{CustomIdent, KeyframesName};
 use style::values::computed::Context;
 use style_traits::{PARSING_MODE_DEFAULT, ToCss};
+use super::error_reporter::ErrorReporter;
 use super::stylesheet_loader::StylesheetLoader;
 
 /*
@@ -172,8 +173,6 @@ unsafe fn dummy_url_data() -> &'static RefPtr<URLExtraData> {
     RefPtr::from_ptr_ref(&DUMMY_URL_DATA)
 }
 
-static DEFAULT_ERROR_REPORTER: RustLogReporter = RustLogReporter;
-
 fn create_shared_context<'a>(global_style_data: &GlobalStyleData,
                              guard: &'a SharedRwLockReadGuard,
                              per_doc_data: &'a PerDocumentStyleDataImpl,
@@ -184,7 +183,6 @@ fn create_shared_context<'a>(global_style_data: &GlobalStyleData,
         stylist: &per_doc_data.stylist,
         options: global_style_data.options.clone(),
         guards: StylesheetGuards::same(guard),
-        error_reporter: &DEFAULT_ERROR_REPORTER,
         timer: Timer::new(),
         quirks_mode: per_doc_data.stylist.quirks_mode(),
         traversal_flags: traversal_flags,
@@ -755,7 +753,7 @@ pub extern "C" fn Servo_StyleSheet_Empty(mode: SheetParsingMode) -> RawServoStyl
             origin,
             shared_lock,
             /* loader = */ None,
-            &RustLogReporter,
+            &NullReporter,
             QuirksMode::NoQuirks,
             0
         )
@@ -782,6 +780,7 @@ pub extern "C" fn Servo_StyleSheet_FromUTF8Bytes(
         SheetParsingMode::eSafeAgentSheetFeatures => Origin::UserAgent,
     };
 
+    let reporter = ErrorReporter::new(stylesheet, loader, extra_data);
     let url_data = unsafe { RefPtr::from_ptr_ref(&extra_data) };
     let loader = if loader.is_null() {
         None
@@ -798,7 +797,7 @@ pub extern "C" fn Servo_StyleSheet_FromUTF8Bytes(
 
     Arc::new(StylesheetContents::from_str(
         input, url_data.clone(), origin,
-        &global_style_data.shared_lock, loader, &RustLogReporter,
+        &global_style_data.shared_lock, loader, &reporter,
         quirks_mode.into(), line_number_offset as u64)
     ).into_strong()
 }
@@ -1775,7 +1774,8 @@ fn parse_property_into(declarations: &mut SourcePropertyDeclaration,
                        value: *const nsACString,
                        data: *mut URLExtraData,
                        parsing_mode: structs::ParsingMode,
-                       quirks_mode: QuirksMode) -> Result<(), ()> {
+                       quirks_mode: QuirksMode,
+                       reporter: &ParseErrorReporter) -> Result<(), ()> {
     use style_traits::ParsingMode;
     let value = unsafe { value.as_ref().unwrap().as_str_unchecked() };
     let url_data = unsafe { RefPtr::from_ptr_ref(&data) };
@@ -1786,7 +1786,7 @@ fn parse_property_into(declarations: &mut SourcePropertyDeclaration,
         property_id,
         value,
         url_data,
-        &RustLogReporter,
+        reporter,
         parsing_mode,
         quirks_mode)
 }
@@ -1795,13 +1795,15 @@ fn parse_property_into(declarations: &mut SourcePropertyDeclaration,
 pub extern "C" fn Servo_ParseProperty(property: nsCSSPropertyID, value: *const nsACString,
                                       data: *mut URLExtraData,
                                       parsing_mode: structs::ParsingMode,
-                                      quirks_mode: nsCompatibility)
+                                      quirks_mode: nsCompatibility,
+                                      loader: *mut Loader)
                                       -> RawServoDeclarationBlockStrong {
     let id = get_property_id_from_nscsspropertyid!(property,
                                                    RawServoDeclarationBlockStrong::null());
     let mut declarations = SourcePropertyDeclaration::new();
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, data);
     match parse_property_into(&mut declarations, id, value, data,
-                              parsing_mode, quirks_mode.into()) {
+                              parsing_mode, quirks_mode.into(), &reporter) {
         Ok(()) => {
             let global_style_data = &*GLOBAL_STYLE_DATA;
             let mut block = PropertyDeclarationBlock::new();
@@ -1820,7 +1822,7 @@ pub extern "C" fn Servo_ParseEasing(easing: *const nsAString,
     use style::properties::longhands::transition_timing_function;
 
     let url_data = unsafe { RefPtr::from_ptr_ref(&data) };
-    let reporter = RustLogReporter;
+    let reporter = NullReporter;
     let context = ParserContext::new(Origin::Author,
                                      url_data,
                                      &reporter,
@@ -1897,13 +1899,16 @@ pub extern "C" fn Servo_MatrixTransform_Operate(matrix_operator: MatrixTransform
 #[no_mangle]
 pub extern "C" fn Servo_ParseStyleAttribute(data: *const nsACString,
                                             raw_extra_data: *mut URLExtraData,
-                                            quirks_mode: nsCompatibility)
+                                            quirks_mode: nsCompatibility,
+                                            loader: *mut Loader)
                                             -> RawServoDeclarationBlockStrong {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let value = unsafe { data.as_ref().unwrap().as_str_unchecked() };
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, raw_extra_data);
     let url_data = unsafe { RefPtr::from_ptr_ref(&raw_extra_data) };
     Arc::new(global_style_data.shared_lock.wrap(
-        GeckoElement::parse_style_attribute(value, url_data, quirks_mode.into()))).into_strong()
+        GeckoElement::parse_style_attribute(value, url_data, quirks_mode.into(), &reporter)))
+        .into_strong()
 }
 
 #[no_mangle]
@@ -2043,10 +2048,12 @@ pub extern "C" fn Servo_DeclarationBlock_GetPropertyIsImportant(declarations: Ra
 fn set_property(declarations: RawServoDeclarationBlockBorrowed, property_id: PropertyId,
                 value: *const nsACString, is_important: bool, data: *mut URLExtraData,
                 parsing_mode: structs::ParsingMode,
-                quirks_mode: QuirksMode) -> bool {
+                quirks_mode: QuirksMode,
+                loader: *mut Loader) -> bool {
     let mut source_declarations = SourcePropertyDeclaration::new();
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, data);
     match parse_property_into(&mut source_declarations, property_id, value, data,
-                              parsing_mode, quirks_mode) {
+                              parsing_mode, quirks_mode, &reporter) {
         Ok(()) => {
             let importance = if is_important { Importance::Important } else { Importance::Normal };
             write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
@@ -2062,9 +2069,10 @@ pub extern "C" fn Servo_DeclarationBlock_SetProperty(declarations: RawServoDecla
                                                      property: *const nsACString, value: *const nsACString,
                                                      is_important: bool, data: *mut URLExtraData,
                                                      parsing_mode: structs::ParsingMode,
-                                                     quirks_mode: nsCompatibility) -> bool {
+                                                     quirks_mode: nsCompatibility,
+                                                     loader: *mut Loader) -> bool {
     set_property(declarations, get_property_id_from_property!(property, false),
-                 value, is_important, data, parsing_mode, quirks_mode.into())
+                 value, is_important, data, parsing_mode, quirks_mode.into(), loader)
 }
 
 #[no_mangle]
@@ -2072,9 +2080,10 @@ pub extern "C" fn Servo_DeclarationBlock_SetPropertyById(declarations: RawServoD
                                                          property: nsCSSPropertyID, value: *const nsACString,
                                                          is_important: bool, data: *mut URLExtraData,
                                                          parsing_mode: structs::ParsingMode,
-                                                         quirks_mode: nsCompatibility) -> bool {
+                                                         quirks_mode: nsCompatibility,
+                                                         loader: *mut Loader) -> bool {
     set_property(declarations, get_property_id_from_nscsspropertyid!(property, false),
-                 value, is_important, data, parsing_mode, quirks_mode.into())
+                 value, is_important, data, parsing_mode, quirks_mode.into(), loader)
 }
 
 fn remove_property(declarations: RawServoDeclarationBlockBorrowed, property_id: PropertyId) {
@@ -2142,7 +2151,7 @@ pub extern "C" fn Servo_MediaList_SetText(list: RawServoMediaListBorrowed, text:
     let mut input = ParserInput::new(&text);
     let mut parser = Parser::new(&mut input);
     let url_data = unsafe { dummy_url_data() };
-    let reporter = RustLogReporter;
+    let reporter = NullReporter;
     let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
                                                PARSING_MODE_DEFAULT,
                                                QuirksMode::NoQuirks);
@@ -2174,7 +2183,7 @@ pub extern "C" fn Servo_MediaList_AppendMedium(list: RawServoMediaListBorrowed,
                                                new_medium: *const nsACString) {
     let new_medium = unsafe { new_medium.as_ref().unwrap().as_str_unchecked() };
     let url_data = unsafe { dummy_url_data() };
-    let reporter = RustLogReporter;
+    let reporter = NullReporter;
     let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
                                                PARSING_MODE_DEFAULT,
                                                QuirksMode::NoQuirks);
@@ -2188,7 +2197,7 @@ pub extern "C" fn Servo_MediaList_DeleteMedium(list: RawServoMediaListBorrowed,
                                                old_medium: *const nsACString) -> bool {
     let old_medium = unsafe { old_medium.as_ref().unwrap().as_str_unchecked() };
     let url_data = unsafe { dummy_url_data() };
-    let reporter = RustLogReporter;
+    let reporter = NullReporter;
     let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
                                                PARSING_MODE_DEFAULT,
                                                QuirksMode::NoQuirks);
@@ -2554,7 +2563,7 @@ pub extern "C" fn Servo_DeclarationBlock_SetBackgroundImage(declarations:
 
     let url_data = unsafe { RefPtr::from_ptr_ref(&raw_extra_data) };
     let string = unsafe { (*value).to_string() };
-    let error_reporter = RustLogReporter;
+    let error_reporter = NullReporter;
     let context = ParserContext::new(Origin::Author, url_data, &error_reporter,
                                      Some(CssRuleType::Style), PARSING_MODE_DEFAULT,
                                      QuirksMode::NoQuirks);
@@ -2595,7 +2604,8 @@ pub extern "C" fn Servo_CSSSupports2(property: *const nsACString,
         value,
         unsafe { DUMMY_URL_DATA },
         structs::ParsingMode_Default,
-        QuirksMode::NoQuirks
+        QuirksMode::NoQuirks,
+        &NullReporter,
     ).is_ok()
 }
 
@@ -2607,7 +2617,7 @@ pub extern "C" fn Servo_CSSSupports(cond: *const nsACString) -> bool {
     let cond = input.parse_entirely(|i| parse_condition_or_declaration(i));
     if let Ok(cond) = cond {
         let url_data = unsafe { dummy_url_data() };
-        let reporter = RustLogReporter;
+        let reporter = NullReporter;
         let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Style),
                                                    PARSING_MODE_DEFAULT,
                                                    QuirksMode::NoQuirks);

ports/geckolib/lib.rs

@@ -13,6 +13,7 @@ extern crate selectors;
 #[macro_use] extern crate style;
 extern crate style_traits;
 
+mod error_reporter;
 #[allow(non_snake_case)]
 pub mod glue;
 mod stylesheet_loader;

tests/unit/stylo/servo_function_signatures.rs

@@ -10,6 +10,9 @@ use style::gecko_properties::*;
 
 include!(concat!(env!("OUT_DIR"), "/check_bindings.rs"));
 
+#[path = "../../../ports/geckolib/error_reporter.rs"]
+mod error_reporter;
+
 #[path = "../../../ports/geckolib/stylesheet_loader.rs"]
 mod stylesheet_loader;