--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -1,28 +1,28 @@
 use std::collections::HashSet;
 use std::ffi::CString;
 use std::{mem, slice};
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::os::raw::{c_void, c_char, c_float};
 use gleam::gl;
 
-use webrender_traits::*;
+use webrender_api::*;
 use webrender::renderer::{ReadPixelsFormat, Renderer, RendererOptions};
 use webrender::renderer::{ExternalImage, ExternalImageHandler, ExternalImageSource};
 use webrender::{ApiRecordingReceiver, BinaryRecorder};
 use thread_profiler::register_thread_with_profiler;
 use moz2d_renderer::Moz2dImageRenderer;
 use app_units::Au;
 use euclid::{TypedPoint2D, TypedSize2D, TypedRect, TypedTransform3D, SideOffsets2D};
 use euclid::TypedVector2D;
 use rayon;
 
-extern crate webrender_traits;
+extern crate webrender_api;
 
 // Enables binary recording that can be used with `wrench replay`
 // Outputs a wr-record-*.bin file for each window that is shown
 // Note: wrench will panic if external images are used, they can
 // be disabled in WebRenderBridgeParent::ProcessWebRenderCommands
 // by commenting out the path that adds an external image ID
 static ENABLE_RECORDING: bool = false;
 
@@ -730,17 +730,17 @@ unsafe impl Send for CppNotifier {}
 extern "C" {
     fn wr_notifier_new_frame_ready(window_id: WrWindowId);
     fn wr_notifier_new_scroll_frame_ready(window_id: WrWindowId,
                                           composite_needed: bool);
     fn wr_notifier_external_event(window_id: WrWindowId,
                                   raw_event: usize);
 }
 
-impl webrender_traits::RenderNotifier for CppNotifier {
+impl webrender_api::RenderNotifier for CppNotifier {
     fn new_frame_ready(&mut self) {
         unsafe {
             wr_notifier_new_frame_ready(self.window_id);
         }
     }
 
     fn new_scroll_frame_ready(&mut self,
                               composite_needed: bool) {
@@ -1184,26 +1184,26 @@ pub unsafe extern "C" fn wr_api_get_name
 // As part of that I am moving the bindings closer to WebRender's API boundary,
 // and moving more of the logic in C++ land.
 // This work is tracked by bug 1328602.
 //
 // See RenderThread.h for some notes about how the pieces fit together.
 
 pub struct WebRenderFrameBuilder {
     pub root_pipeline_id: WrPipelineId,
-    pub dl_builder: webrender_traits::DisplayListBuilder,
+    pub dl_builder: webrender_api::DisplayListBuilder,
     pub scroll_clips_defined: HashSet<ClipId>,
 }
 
 impl WebRenderFrameBuilder {
     pub fn new(root_pipeline_id: WrPipelineId,
                content_size: WrSize) -> WebRenderFrameBuilder {
         WebRenderFrameBuilder {
             root_pipeline_id: root_pipeline_id,
-            dl_builder: webrender_traits::DisplayListBuilder::new(root_pipeline_id, content_size.into()),
+            dl_builder: webrender_api::DisplayListBuilder::new(root_pipeline_id, content_size.into()),
             scroll_clips_defined: HashSet::new(),
         }
     }
 }
 
 pub struct WrState {
     pipeline_id: WrPipelineId,
     frame_builder: WebRenderFrameBuilder,
@@ -1240,17 +1240,17 @@ pub extern "C" fn wr_dp_begin(state: &mu
     assert!(unsafe { !is_in_render_thread() });
     state.frame_builder.dl_builder.data.clear();
 
     let bounds = LayoutRect::new(LayoutPoint::new(0.0, 0.0),
                                  LayoutSize::new(width as f32, height as f32));
 
     state.frame_builder
          .dl_builder
-         .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
+         .push_stacking_context(webrender_api::ScrollPolicy::Scrollable,
                                 bounds,
                                 None,
                                 TransformStyle::Flat,
                                 None,
                                 MixBlendMode::Normal,
                                 Vec::new());
 }
 
@@ -1304,17 +1304,17 @@ pub extern "C" fn wr_dp_push_stacking_co
             Some(transform) => Some(PropertyBinding::Value(transform.into())),
             None => None,
         },
         _ => Some(PropertyBinding::Binding(PropertyBindingKey::new(animation_id))),
     };
 
     state.frame_builder
          .dl_builder
-         .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
+         .push_stacking_context(webrender_api::ScrollPolicy::Scrollable,
                                 bounds,
                                 transform_binding,
                                 transform_style,
                                 None,
                                 mix_blend_mode,
                                 filters);
 }
 

--- a/gfx/webrender_bindings/src/lib.rs
+++ b/gfx/webrender_bindings/src/lib.rs
@@ -1,16 +1,16 @@
 /* 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/. */
 
 #![deny(warnings)]
 
 extern crate webrender;
-extern crate webrender_traits;
+extern crate webrender_api;
 extern crate euclid;
 extern crate app_units;
 extern crate gleam;
 extern crate rayon;
 extern crate thread_profiler;
 
 #[allow(non_snake_case)]
 pub mod bindings;

--- a/gfx/webrender_bindings/src/moz2d_renderer.rs
+++ b/gfx/webrender_bindings/src/moz2d_renderer.rs
@@ -1,9 +1,9 @@
-use webrender_traits::*;
+use webrender_api::*;
 use bindings::{WrByteSlice, MutByteSlice, wr_moz2d_render_cb};
 use rayon::ThreadPool;
 
 use std::collections::hash_map::{HashMap, Entry};
 use std::sync::mpsc::{channel, Sender, Receiver};
 use std::sync::Arc;
 
 pub struct Moz2dImageRenderer {