servo: Merge #7559 - Remove 'get_*' on getters as per RFC 0344 on canevas, compositing, devtools, gfx, layout, net, profile, servo and webdriver_server (from ddrmanxbxfr:RFC-0344-Work); r=nox
authorMathieu Rheaume <mathieu@codingrhemes.com>
Sat, 12 Sep 2015 18:29:56 -0600
changeset 383785 1be5c4b1f27ae5b5d16501099ecaf8ca5b64c158
parent 383784 9f66c0a4801c354b39149d3fdec93a59b9593fa8
child 383786 62a537946e409bfa5140977d19cfc9a25c0a9752
push id7198
push userjlorenzo@mozilla.com
push dateTue, 18 Apr 2017 12:07:49 +0000
treeherdermozilla-beta@d57aa49c3948 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnox
servo: Merge #7559 - Remove 'get_*' on getters as per RFC 0344 on canevas, compositing, devtools, gfx, layout, net, profile, servo and webdriver_server (from ddrmanxbxfr:RFC-0344-Work); r=nox Hi guys, I just gave a big pass of RFC-0344 as per issue #6224 . Pretty much renamed all the get_* fn that were used to fetch values. I hope I didn't rename too much. As said in the issue discussion, I didn't touch at the scripts folder so we keep the unsafe ones pretty explicit. I've ran the whole pass of test, everything seems to be still working right :). Please give feedback on this PR. Thanks for looking into it. Source-Repo: https://github.com/servo/servo Source-Revision: b05f4aa3aa3085e65cb75433ae37bf272216d033
servo/components/canvas/canvas_paint_task.rs
servo/components/canvas/webgl_paint_task.rs
servo/components/compositing/compositor.rs
servo/components/compositing/compositor_layer.rs
servo/components/compositing/compositor_task.rs
servo/components/compositing/headless.rs
servo/components/devtools/actor.rs
servo/components/devtools/actors/timeline.rs
servo/components/gfx/font.rs
servo/components/gfx/font_cache_task.rs
servo/components/gfx/font_context.rs
servo/components/gfx/font_template.rs
servo/components/gfx/paint_context.rs
servo/components/gfx/paint_task.rs
servo/components/gfx/platform/freetype/font.rs
servo/components/gfx/platform/freetype/font_list.rs
servo/components/gfx/platform/macos/font.rs
servo/components/gfx/platform/macos/font_list.rs
servo/components/gfx/text/glyph.rs
servo/components/gfx/text/shaping/harfbuzz.rs
servo/components/layout/context.rs
servo/components/layout/text.rs
servo/components/net/storage_task.rs
servo/components/net_traits/image_cache_task.rs
servo/components/profile/mem.rs
servo/components/servo/lib.rs
servo/components/servo/main.rs
servo/components/webdriver_server/lib.rs
servo/ports/cef/browser.rs
servo/ports/cef/frame.rs
--- a/servo/components/canvas/canvas_paint_task.rs
+++ b/servo/components/canvas/canvas_paint_task.rs
@@ -165,17 +165,17 @@ impl<'a> CanvasPaintTask<'a> {
                             Canvas2dMsg::SetLineWidth(width) => painter.set_line_width(width),
                             Canvas2dMsg::SetLineCap(cap) => painter.set_line_cap(cap),
                             Canvas2dMsg::SetLineJoin(join) => painter.set_line_join(join),
                             Canvas2dMsg::SetMiterLimit(limit) => painter.set_miter_limit(limit),
                             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),
+                                => painter.image_data(dest_rect, canvas_size, chan),
                             Canvas2dMsg::PutImageData(imagedata, offset, image_data_size, dirty_rect)
                                 => painter.put_image_data(imagedata, offset, image_data_size, dirty_rect),
                             Canvas2dMsg::SetShadowOffsetX(value) => painter.set_shadow_offset_x(value),
                             Canvas2dMsg::SetShadowOffsetY(value) => painter.set_shadow_offset_y(value),
                             Canvas2dMsg::SetShadowBlur(value) => painter.set_shadow_blur(value),
                             Canvas2dMsg::SetShadowColor(ref color) => painter.set_shadow_color(color.to_azcolor()),
                         }
                     },
@@ -511,17 +511,17 @@ impl<'a> CanvasPaintTask<'a> {
     }
 
     fn send_native_surface(&self, _chan: Sender<NativeSurface>) {
         // FIXME(mrobinson): We need a handle on the NativeDisplay to create compatible
         // NativeSurfaces for the compositor.
         unimplemented!()
     }
 
-    fn get_image_data(&self,
+    fn image_data(&self,
                       dest_rect: Rect<i32>,
                       canvas_size: Size2D<f64>,
                       chan: IpcSender<Vec<u8>>) {
         let mut dest_data = self.read_pixels(dest_rect, canvas_size);
 
         // bgra -> rgba
         byte_swap(&mut dest_data);
         chan.send(dest_data).unwrap();
--- a/servo/components/canvas/webgl_paint_task.rs
+++ b/servo/components/canvas/webgl_paint_task.rs
@@ -52,17 +52,17 @@ impl WebGLPaintTask {
     /// Those messages that just involve a gl call have the call inlined,
     /// processing of messages that require extra work are moved to functions
     ///
     /// NB: Not gl-related validations (names, lengths, accepted parameters...) are
     /// done in the corresponding DOM interfaces
     pub fn handle_webgl_message(&self, message: CanvasWebGLMsg) {
         match message {
             CanvasWebGLMsg::GetContextAttributes(sender) =>
-                self.get_context_attributes(sender),
+                self.context_attributes(sender),
             CanvasWebGLMsg::ActiveTexture(target) =>
                 gl::active_texture(target),
             CanvasWebGLMsg::BlendColor(r, g, b, a) =>
                 gl::blend_color(r, g, b, a),
             CanvasWebGLMsg::BlendEquation(mode) =>
                 gl::blend_equation(mode),
             CanvasWebGLMsg::BlendEquationSeparate(mode_rgb, mode_alpha) =>
                 gl::blend_equation_separate(mode_rgb, mode_alpha),
@@ -106,21 +106,21 @@ impl WebGLPaintTask {
                 gl::line_width(width),
             CanvasWebGLMsg::PixelStorei(name, val) =>
                 gl::pixel_store_i(name, val),
             CanvasWebGLMsg::PolygonOffset(factor, units) =>
                 gl::polygon_offset(factor, units),
             CanvasWebGLMsg::EnableVertexAttribArray(attrib_id) =>
                 gl::enable_vertex_attrib_array(attrib_id),
             CanvasWebGLMsg::GetAttribLocation(program_id, name, chan) =>
-                self.get_attrib_location(program_id, name, chan),
+                self.attrib_location(program_id, name, chan),
             CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, chan) =>
-                self.get_shader_parameter(shader_id, param_id, chan),
+                self.shader_parameter(shader_id, param_id, chan),
             CanvasWebGLMsg::GetUniformLocation(program_id, name, chan) =>
-                self.get_uniform_location(program_id, name, chan),
+                self.uniform_location(program_id, name, chan),
             CanvasWebGLMsg::CompileShader(shader_id, source) =>
                 self.compile_shader(shader_id, source),
             CanvasWebGLMsg::CreateBuffer(chan) =>
                 self.create_buffer(chan),
             CanvasWebGLMsg::CreateFramebuffer(chan) =>
                 self.create_framebuffer(chan),
             CanvasWebGLMsg::CreateRenderbuffer(chan) =>
                 self.create_renderbuffer(chan),
@@ -209,17 +209,17 @@ impl WebGLPaintTask {
                 }
             }
         });
 
         Ok((out_of_process_chan, in_process_chan))
     }
 
     #[inline]
-    fn get_context_attributes(&self, sender: IpcSender<GLContextAttributes>) {
+    fn context_attributes(&self, sender: IpcSender<GLContextAttributes>) {
         sender.send(*self.gl_context.borrow_attributes()).unwrap()
     }
 
     #[inline]
     fn send_drawing_buffer_width(&self, sender: IpcSender<i32>) {
         sender.send(self.size.width).unwrap()
     }
 
@@ -300,44 +300,44 @@ impl WebGLPaintTask {
     }
 
     #[inline]
     fn compile_shader(&self, shader_id: u32, source: String) {
         gl::shader_source(shader_id, &[source.as_bytes()]);
         gl::compile_shader(shader_id);
     }
 
-    fn get_attrib_location(&self, program_id: u32, name: String, chan: IpcSender<Option<i32>> ) {
+    fn attrib_location(&self, program_id: u32, name: String, chan: IpcSender<Option<i32>> ) {
         let attrib_location = gl::get_attrib_location(program_id, &name);
 
         let attrib_location = if attrib_location == -1 {
             None
         } else {
             Some(attrib_location)
         };
 
         chan.send(attrib_location).unwrap();
     }
 
-    fn get_shader_parameter(&self,
+    fn shader_parameter(&self,
                             shader_id: u32,
                             param_id: u32,
                             chan: IpcSender<WebGLShaderParameter>) {
         let result = match param_id {
             gl::SHADER_TYPE =>
                 WebGLShaderParameter::Int(gl::get_shader_iv(shader_id, param_id)),
             gl::DELETE_STATUS | gl::COMPILE_STATUS =>
                 WebGLShaderParameter::Bool(gl::get_shader_iv(shader_id, param_id) != 0),
             _ => panic!("Unexpected shader parameter type"),
         };
 
         chan.send(result).unwrap();
     }
 
-    fn get_uniform_location(&self, program_id: u32, name: String, chan: IpcSender<Option<i32>>) {
+    fn uniform_location(&self, program_id: u32, name: String, chan: IpcSender<Option<i32>>) {
         let location = gl::get_uniform_location(program_id, &name);
         let location = if location == -1 {
             None
         } else {
             Some(location)
         };
 
         chan.send(location).unwrap();
--- a/servo/components/compositing/compositor.rs
+++ b/servo/components/compositing/compositor.rs
@@ -368,22 +368,22 @@ impl<Window: WindowMethods> IOCompositor
             (Msg::ChangePageUrl(pipeline_id, url), ShutdownState::NotShuttingDown) => {
                 self.change_page_url(pipeline_id, url);
             }
 
             (Msg::SetFrameTree(frame_tree, response_chan, new_constellation_chan),
              ShutdownState::NotShuttingDown) => {
                 self.set_frame_tree(&frame_tree, response_chan, new_constellation_chan);
                 self.send_viewport_rects_for_all_layers();
-                self.get_title_for_main_frame();
+                self.title_for_main_frame();
             }
 
             (Msg::InitializeLayersForPipeline(pipeline_id, epoch, properties),
              ShutdownState::NotShuttingDown) => {
-                self.get_or_create_pipeline_details(pipeline_id).current_epoch = epoch;
+                self.pipeline_details(pipeline_id).current_epoch = epoch;
                 self.collect_old_layers(pipeline_id, &properties);
                 for (index, layer_properties) in properties.iter().enumerate() {
                     if index == 0 {
                         self.create_or_update_base_layer(pipeline_id, *layer_properties);
                     } else {
                         self.create_or_update_descendant_layer(pipeline_id, *layer_properties);
                     }
                 }
@@ -548,47 +548,47 @@ impl<Window: WindowMethods> IOCompositor
 
     /// Sets or unsets the animations-running flag for the given pipeline, and schedules a
     /// recomposite if necessary.
     fn change_running_animations_state(&mut self,
                                        pipeline_id: PipelineId,
                                        animation_state: AnimationState) {
         match animation_state {
             AnimationState::AnimationsPresent => {
-                self.get_or_create_pipeline_details(pipeline_id).animations_running = true;
+                self.pipeline_details(pipeline_id).animations_running = true;
                 self.composite_if_necessary(CompositingReason::Animation);
             }
             AnimationState::AnimationCallbacksPresent => {
-                if self.get_or_create_pipeline_details(pipeline_id).animation_callbacks_running {
+                if self.pipeline_details(pipeline_id).animation_callbacks_running {
                     return
                 }
-                self.get_or_create_pipeline_details(pipeline_id).animation_callbacks_running =
+                self.pipeline_details(pipeline_id).animation_callbacks_running =
                     true;
                 self.tick_animations_for_pipeline(pipeline_id);
                 self.composite_if_necessary(CompositingReason::Animation);
             }
             AnimationState::NoAnimationsPresent => {
-                self.get_or_create_pipeline_details(pipeline_id).animations_running = false;
+                self.pipeline_details(pipeline_id).animations_running = false;
             }
             AnimationState::NoAnimationCallbacksPresent => {
-                self.get_or_create_pipeline_details(pipeline_id).animation_callbacks_running = false;
+                self.pipeline_details(pipeline_id).animation_callbacks_running = false;
             }
         }
     }
 
-    pub fn get_or_create_pipeline_details<'a>(&'a mut self,
+    pub fn pipeline_details<'a>(&'a mut self,
                                               pipeline_id: PipelineId)
                                               -> &'a mut PipelineDetails {
         if !self.pipeline_details.contains_key(&pipeline_id) {
             self.pipeline_details.insert(pipeline_id, PipelineDetails::new());
         }
         return self.pipeline_details.get_mut(&pipeline_id).unwrap();
     }
 
-    pub fn get_pipeline<'a>(&'a self, pipeline_id: PipelineId) -> &'a CompositionPipeline {
+    pub fn pipeline<'a>(&'a self, pipeline_id: PipelineId) -> &'a CompositionPipeline {
         match self.pipeline_details.get(&pipeline_id) {
             Some(ref details) => {
                 match details.pipeline {
                     Some(ref pipeline) => pipeline,
                     None => panic!("Compositor layer has an unitialized pipeline ({:?}).",
                                    pipeline_id),
 
                 }
@@ -651,17 +651,17 @@ impl<Window: WindowMethods> IOCompositor
             scrolls_overflow_area: false,
         };
 
         let root_layer = CompositorData::new_layer(pipeline.id,
                                                    layer_properties,
                                                    WantsScrollEventsFlag::WantsScrollEvents,
                                                    opts::get().tile_size);
 
-        self.get_or_create_pipeline_details(pipeline.id).pipeline = Some(pipeline.clone());
+        self.pipeline_details(pipeline.id).pipeline = Some(pipeline.clone());
 
         // All root layers mask to bounds.
         *root_layer.masks_to_bounds.borrow_mut() = true;
 
         if let Some(ref frame_rect) = frame_rect {
             let frame_rect = frame_rect.to_untyped();
             *root_layer.bounds.borrow_mut() = Rect::from_untyped(&frame_rect);
         }
@@ -1301,17 +1301,17 @@ impl<Window: WindowMethods> IOCompositor
 
         results
     }
 
     fn send_viewport_rect_for_layer(&self, layer: Rc<Layer<CompositorData>>) {
         if layer.extra_data.borrow().id == LayerId::null() {
             let layer_rect = Rect::new(-layer.extra_data.borrow().scroll_offset.to_untyped(),
                                        layer.bounds.borrow().size.to_untyped());
-            let pipeline = self.get_pipeline(layer.pipeline_id());
+            let pipeline = self.pipeline(layer.pipeline_id());
             pipeline.script_chan.send(ConstellationControlMsg::Viewport(pipeline.id.clone(), layer_rect)).unwrap();
         }
 
         for kid in &*layer.children() {
             self.send_viewport_rect_for_layer(kid.clone());
         }
     }
 
@@ -1343,17 +1343,17 @@ impl<Window: WindowMethods> IOCompositor
 
         // We want to batch requests for each pipeline to avoid race conditions
         // when handling the resulting BufferRequest responses.
         let pipeline_requests =
             self.convert_buffer_requests_to_pipeline_requests_map(layers_and_requests);
 
         for (pipeline_id, requests) in pipeline_requests {
             let msg = ChromeToPaintMsg::Paint(requests, self.frame_tree_id);
-            let _ = self.get_pipeline(pipeline_id).chrome_to_paint_chan.send(msg);
+            let _ = self.pipeline(pipeline_id).chrome_to_paint_chan.send(msg);
         }
 
         true
     }
 
     /// Check if a layer (or its children) have any outstanding paint
     /// results to arrive yet.
     fn does_layer_have_outstanding_paint_messages(&self, layer: &Rc<Layer<CompositorData>>) -> bool {
@@ -1785,17 +1785,17 @@ impl<Window> CompositorEventListener for
         self.mem_profiler_chan.send(mem::ProfilerMsg::Exit);
         self.scrolling_timer.shutdown();
     }
 
     fn pinch_zoom_level(&self) -> f32 {
         self.viewport_zoom.get() as f32
     }
 
-    fn get_title_for_main_frame(&self) {
+    fn title_for_main_frame(&self) {
         let root_pipeline_id = match self.root_pipeline {
             None => return,
             Some(ref root_pipeline) => root_pipeline.id,
         };
         let ConstellationChan(ref chan) = self.constellation_chan;
         chan.send(ConstellationMsg::GetPipelineTitle(root_pipeline_id)).unwrap();
     }
 }
--- a/servo/components/compositing/compositor_layer.rs
+++ b/servo/components/compositing/compositor_layer.rs
@@ -399,26 +399,26 @@ impl CompositorLayer for Layer<Composito
             MouseWindowEvent::Click(button, _) =>
                 ClickEvent(button, event_point),
             MouseWindowEvent::MouseDown(button, _) =>
                 MouseDownEvent(button, event_point),
             MouseWindowEvent::MouseUp(button, _) =>
                 MouseUpEvent(button, event_point),
         };
 
-        let pipeline = compositor.get_pipeline(self.pipeline_id());
+        let pipeline = compositor.pipeline(self.pipeline_id());
         let _ = pipeline.script_chan.send(ConstellationControlMsg::SendEvent(pipeline.id.clone(), message));
     }
 
     fn send_mouse_move_event<Window>(&self,
                                      compositor: &IOCompositor<Window>,
                                      cursor: TypedPoint2D<LayerPixel, f32>)
                                      where Window: WindowMethods {
         let message = MouseMoveEvent(cursor.to_untyped());
-        let pipeline = compositor.get_pipeline(self.pipeline_id());
+        let pipeline = compositor.pipeline(self.pipeline_id());
         let _ = pipeline.script_chan.send(ConstellationControlMsg::SendEvent(pipeline.id.clone(), message));
     }
 
     fn scroll_layer_and_all_child_layers(&self, new_offset: TypedPoint2D<LayerPixel, f32>)
                                          -> bool {
         let mut result = false;
 
         // Only scroll this layer if it's not fixed-positioned.
--- a/servo/components/compositing/compositor_task.rs
+++ b/servo/components/compositing/compositor_task.rs
@@ -289,10 +289,10 @@ impl CompositorTask {
 }
 
 pub trait CompositorEventListener {
     fn handle_events(&mut self, events: Vec<WindowEvent>) -> bool;
     fn repaint_synchronously(&mut self);
     fn shutdown(&mut self);
     fn pinch_zoom_level(&self) -> f32;
     /// Requests that the compositor send the title for the main frame as soon as possible.
-    fn get_title_for_main_frame(&self);
+    fn title_for_main_frame(&self);
 }
--- a/servo/components/compositing/headless.rs
+++ b/servo/components/compositing/headless.rs
@@ -147,10 +147,10 @@ impl CompositorEventListener for NullCom
         self.time_profiler_chan.send(time::ProfilerMsg::Exit);
         self.mem_profiler_chan.send(mem::ProfilerMsg::Exit);
     }
 
     fn pinch_zoom_level(&self) -> f32 {
         1.0
     }
 
-    fn get_title_for_main_frame(&self) {}
+    fn title_for_main_frame(&self) {}
 }
--- a/servo/components/devtools/actor.rs
+++ b/servo/components/devtools/actor.rs
@@ -77,17 +77,17 @@ impl ActorRegistry {
             let mut lock = shareable.lock();
             let registry = lock.as_mut().unwrap();
             registry.shareable = Some(shareable.clone());
         }
         shareable
     }
 
     /// Get shareable registry through threads
-    pub fn get_shareable(&self) -> Arc<Mutex<ActorRegistry>> {
+    pub fn shareable(&self) -> Arc<Mutex<ActorRegistry>> {
         self.shareable.as_ref().unwrap().clone()
     }
 
     /// Get start stamp when registry was started
     pub fn start_stamp(&self) -> PreciseTime {
         self.start_stamp.clone()
     }
 
--- a/servo/components/devtools/actors/timeline.rs
+++ b/servo/components/devtools/actors/timeline.rs
@@ -199,17 +199,17 @@ impl Actor for TimelineActor {
                         let framerate_actor = Some(FramerateActor::create(
                                 registry,
                                 self.pipeline.clone(),
                                 self.script_sender.clone()));
                         *self.framerate_actor.borrow_mut() = framerate_actor;
                     }
                 }
 
-                let emitter = Emitter::new(self.name(), registry.get_shareable(),
+                let emitter = Emitter::new(self.name(), registry.shareable(),
                                            registry.start_stamp(),
                                            stream.try_clone().unwrap(),
                                            self.memory_actor.borrow().clone(),
                                            self.framerate_actor.borrow().clone());
 
                 self.pull_timeline_data(rx, emitter);
 
                 let msg = StartReply {
--- a/servo/components/gfx/font.rs
+++ b/servo/components/gfx/font.rs
@@ -36,17 +36,17 @@ pub trait FontHandleMethods: Sized {
     fn is_italic(&self) -> bool;
     fn boldness(&self) -> font_weight::T;
     fn stretchiness(&self) -> font_stretch::T;
 
     fn glyph_index(&self, codepoint: char) -> Option<GlyphId>;
     fn glyph_h_advance(&self, GlyphId) -> Option<FractionalPixel>;
     fn glyph_h_kerning(&self, GlyphId, GlyphId) -> FractionalPixel;
     fn metrics(&self) -> FontMetrics;
-    fn get_table_for_tag(&self, FontTableTag) -> Option<Box<FontTable>>;
+    fn table_for_tag(&self, FontTableTag) -> Option<Box<FontTable>>;
 }
 
 // Used to abstract over the shaper's choice of fixed int representation.
 pub type FractionalPixel = f64;
 
 pub type FontTableTag = u32;
 
 pub trait FontTableTagConversions {
@@ -163,18 +163,18 @@ impl Font {
             return shaper
         }
 
         let shaper = Shaper::new(self, options);
         self.shaper = Some(shaper);
         self.shaper.as_ref().unwrap()
     }
 
-    pub fn get_table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
-        let result = self.handle.get_table_for_tag(tag);
+    pub fn table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
+        let result = self.handle.table_for_tag(tag);
         let status = if result.is_some() { "Found" } else { "Didn't find" };
 
         debug!("{} font table[{}] with family={}, face={}",
                status, tag.tag_to_str(),
                self.handle.family_name(), self.handle.face_name());
 
         result
     }
--- a/servo/components/gfx/font_cache_task.rs
+++ b/servo/components/gfx/font_cache_task.rs
@@ -1,20 +1,19 @@
 /* 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/. */
 
-use platform::font_context::FontContextHandle;
-use platform::font_list::get_available_families;
-use platform::font_list::get_last_resort_font_families;
-use platform::font_list::get_system_default_family;
-use platform::font_list::get_variations_for_family;
-
 use font_template::{FontTemplate, FontTemplateDescriptor};
 use net_traits::{ResourceTask, load_whole_resource};
+use platform::font_context::FontContextHandle;
+use platform::font_list::for_each_available_family;
+use platform::font_list::for_each_variation;
+use platform::font_list::last_resort_font_families;
+use platform::font_list::system_default_family;
 use platform::font_template::FontTemplateData;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::mpsc::{Sender, Receiver, channel};
 use string_cache::Atom;
 use style::font_face::Source;
 use util::str::LowercaseString;
@@ -37,17 +36,17 @@ impl FontFamily {
                                -> Option<Arc<FontTemplateData>> {
         // TODO(Issue #189): optimize lookup for
         // regular/bold/italic/bolditalic with fixed offsets and a
         // static decision table for fallback between these values.
 
         // TODO(Issue #190): if not in the fast path above, do
         // expensive matching of weights, etc.
         for template in &mut self.templates {
-            let maybe_template = template.get_if_matches(fctx, desc);
+            let maybe_template = template.data_for_descriptor(fctx, desc);
             if maybe_template.is_some() {
                 return maybe_template;
             }
         }
 
         // If a request is made for a font family that exists,
         // pick the first valid font in the family if we failed
         // to find an exact match for the descriptor.
@@ -94,37 +93,37 @@ struct FontCache {
     local_families: HashMap<LowercaseString, FontFamily>,
     web_families: HashMap<LowercaseString, FontFamily>,
     font_context: FontContextHandle,
     resource_task: ResourceTask,
 }
 
 fn add_generic_font(generic_fonts: &mut HashMap<LowercaseString, LowercaseString>,
                     generic_name: &str, mapped_name: &str) {
-    let opt_system_default = get_system_default_family(generic_name);
+    let opt_system_default = system_default_family(generic_name);
     let family_name = match opt_system_default {
         Some(system_default) => LowercaseString::new(&system_default),
         None => LowercaseString::new(mapped_name),
     };
     generic_fonts.insert(LowercaseString::new(generic_name), family_name);
 }
 
 impl FontCache {
     fn run(&mut self) {
         loop {
             let msg = self.port.recv().unwrap();
 
             match msg {
                 Command::GetFontTemplate(family, descriptor, result) => {
                     let family = LowercaseString::new(&family);
-                    let maybe_font_template = self.get_font_template(&family, &descriptor);
+                    let maybe_font_template = self.find_font_template(&family, &descriptor);
                     result.send(Reply::GetFontTemplateReply(maybe_font_template)).unwrap();
                 }
                 Command::GetLastResortFontTemplate(descriptor, result) => {
-                    let font_template = self.get_last_resort_font_template(&descriptor);
+                    let font_template = self.last_resort_font_template(&descriptor);
                     result.send(Reply::GetFontTemplateReply(Some(font_template))).unwrap();
                 }
                 Command::AddWebFont(family_name, src, result) => {
                     let family_name = LowercaseString::new(&family_name);
                     if !self.web_families.contains_key(&family_name) {
                         let family = FontFamily::new();
                         self.web_families.insert(family_name.clone(), family);
                     }
@@ -140,34 +139,34 @@ impl FontCache {
                                 },
                                 Err(_) => {
                                     debug!("Failed to load web font: family={:?} url={}", family_name, url);
                                 }
                             }
                         }
                         Source::Local(ref local_family_name) => {
                             let family = &mut self.web_families.get_mut(&family_name).unwrap();
-                            get_variations_for_family(&local_family_name, |path| {
+                            for_each_variation(&local_family_name, |path| {
                                 family.add_template(Atom::from_slice(&path), None);
                             });
                         }
                     }
                     result.send(()).unwrap();
                 }
                 Command::Exit(result) => {
                     result.send(()).unwrap();
                     break;
                 }
             }
         }
     }
 
     fn refresh_local_families(&mut self) {
         self.local_families.clear();
-        get_available_families(|family_name| {
+        for_each_available_family(|family_name| {
             let family_name = LowercaseString::new(&family_name);
             if !self.local_families.contains_key(&family_name) {
                 let family = FontFamily::new();
                 self.local_families.insert(family_name, family);
             }
         });
     }
 
@@ -182,17 +181,17 @@ impl FontCache {
                                 -> Option<Arc<FontTemplateData>> {
         // TODO(Issue #188): look up localized font family names if canonical name not found
         // look up canonical name
         if self.local_families.contains_key(family_name) {
             debug!("FontList: Found font family with name={}", &**family_name);
             let s = self.local_families.get_mut(family_name).unwrap();
 
             if s.templates.is_empty() {
-                get_variations_for_family(family_name, |path| {
+                for_each_variation(family_name, |path| {
                     s.add_template(Atom::from_slice(&path), None);
                 });
             }
 
             // TODO(Issue #192: handle generic font families, like 'serif' and 'sans-serif'.
             // if such family exists, try to match style to a font
             let result = s.find_font_for_style(desc, &self.font_context);
             if result.is_some() {
@@ -212,29 +211,29 @@ impl FontCache {
             let family = self.web_families.get_mut(family_name).unwrap();
             let maybe_font = family.find_font_for_style(desc, &self.font_context);
             maybe_font
         } else {
             None
         }
     }
 
-    fn get_font_template(&mut self, family: &LowercaseString, desc: &FontTemplateDescriptor)
+    fn find_font_template(&mut self, family: &LowercaseString, desc: &FontTemplateDescriptor)
                             -> Option<Arc<FontTemplateData>> {
         let transformed_family_name = self.transform_family(family);
         let mut maybe_template = self.find_font_in_web_family(&transformed_family_name, desc);
         if maybe_template.is_none() {
             maybe_template = self.find_font_in_local_family(&transformed_family_name, desc);
         }
         maybe_template
     }
 
-    fn get_last_resort_font_template(&mut self, desc: &FontTemplateDescriptor)
+    fn last_resort_font_template(&mut self, desc: &FontTemplateDescriptor)
                                         -> Arc<FontTemplateData> {
-        let last_resort = get_last_resort_font_families();
+        let last_resort = last_resort_font_families();
 
         for family in &last_resort {
             let family = LowercaseString::new(family);
             let maybe_font_in_family = self.find_font_in_local_family(&family, desc);
             if maybe_font_in_family.is_some() {
                 return maybe_font_in_family.unwrap();
             }
         }
@@ -276,32 +275,32 @@ impl FontCacheTask {
             cache.run();
         });
 
         FontCacheTask {
             chan: chan,
         }
     }
 
-    pub fn get_font_template(&self, family: String, desc: FontTemplateDescriptor)
+    pub fn find_font_template(&self, family: String, desc: FontTemplateDescriptor)
                                                 -> Option<Arc<FontTemplateData>> {
 
         let (response_chan, response_port) = channel();
         self.chan.send(Command::GetFontTemplate(family, desc, response_chan)).unwrap();
 
         let reply = response_port.recv().unwrap();
 
         match reply {
             Reply::GetFontTemplateReply(data) => {
                 data
             }
         }
     }
 
-    pub fn get_last_resort_font_template(&self, desc: FontTemplateDescriptor)
+    pub fn last_resort_font_template(&self, desc: FontTemplateDescriptor)
                                                 -> Arc<FontTemplateData> {
 
         let (response_chan, response_port) = channel();
         self.chan.send(Command::GetLastResortFontTemplate(desc, response_chan)).unwrap();
 
         let reply = response_port.recv().unwrap();
 
         match reply {
--- a/servo/components/gfx/font_context.rs
+++ b/servo/components/gfx/font_context.rs
@@ -129,17 +129,17 @@ impl FontContext {
                 glyph_advance_cache: HashCache::new(),
             }
         })
     }
 
     /// Create a group of fonts for use in layout calculations. May return
     /// a cached font if this font instance has already been used by
     /// this context.
-    pub fn get_layout_font_group_for_style(&mut self, style: Arc<SpecifiedFontStyle>)
+    pub fn layout_font_group_for_style(&mut self, style: Arc<SpecifiedFontStyle>)
                                             -> Rc<FontGroup> {
         let address = &*style as *const SpecifiedFontStyle as usize;
         if let Some(ref cached_font_group) = self.layout_font_group_cache.get(&address) {
             return (*cached_font_group).clone()
         }
 
         let layout_font_group_cache_key = LayoutFontGroupCacheKey {
             pointer: style.clone(),
@@ -181,19 +181,19 @@ impl FontContext {
                                 break;
                             }
                         }
                     }
                 }
             }
 
             if !cache_hit {
-                let font_template = self.font_cache_task.get_font_template(family.name()
-                                                                                 .to_owned(),
-                                                                           desc.clone());
+                let font_template = self.font_cache_task.find_font_template(family.name()
+                                                                            .to_owned(),
+                                                                            desc.clone());
                 match font_template {
                     Some(font_template) => {
                         let layout_font = self.create_layout_font(font_template,
                                                                   desc.clone(),
                                                                   style.font_size,
                                                                   style.font_variant);
                         let font = match layout_font {
                             Ok(layout_font) => {
@@ -231,17 +231,17 @@ impl FontContext {
                             cached_font.variant == style.font_variant {
                     fonts.push(cached_font_entry.font.clone());
                     cache_hit = true;
                     break;
                 }
             }
 
             if !cache_hit {
-                let font_template = self.font_cache_task.get_last_resort_font_template(desc.clone());
+                let font_template = self.font_cache_task.last_resort_font_template(desc.clone());
                 let layout_font = self.create_layout_font(font_template,
                                                           desc.clone(),
                                                           style.font_size,
                                                           style.font_variant);
                 match layout_font {
                     Ok(layout_font) => {
                         let layout_font = Rc::new(RefCell::new(layout_font));
                         self.fallback_font_cache.push(FallbackFontCacheEntry {
@@ -256,17 +256,17 @@ impl FontContext {
 
         let font_group = Rc::new(FontGroup::new(fonts));
         self.layout_font_group_cache.insert(layout_font_group_cache_key, font_group.clone());
         font_group
     }
 
     /// Create a paint font for use with azure. May return a cached
     /// reference if already used by this font context.
-    pub fn get_paint_font_from_template(&mut self,
+    pub fn paint_font_from_template(&mut self,
                                         template: &Arc<FontTemplateData>,
                                         pt_size: Au)
                                         -> Rc<RefCell<ScaledFont>> {
         for cached_font in &self.paint_font_cache {
             if cached_font.pt_size == pt_size &&
                cached_font.identifier == template.identifier {
                 return cached_font.font.clone();
             }
--- a/servo/components/gfx/font_template.rs
+++ b/servo/components/gfx/font_template.rs
@@ -83,35 +83,35 @@ impl FontTemplate {
         }
     }
 
     pub fn identifier(&self) -> &Atom {
         &self.identifier
     }
 
     /// Get the data for creating a font if it matches a given descriptor.
-    pub fn get_if_matches(&mut self,
+    pub fn data_for_descriptor(&mut self,
                           fctx: &FontContextHandle,
                           requested_desc: &FontTemplateDescriptor)
                           -> Option<Arc<FontTemplateData>> {
         // The font template data can be unloaded when nothing is referencing
         // it (via the Weak reference to the Arc above). However, if we have
         // already loaded a font, store the style information about it separately,
         // so that we can do font matching against it again in the future
         // without having to reload the font (unless it is an actual match).
         match self.descriptor {
             Some(actual_desc) => {
                 if *requested_desc == actual_desc {
-                    Some(self.get_data())
+                    Some(self.data())
                 } else {
                     None
                 }
             },
             None if self.is_valid => {
-                let data = self.get_data();
+                let data = self.data();
                 let handle: Result<FontHandle, ()> =
                     FontHandleMethods::new_from_template(fctx, data.clone(), None);
                 match handle {
                     Ok(handle) => {
                         let actual_desc = FontTemplateDescriptor::new(handle.boldness(),
                                                                       handle.stretchiness(),
                                                                       handle.is_italic());
                         let desc_match = actual_desc == *requested_desc;
@@ -133,26 +133,26 @@ impl FontTemplate {
             }
             None => None,
         }
     }
 
     /// Get the data for creating a font.
     pub fn get(&mut self) -> Option<Arc<FontTemplateData>> {
         if self.is_valid {
-            Some(self.get_data())
+            Some(self.data())
         } else {
             None
         }
     }
 
     /// Get the font template data. If any strong references still
     /// exist, it will return a clone, otherwise it will load the
     /// font data and store a weak reference to it internally.
-    pub fn get_data(&mut self) -> Arc<FontTemplateData> {
+    pub fn data(&mut self) -> Arc<FontTemplateData> {
         let maybe_data = match self.weak_ref {
             Some(ref data) => data.upgrade(),
             None => None,
         };
 
         if let Some(data) = maybe_data {
             return data
         }
--- a/servo/components/gfx/paint_context.rs
+++ b/servo/components/gfx/paint_context.rs
@@ -1267,17 +1267,17 @@ impl<'a> PaintContext<'a> {
             }
         };
 
         // Draw the text.
         let temporary_draw_target =
             self.create_draw_target_for_blur_if_necessary(&text.base.bounds, text.blur_radius);
         {
             // FIXME(https://github.com/rust-lang/rust/issues/23338)
-            let font = self.font_context.get_paint_font_from_template(
+            let font = self.font_context.paint_font_from_template(
                 &text.text_run.font_template, text.text_run.actual_pt_size);
             font.borrow()
                 .draw_text(&temporary_draw_target.draw_target,
                            &*text.text_run,
                            &text.range,
                            baseline_origin,
                            text.text_color,
                            opts::get().enable_text_antialiasing);
--- a/servo/components/gfx/paint_task.rs
+++ b/servo/components/gfx/paint_task.rs
@@ -315,17 +315,17 @@ impl<C> PaintTask<C> where C: PaintListe
                 self.worker_threads[thread_id].paint_tile(thread_id,
                                                           tile,
                                                           stacking_context.clone(),
                                                           scale,
                                                           layer_kind);
             }
             let new_buffers = (0..tile_count).map(|i| {
                 let thread_id = i % self.worker_threads.len();
-                self.worker_threads[thread_id].get_painted_tile_buffer()
+                self.worker_threads[thread_id].painted_tile_buffer()
             }).collect();
 
             let layer_buffer_set = box LayerBufferSet {
                 buffers: new_buffers,
             };
             replies.push((layer_id, layer_buffer_set));
         })
     }
@@ -478,17 +478,17 @@ impl WorkerThreadProxy {
         let msg = MsgToWorkerThread::PaintTile(thread_id,
                                                tile,
                                                stacking_context,
                                                scale,
                                                layer_kind);
         self.sender.send(msg).unwrap()
     }
 
-    fn get_painted_tile_buffer(&mut self) -> Box<LayerBuffer> {
+    fn painted_tile_buffer(&mut self) -> Box<LayerBuffer> {
         match self.receiver.recv().unwrap() {
             MsgFromWorkerThread::PaintedTile(layer_buffer) => layer_buffer,
         }
     }
 
     fn exit(&mut self) {
         self.sender.send(MsgToWorkerThread::Exit).unwrap()
     }
--- a/servo/components/gfx/platform/freetype/font.rs
+++ b/servo/components/gfx/platform/freetype/font.rs
@@ -258,17 +258,17 @@ impl FontHandleMethods for FontHandle {
             average_advance:  average_advance,
             line_gap:         height,
         };
 
         debug!("Font metrics (@{}px): {:?}", em_size.to_f32_px(), metrics);
         return metrics;
     }
 
-    fn get_table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
+    fn table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
         let tag = tag as FT_ULong;
 
         unsafe {
             // Get the length
             let mut len = 0;
             if !FT_Load_Sfnt_Table(self.face, tag, 0, ptr::null_mut(), &mut len).succeeded() {
                 return None
             }
--- a/servo/components/gfx/platform/freetype/font_list.rs
+++ b/servo/components/gfx/platform/freetype/font_list.rs
@@ -22,17 +22,17 @@ use std::borrow::ToOwned;
 use std::ffi::CString;
 use std::ptr;
 
 static FC_FAMILY: &'static [u8] = b"family\0";
 static FC_FILE: &'static [u8] = b"file\0";
 static FC_INDEX: &'static [u8] = b"index\0";
 static FC_FONTFORMAT: &'static [u8] = b"fontformat\0";
 
-pub fn get_available_families<F>(mut callback: F) where F: FnMut(String) {
+pub fn for_each_available_family<F>(mut callback: F) where F: FnMut(String) {
     unsafe {
         let config = FcConfigGetCurrent();
         let fontSet = FcConfigGetFonts(config, FcSetSystem);
         for i in 0..((*fontSet).nfont as isize) {
             let font = (*fontSet).fonts.offset(i);
             let mut family: *mut FcChar8 = ptr::null_mut();
             let mut format: *mut FcChar8 = ptr::null_mut();
             let mut v: c_int = 0;
@@ -52,17 +52,17 @@ pub fn get_available_families<F>(mut cal
                 let family_name = c_str_to_string(family as *const c_char);
                 callback(family_name);
                 v += 1;
             }
         }
     }
 }
 
-pub fn get_variations_for_family<F>(family_name: &str, mut callback: F)
+pub fn for_each_variation<F>(family_name: &str, mut callback: F)
     where F: FnMut(String)
 {
     debug!("getting variations for {}", family_name);
     unsafe {
         let config = FcConfigGetCurrent();
         let mut font_set = FcConfigGetFonts(config, FcSetSystem);
         let font_set_array_ptr = &mut font_set;
         let pattern = FcPatternCreate();
@@ -106,17 +106,17 @@ pub fn get_variations_for_family<F>(fami
         }
 
         FcFontSetDestroy(matches);
         FcPatternDestroy(pattern);
         FcObjectSetDestroy(object_set);
     }
 }
 
-pub fn get_system_default_family(generic_name: &str) -> Option<String> {
+pub fn system_default_family(generic_name: &str) -> Option<String> {
     let generic_name_c = CString::new(generic_name).unwrap();
     let generic_name_ptr = generic_name_c.as_ptr();
 
     unsafe {
         let pattern = FcNameParse(generic_name_ptr as *mut FcChar8);
 
         FcConfigSubstitute(ptr::null_mut(), pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
@@ -135,20 +135,20 @@ pub fn get_system_default_family(generic
         };
 
         FcPatternDestroy(pattern);
         family_name
     }
 }
 
 #[cfg(target_os = "linux")]
-pub fn get_last_resort_font_families() -> Vec<String> {
+pub fn last_resort_font_families() -> Vec<String> {
     vec!(
         "Fira Sans".to_owned(),
         "DejaVu Sans".to_owned(),
         "Arial".to_owned()
     )
 }
 
 #[cfg(target_os = "android")]
-pub fn get_last_resort_font_families() -> Vec<String> {
+pub fn last_resort_font_families() -> Vec<String> {
     vec!("Roboto".to_owned())
 }
--- a/servo/components/gfx/platform/macos/font.rs
+++ b/servo/components/gfx/platform/macos/font.rs
@@ -187,15 +187,15 @@ impl FontHandleMethods for FontHandle {
             max_advance:      max_advance_width,
             average_advance:  average_advance,
             line_gap:         Au::from_f64_px(line_gap),
         };
         debug!("Font metrics (@{} pt): {:?}", self.ctfont.pt_size() as f64, metrics);
         return metrics;
     }
 
-    fn get_table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
+    fn table_for_tag(&self, tag: FontTableTag) -> Option<Box<FontTable>> {
         let result: Option<CFData> = self.ctfont.get_font_table(tag);
         result.and_then(|data| {
             Some(box FontTable::wrap(data))
         })
     }
 }
--- a/servo/components/gfx/platform/macos/font_list.rs
+++ b/servo/components/gfx/platform/macos/font_list.rs
@@ -5,40 +5,40 @@
 use core_foundation::base::TCFType;
 use core_foundation::string::{CFString, CFStringRef};
 use core_text;
 use core_text::font_descriptor::{CTFontDescriptor, CTFontDescriptorRef};
 
 use std::borrow::ToOwned;
 use std::mem;
 
-pub fn get_available_families<F>(mut callback: F) where F: FnMut(String) {
+pub fn for_each_available_family<F>(mut callback: F) where F: FnMut(String) {
     let family_names = core_text::font_collection::get_family_names();
     for strref in family_names.iter() {
         let family_name_ref: CFStringRef = unsafe { mem::transmute(strref) };
         let family_name_cf: CFString = unsafe { TCFType::wrap_under_get_rule(family_name_ref) };
         let family_name = family_name_cf.to_string();
         callback(family_name);
     }
 }
 
-pub fn get_variations_for_family<F>(family_name: &str, mut callback: F) where F: FnMut(String) {
+pub fn for_each_variation<F>(family_name: &str, mut callback: F) where F: FnMut(String) {
     debug!("Looking for faces of family: {}", family_name);
 
     let family_collection = core_text::font_collection::create_for_family(family_name);
     if let Some(family_collection) = family_collection {
         let family_descriptors = family_collection.get_descriptors();
         for descref in family_descriptors.iter() {
             let descref: CTFontDescriptorRef = unsafe { mem::transmute(descref) };
             let desc: CTFontDescriptor = unsafe { TCFType::wrap_under_get_rule(descref) };
             let postscript_name = desc.font_name();
             callback(postscript_name);
         }
     }
 }
 
-pub fn get_system_default_family(_generic_name: &str) -> Option<String> {
+pub fn system_default_family(_generic_name: &str) -> Option<String> {
     None
 }
 
-pub fn get_last_resort_font_families() -> Vec<String> {
+pub fn last_resort_font_families() -> Vec<String> {
     vec!("Arial Unicode MS".to_owned(), "Arial".to_owned())
 }
--- a/servo/components/gfx/text/glyph.rs
+++ b/servo/components/gfx/text/glyph.rs
@@ -237,17 +237,17 @@ impl<'a> DetailedGlyphStore {
         }
         */
 
         self.detail_lookup.push(entry);
         self.detail_buffer.push_all(glyphs);
         self.lookup_is_sorted = false;
     }
 
-    fn get_detailed_glyphs_for_entry(&'a self, entry_offset: CharIndex, count: u16)
+    fn detailed_glyphs_for_entry(&'a self, entry_offset: CharIndex, count: u16)
                                   -> &'a [DetailedGlyph] {
         debug!("Requesting detailed glyphs[n={}] for entry[off={:?}]", count, entry_offset);
 
         // FIXME: Is this right? --pcwalton
         // TODO: should fix this somewhere else
         if count == 0 {
             return &self.detail_buffer[0..0];
         }
@@ -263,17 +263,17 @@ impl<'a> DetailedGlyphStore {
         let i = self.detail_lookup.binary_search_index(&key)
             .expect("Invalid index not found in detailed glyph lookup table!");
 
         assert!(i + (count as usize) <= self.detail_buffer.len());
         // return a slice into the buffer
         &self.detail_buffer[i .. i + count as usize]
     }
 
-    fn get_detailed_glyph_with_index(&'a self,
+    fn detailed_glyph_with_index(&'a self,
                                      entry_offset: CharIndex,
                                      detail_offset: u16)
             -> &'a DetailedGlyph {
         assert!((detail_offset as usize) <= self.detail_buffer.len());
         assert!(self.lookup_is_sorted);
 
         let key = DetailedGlyphRecord {
             entry_offset: entry_offset,
@@ -356,37 +356,37 @@ pub enum GlyphInfo<'a> {
     Detail(&'a GlyphStore, CharIndex, u16),
 }
 
 impl<'a> GlyphInfo<'a> {
     pub fn id(self) -> GlyphId {
         match self {
             GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_usize()].id(),
             GlyphInfo::Detail(store, entry_i, detail_j) => {
-                store.detail_store.get_detailed_glyph_with_index(entry_i, detail_j).id
+                store.detail_store.detailed_glyph_with_index(entry_i, detail_j).id
             }
         }
     }
 
     #[inline(always)]
     // FIXME: Resolution conflicts with IteratorUtil trait so adding trailing _
     pub fn advance(self) -> Au {
         match self {
             GlyphInfo::Simple(store, entry_i) => store.entry_buffer[entry_i.to_usize()].advance(),
             GlyphInfo::Detail(store, entry_i, detail_j) => {
-                store.detail_store.get_detailed_glyph_with_index(entry_i, detail_j).advance
+                store.detail_store.detailed_glyph_with_index(entry_i, detail_j).advance
             }
         }
     }
 
     pub fn offset(self) -> Option<Point2D<Au>> {
         match self {
             GlyphInfo::Simple(_, _) => None,
             GlyphInfo::Detail(store, entry_i, detail_j) => {
-                Some(store.detail_store.get_detailed_glyph_with_index(entry_i, detail_j).offset)
+                Some(store.detail_store.detailed_glyph_with_index(entry_i, detail_j).offset)
             }
         }
     }
 }
 
 /// Stores the glyph data belonging to a text run.
 ///
 /// Simple glyphs are stored inline in the `entry_buffer`, detailed glyphs are
@@ -667,17 +667,17 @@ impl<'a> GlyphIterator<'a> {
             }
         }
     }
 
     // Slow path when there is a complex glyph.
     #[inline(never)]
     fn next_complex_glyph(&mut self, entry: &GlyphEntry, i: CharIndex)
                           -> Option<(CharIndex, GlyphInfo<'a>)> {
-        let glyphs = self.store.detail_store.get_detailed_glyphs_for_entry(i, entry.glyph_count());
+        let glyphs = self.store.detail_store.detailed_glyphs_for_entry(i, entry.glyph_count());
         self.glyph_range = Some(range::each_index(CharIndex(0), CharIndex(glyphs.len() as isize)));
         self.next()
     }
 }
 
 impl<'a> Iterator for GlyphIterator<'a> {
     type Item  = (CharIndex, GlyphInfo<'a>);
 
--- a/servo/components/gfx/text/shaping/harfbuzz.rs
+++ b/servo/components/gfx/text/shaping/harfbuzz.rs
@@ -98,17 +98,17 @@ impl ShapedGlyphData {
         }
     }
 
     pub fn len(&self) -> usize {
         self.count
     }
 
     /// Returns shaped glyph data for one glyph, and updates the y-position of the pen.
-    pub fn get_entry_for_glyph(&self, i: usize, y_pos: &mut Au) -> ShapedGlyphEntry {
+    pub fn entry_for_glyph(&self, i: usize, y_pos: &mut Au) -> ShapedGlyphEntry {
         assert!(i < self.count);
 
         unsafe {
             let glyph_info_i = self.glyph_infos.offset(i as isize);
             let pos_info_i = self.pos_infos.offset(i as isize);
             let x_offset = Shaper::fixed_to_float((*pos_info_i).x_offset);
             let y_offset = Shaper::fixed_to_float((*pos_info_i).y_offset);
             let x_advance = Shaper::fixed_to_float((*pos_info_i).x_advance);
@@ -165,17 +165,17 @@ impl Drop for Shaper {
 impl Shaper {
     pub fn new(font: &mut Font, options: &ShapingOptions) -> Shaper {
         unsafe {
             let mut font_and_shaping_options = box FontAndShapingOptions {
                 font: font,
                 options: *options,
             };
             let hb_face: *mut hb_face_t =
-                RUST_hb_face_create_for_tables(get_font_table_func,
+                RUST_hb_face_create_for_tables(font_table_func,
                                           (&mut *font_and_shaping_options)
                                             as *mut FontAndShapingOptions
                                             as *mut c_void,
                                           None);
             let hb_font: *mut hb_font_t = RUST_hb_font_create(hb_face);
 
             // Set points-per-em. if zero, performs no hinting in that direction.
             let pt_size = font.actual_pt_size.to_f64_px();
@@ -443,32 +443,32 @@ impl Shaper {
                 // 1-to-1 mapping of character to glyph also treated as ligature start.
                 //
                 // NB: When we acquire the ability to handle ligatures that cross word boundaries,
                 // we'll need to do something special to handle `word-spacing` properly.
                 let character = text.char_at(char_byte_span.begin());
                 if is_bidi_control(character) {
                     glyphs.add_nonglyph_for_char_index(char_idx, false, false);
                 } else {
-                    let shape = glyph_data.get_entry_for_glyph(glyph_span.begin(), &mut y_pos);
+                    let shape = glyph_data.entry_for_glyph(glyph_span.begin(), &mut y_pos);
                     let advance = self.advance_for_shaped_glyph(shape.advance, character, options);
                     let data = GlyphData::new(shape.codepoint,
                                               advance,
                                               shape.offset,
                                               false,
                                               true,
                                               true);
                     glyphs.add_glyph_for_char_index(char_idx, Some(character), &data);
                 }
             } else {
                 // collect all glyphs to be assigned to the first character.
                 let mut datas = vec!();
 
                 for glyph_i in glyph_span.each_index() {
-                    let shape = glyph_data.get_entry_for_glyph(glyph_i, &mut y_pos);
+                    let shape = glyph_data.entry_for_glyph(glyph_i, &mut y_pos);
                     datas.push(GlyphData::new(shape.codepoint,
                                               shape.advance,
                                               shape.offset,
                                               false, // not missing
                                               true,  // treat as cluster start
                                               glyph_i > glyph_span.begin()));
                                               // all but first are ligature continuations
                 }
@@ -596,29 +596,29 @@ extern fn glyph_h_kerning_func(_: *mut h
 
     unsafe {
         let advance = (*font).glyph_h_kerning(first_glyph as GlyphId, second_glyph as GlyphId);
         Shaper::float_to_fixed(advance)
     }
 }
 
 // Callback to get a font table out of a font.
-extern fn get_font_table_func(_: *mut hb_face_t,
+extern fn font_table_func(_: *mut hb_face_t,
                               tag: hb_tag_t,
                               user_data: *mut c_void)
                               -> *mut hb_blob_t {
     unsafe {
         // NB: These asserts have security implications.
         let font_and_shaping_options: *const FontAndShapingOptions =
             user_data as *const FontAndShapingOptions;
         assert!(!font_and_shaping_options.is_null());
         assert!(!(*font_and_shaping_options).font.is_null());
 
         // TODO(Issue #197): reuse font table data, which will change the unsound trickery here.
-        match (*(*font_and_shaping_options).font).get_table_for_tag(tag as FontTableTag) {
+        match (*(*font_and_shaping_options).font).table_for_tag(tag as FontTableTag) {
             None => ptr::null_mut(),
             Some(font_table) => {
                 // `Box::into_raw` intentionally leaks the FontTable so we don't destroy the buffer
                 // while HarfBuzz is using it.  When HarfBuzz is done with the buffer, it will pass
                 // this raw pointer back to `destroy_blob_func` which will deallocate the Box.
                 let font_table_ptr = Box::into_raw(font_table);
 
                 let mut blob: *mut hb_blob_t = ptr::null_mut();
--- a/servo/components/layout/context.rs
+++ b/servo/components/layout/context.rs
@@ -171,18 +171,18 @@ impl<'a> LayoutContext<'a> {
     #[inline(always)]
     pub fn style_sharing_candidate_cache(&self) -> RefMut<StyleSharingCandidateCache> {
         self.cached_local_layout_context.style_sharing_candidate_cache.borrow_mut()
     }
 
     pub fn get_or_request_image(&self, url: Url, use_placeholder: UsePlaceholder)
                                 -> Option<Arc<Image>> {
         // See if the image is already available
-        let result = self.shared.image_cache_task.get_image_if_available(url.clone(),
-                                                                         use_placeholder);
+        let result = self.shared.image_cache_task.find_image(url.clone(),
+                                                             use_placeholder);
 
         match result {
             Ok(image) => Some(image),
             Err(state) => {
                 // If we are emitting an output file, then we need to block on
                 // image load or we risk emitting an output file missing the image.
                 let is_sync = opts::get().output_file.is_some() ||
                               opts::get().exit_after_load;
--- a/servo/components/layout/text.rs
+++ b/servo/components/layout/text.rs
@@ -154,17 +154,17 @@ impl TextRunScanner {
             let text_transform;
             let letter_spacing;
             let word_spacing;
             let text_rendering;
             {
                 let in_fragment = self.clump.front().unwrap();
                 let font_style = in_fragment.style().get_font_arc();
                 let inherited_text_style = in_fragment.style().get_inheritedtext();
-                fontgroup = font_context.get_layout_font_group_for_style(font_style);
+                fontgroup = font_context.layout_font_group_for_style(font_style);
                 compression = match in_fragment.white_space() {
                     white_space::T::normal | white_space::T::nowrap => {
                         CompressionMode::CompressWhitespaceNewline
                     }
                     white_space::T::pre => CompressionMode::CompressNone,
                 };
                 text_transform = inherited_text_style.text_transform;
                 letter_spacing = inherited_text_style.letter_spacing.0;
@@ -353,17 +353,17 @@ fn bounding_box_for_run_metrics(metrics:
 }
 
 /// Returns the metrics of the font represented by the given `FontStyle`, respectively.
 ///
 /// `#[inline]` because often the caller only needs a few fields from the font metrics.
 #[inline]
 pub fn font_metrics_for_style(font_context: &mut FontContext, font_style: Arc<FontStyle>)
                               -> FontMetrics {
-    let fontgroup = font_context.get_layout_font_group_for_style(font_style);
+    let fontgroup = font_context.layout_font_group_for_style(font_style);
     // FIXME(https://github.com/rust-lang/rust/issues/23338)
     let font = fontgroup.fonts[0].borrow();
     font.metrics.clone()
 }
 
 /// Returns the line block-size needed by the given computed style and font size.
 pub fn line_height_from_style(style: &ComputedValues, metrics: &FontMetrics) -> Au {
     let font_size = style.get_font().font_size;
--- a/servo/components/net/storage_task.rs
+++ b/servo/components/net/storage_task.rs
@@ -53,17 +53,17 @@ impl StorageManager {
                 }
                 StorageTaskMsg::Key(sender, url, storage_type, index) => {
                     self.key(sender, url, storage_type, index)
                 }
                 StorageTaskMsg::SetItem(sender, url, storage_type, name, value) => {
                     self.set_item(sender, url, storage_type, name, value)
                 }
                 StorageTaskMsg::GetItem(sender, url, storage_type, name) => {
-                    self.get_item(sender, url, storage_type, name)
+                    self.request_item(sender, url, storage_type, name)
                 }
                 StorageTaskMsg::RemoveItem(sender, url, storage_type, name) => {
                     self.remove_item(sender, url, storage_type, name)
                 }
                 StorageTaskMsg::Clear(sender, url, storage_type) => {
                     self.clear(sender, url, storage_type)
                 }
                 StorageTaskMsg::Exit => {
@@ -85,42 +85,42 @@ impl StorageManager {
                        -> &mut HashMap<String, BTreeMap<DOMString, DOMString>> {
         match storage_type {
             StorageType::Session => &mut self.session_data,
             StorageType::Local => &mut self.local_data
         }
     }
 
     fn length(&self, sender: IpcSender<usize>, url: Url, storage_type: StorageType) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
         sender.send(data.get(&origin).map_or(0, |entry| entry.len())).unwrap();
     }
 
     fn key(&self,
            sender: IpcSender<Option<DOMString>>,
            url: Url,
            storage_type: StorageType,
            index: u32) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
         sender.send(data.get(&origin)
                     .and_then(|entry| entry.keys().nth(index as usize))
                     .map(|key| key.clone())).unwrap();
     }
 
     /// Sends Some(old_value) in case there was a previous value with the same key name but with different
     /// value name, otherwise sends None
     fn set_item(&mut self,
                 sender: IpcSender<(bool, Option<DOMString>)>,
                 url: Url,
                 storage_type: StorageType,
                 name: DOMString,
                 value: DOMString) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data_mut(storage_type);
         if !data.contains_key(&origin) {
             data.insert(origin.clone(), BTreeMap::new());
         }
 
         let (changed, old_value) = data.get_mut(&origin).map(|entry| {
             entry.insert(name, value.clone()).map_or(
                 (true, None),
@@ -128,56 +128,56 @@ impl StorageManager {
                     (false, None)
                 } else {
                     (true, Some(old))
                 })
         }).unwrap();
         sender.send((changed, old_value)).unwrap();
     }
 
-    fn get_item(&self,
+    fn request_item(&self,
                 sender: IpcSender<Option<DOMString>>,
                 url: Url,
                 storage_type: StorageType,
                 name: DOMString) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
         sender.send(data.get(&origin)
                     .and_then(|entry| entry.get(&name))
                     .map(|value| value.to_string())).unwrap();
     }
 
     /// Sends Some(old_value) in case there was a previous value with the key name, otherwise sends None
     fn remove_item(&mut self,
                    sender: IpcSender<Option<DOMString>>,
                    url: Url,
                    storage_type: StorageType,
                    name: DOMString) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data_mut(storage_type);
         let old_value = data.get_mut(&origin).and_then(|entry| {
             entry.remove(&name)
         });
         sender.send(old_value).unwrap();
     }
 
     fn clear(&mut self, sender: IpcSender<bool>, url: Url, storage_type: StorageType) {
-        let origin = self.get_origin_as_string(url);
+        let origin = self.origin_as_string(url);
         let data = self.select_data_mut(storage_type);
         sender.send(data.get_mut(&origin)
                     .map_or(false, |entry| {
                         if !entry.is_empty() {
                             entry.clear();
                             true
                         } else {
                             false
                         }})).unwrap();
     }
 
-    fn get_origin_as_string(&self, url: Url) -> String {
+    fn origin_as_string(&self, url: Url) -> String {
         let mut origin = "".to_string();
         origin.push_str(&url.scheme);
         origin.push_str("://");
         url.domain().map(|domain| origin.push_str(&domain));
         url.port().map(|port| {
             origin.push_str(":");
             origin.push_str(&port.to_string());
         });
--- a/servo/components/net_traits/image_cache_task.rs
+++ b/servo/components/net_traits/image_cache_task.rs
@@ -106,17 +106,17 @@ impl ImageCacheTask {
                          url: Url,
                          result_chan: ImageCacheChan,
                          responder: Option<ImageResponder>) {
         let msg = ImageCacheCommand::RequestImage(url, result_chan, responder);
         self.chan.send(msg).unwrap();
     }
 
     /// Get the current state of an image. See ImageCacheCommand::GetImageIfAvailable.
-    pub fn get_image_if_available(&self, url: Url, use_placeholder: UsePlaceholder)
+    pub fn find_image(&self, url: Url, use_placeholder: UsePlaceholder)
                                   -> Result<Arc<Image>, ImageState> {
         let (sender, receiver) = ipc::channel().unwrap();
         let msg = ImageCacheCommand::GetImageIfAvailable(url, use_placeholder, sender);
         self.chan.send(msg).unwrap();
         receiver.recv().unwrap()
     }
 
     /// Shutdown the image cache task.
--- a/servo/components/profile/mem.rs
+++ b/servo/components/profile/mem.rs
@@ -381,43 +381,43 @@ mod system_reporter {
                         path: path,
                         kind: ReportKind::NonExplicitSize,
                         size: size,
                     });
                 }
             };
 
             // Virtual and physical memory usage, as reported by the OS.
-            report(path!["vsize"], get_vsize());
-            report(path!["resident"], get_resident());
+            report(path!["vsize"], vsize());
+            report(path!["resident"], resident());
 
             // Memory segments, as reported by the OS.
-            for seg in get_resident_segments() {
+            for seg in resident_segments() {
                 report(path!["resident-according-to-smaps", seg.0], Some(seg.1));
             }
 
             // Total number of bytes allocated by the application on the system
             // heap.
-            report(path![SYSTEM_HEAP_ALLOCATED_STR], get_system_heap_allocated());
+            report(path![SYSTEM_HEAP_ALLOCATED_STR], system_heap_allocated());
 
             // The descriptions of the following jemalloc measurements are taken
             // directly from the jemalloc documentation.
 
             // "Total number of bytes allocated by the application."
-            report(path![JEMALLOC_HEAP_ALLOCATED_STR], get_jemalloc_stat("stats.allocated"));
+            report(path![JEMALLOC_HEAP_ALLOCATED_STR], jemalloc_stat("stats.allocated"));
 
             // "Total number of bytes in active pages allocated by the application.
             // This is a multiple of the page size, and greater than or equal to
             // |stats.allocated|."
-            report(path!["jemalloc-heap-active"], get_jemalloc_stat("stats.active"));
+            report(path!["jemalloc-heap-active"], jemalloc_stat("stats.active"));
 
             // "Total number of bytes in chunks mapped on behalf of the application.
             // This is a multiple of the chunk size, and is at least as large as
             // |stats.active|. This does not include inactive chunks."
-            report(path!["jemalloc-heap-mapped"], get_jemalloc_stat("stats.mapped"));
+            report(path!["jemalloc-heap-mapped"], jemalloc_stat("stats.mapped"));
         }
 
         request.reports_channel.send(reports);
     }
 
     #[cfg(target_os = "linux")]
     extern {
         fn mallinfo() -> struct_mallinfo;
@@ -434,17 +434,17 @@ mod system_reporter {
         usmblks:  c_int,
         fsmblks:  c_int,
         uordblks: c_int,
         fordblks: c_int,
         keepcost: c_int,
     }
 
     #[cfg(target_os = "linux")]
-    fn get_system_heap_allocated() -> Option<usize> {
+    fn system_heap_allocated() -> Option<usize> {
         let info: struct_mallinfo = unsafe { mallinfo() };
 
         // The documentation in the glibc man page makes it sound like |uordblks| would suffice,
         // but that only gets the small allocations that are put in the brk heap. We need |hblkhd|
         // as well to get the larger allocations that are mmapped.
         //
         // These fields are unfortunately |int| and so can overflow (becoming negative) if memory
         // usage gets high enough. So don't report anything in that case. In the non-overflow case
@@ -453,26 +453,26 @@ mod system_reporter {
         if info.hblkhd < 0 || info.uordblks < 0 {
             None
         } else {
             Some(info.hblkhd as usize + info.uordblks as usize)
         }
     }
 
     #[cfg(not(target_os = "linux"))]
-    fn get_system_heap_allocated() -> Option<usize> {
+    fn system_heap_allocated() -> Option<usize> {
         None
     }
 
     extern {
         fn je_mallctl(name: *const c_char, oldp: *mut c_void, oldlenp: *mut size_t,
                       newp: *mut c_void, newlen: size_t) -> c_int;
     }
 
-    fn get_jemalloc_stat(value_name: &str) -> Option<usize> {
+    fn jemalloc_stat(value_name: &str) -> Option<usize> {
         // Before we request the measurement of interest, we first send an "epoch"
         // request. Without that jemalloc gives cached statistics(!) which can be
         // highly inaccurate.
         let epoch_name = "epoch";
         let epoch_c_name = CString::new(epoch_name).unwrap();
         let mut epoch: u64 = 0;
         let epoch_ptr = &mut epoch as *mut _ as *mut c_void;
         let mut epoch_len = size_of::<u64>() as size_t;
@@ -510,60 +510,60 @@ mod system_reporter {
     #[cfg(target_os = "linux")]
     fn page_size() -> usize {
         unsafe {
             ::libc::sysconf(::libc::_SC_PAGESIZE) as usize
         }
     }
 
     #[cfg(target_os = "linux")]
-    fn get_proc_self_statm_field(field: usize) -> Option<usize> {
+    fn proc_self_statm_field(field: usize) -> Option<usize> {
         use std::fs::File;
         use std::io::Read;
 
         let mut f = option_try!(File::open("/proc/self/statm").ok());
         let mut contents = String::new();
         option_try!(f.read_to_string(&mut contents).ok());
         let s = option_try!(contents.split_whitespace().nth(field));
         let npages = option_try!(s.parse::<usize>().ok());
         Some(npages * page_size())
     }
 
     #[cfg(target_os = "linux")]
-    fn get_vsize() -> Option<usize> {
-        get_proc_self_statm_field(0)
+    fn vsize() -> Option<usize> {
+        proc_self_statm_field(0)
     }
 
     #[cfg(target_os = "linux")]
-    fn get_resident() -> Option<usize> {
-        get_proc_self_statm_field(1)
+    fn resident() -> Option<usize> {
+        proc_self_statm_field(1)
     }
 
     #[cfg(target_os = "macos")]
-    fn get_vsize() -> Option<usize> {
+    fn vsize() -> Option<usize> {
         virtual_size()
     }
 
     #[cfg(target_os = "macos")]
-    fn get_resident() -> Option<usize> {
+    fn resident() -> Option<usize> {
         resident_size()
     }
 
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
-    fn get_vsize() -> Option<usize> {
+    fn vsize() -> Option<usize> {
         None
     }
 
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
-    fn get_resident() -> Option<usize> {
+    fn resident() -> Option<usize> {
         None
     }
 
     #[cfg(target_os = "linux")]
-    fn get_resident_segments() -> Vec<(String, usize)> {
+    fn resident_segments() -> Vec<(String, usize)> {
         use regex::Regex;
         use std::collections::HashMap;
         use std::collections::hash_map::Entry;
         use std::fs::File;
         use std::io::{BufReader, BufRead};
 
         // The first line of an entry in /proc/<pid>/smaps looks just like an entry
         // in /proc/<pid>/maps:
@@ -647,19 +647,19 @@ mod system_reporter {
                     }
                 }
 
                 looking_for = LookingFor::Segment;
             }
         }
 
         // Note that the sum of all these segments' RSS values differs from the "resident"
-        // measurement obtained via /proc/<pid>/statm in get_resident(). It's unclear why this
+        // measurement obtained via /proc/<pid>/statm in resident(). It's unclear why this
         // difference occurs; for some processes the measurements match, but for Servo they do not.
         let segs: Vec<(String, usize)> = seg_map.into_iter().collect();
         segs
     }
 
     #[cfg(not(target_os = "linux"))]
-    fn get_resident_segments() -> Vec<(String, usize)> {
+    fn resident_segments() -> Vec<(String, usize)> {
         vec![]
     }
 }
--- a/servo/components/servo/lib.rs
+++ b/servo/components/servo/lib.rs
@@ -182,18 +182,18 @@ impl Browser {
     pub fn repaint_synchronously(&mut self) {
         self.compositor.repaint_synchronously()
     }
 
     pub fn pinch_zoom_level(&self) -> f32 {
         self.compositor.pinch_zoom_level()
     }
 
-    pub fn get_title_for_main_frame(&self) {
-        self.compositor.get_title_for_main_frame()
+    pub fn request_title_for_main_frame(&self) {
+        self.compositor.title_for_main_frame()
     }
 
     pub fn shutdown(mut self) {
         self.compositor.shutdown();
     }
 }
 
 fn create_constellation(opts: opts::Opts,
--- a/servo/components/servo/main.rs
+++ b/servo/components/servo/main.rs
@@ -37,17 +37,17 @@ use std::rc::Rc;
 
 #[cfg(target_os = "android")]
 use std::borrow::ToOwned;
 
 fn main() {
     env_logger::init().unwrap();
 
     // Parse the command line options and store them globally
-    opts::from_cmdline_args(&*get_args());
+    opts::from_cmdline_args(&*args());
 
     setup_logging();
 
     // Possibly interpret the `HOST_FILE` environment variable
     hosts::global_init();
 
     let window = if opts::get().headless {
         None
@@ -133,25 +133,25 @@ fn setup_logging() {
     android::setup_logging();
 }
 
 #[cfg(not(target_os = "android"))]
 fn setup_logging() {
 }
 
 #[cfg(target_os = "android")]
-fn get_args() -> Vec<String> {
+fn args() -> Vec<String> {
     vec![
         "servo".to_owned(),
         "http://en.wikipedia.org/wiki/Rust".to_owned()
     ]
 }
 
 #[cfg(not(target_os = "android"))]
-fn get_args() -> Vec<String> {
+fn args() -> Vec<String> {
     use std::env;
     env::args().collect()
 }
 
 // This macro must be used at toplevel because it defines a nested
 // module, but macros can only accept identifiers - not paths -
 // preventing the expansion of this macro within the android module
 // without use of an additionl stub method or other hackery.
--- a/servo/components/webdriver_server/lib.rs
+++ b/servo/components/webdriver_server/lib.rs
@@ -80,45 +80,45 @@ impl Handler {
             session: None,
             constellation_chan: constellation_chan,
             script_timeout: 30_000,
             load_timeout: 300_000,
             implicit_wait_timeout: 0
         }
     }
 
-    fn get_root_pipeline(&self) -> WebDriverResult<PipelineId> {
+    fn root_pipeline(&self) -> WebDriverResult<PipelineId> {
         let interval = 20;
         let iterations = 30_000 / interval;
 
         for _ in 0..iterations {
-            if let Some(x) = self.get_pipeline(None) {
+            if let Some(x) = self.pipeline(None) {
                 return Ok(x)
             };
 
             sleep_ms(interval);
         };
 
         Err(WebDriverError::new(ErrorStatus::Timeout,
                                 "Failed to get root window handle"))
     }
 
-    fn get_frame_pipeline(&self) -> WebDriverResult<PipelineId> {
+    fn frame_pipeline(&self) -> WebDriverResult<PipelineId> {
         if let Some(ref session) = self.session {
-            match self.get_pipeline(session.frame_id) {
+            match self.pipeline(session.frame_id) {
                 Some(x) => Ok(x),
                 None => Err(WebDriverError::new(ErrorStatus::NoSuchFrame,
                                                 "Frame got closed"))
             }
         } else {
             panic!("Command tried to access session but session is None");
         }
     }
 
-    fn get_session(&self) -> WebDriverResult<&WebDriverSession> {
+    fn session(&self) -> WebDriverResult<&WebDriverSession> {
         match self.session {
             Some(ref x) => Ok(x),
             None => Err(WebDriverError::new(ErrorStatus::SessionNotCreated,
                                             "Session not created"))
         }
     }
 
     fn set_frame_id(&mut self, frame_id: Option<FrameId>) -> WebDriverResult<()> {
@@ -127,17 +127,17 @@ impl Handler {
                 x.frame_id = frame_id;
                 Ok(())
             },
             None => Err(WebDriverError::new(ErrorStatus::SessionNotCreated,
                                             "Session not created"))
         }
     }
 
-    fn get_pipeline(&self, frame_id: Option<FrameId>) -> Option<PipelineId> {
+    fn pipeline(&self, frame_id: Option<FrameId>) -> Option<PipelineId> {
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         const_chan.send(ConstellationMsg::GetPipeline(frame_id, sender)).unwrap();
 
 
         receiver.recv().unwrap()
     }
 
@@ -164,17 +164,17 @@ impl Handler {
 
     fn handle_get(&self, parameters: &GetParameters) -> WebDriverResult<WebDriverResponse> {
         let url = match Url::parse(&parameters.url[..]) {
             Ok(url) => url,
             Err(_) => return Err(WebDriverError::new(ErrorStatus::InvalidArgument,
                                                "Invalid URL"))
         };
 
-        let pipeline_id = try!(self.get_root_pipeline());
+        let pipeline_id = try!(self.root_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
 
         let load_data = LoadData::new(url);
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd_msg = WebDriverCommandMsg::LoadUrl(pipeline_id, load_data, sender.clone());
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
 
@@ -194,18 +194,18 @@ impl Handler {
         //Wait to get a load event
         match receiver.recv().unwrap() {
             LoadStatus::LoadComplete => Ok(WebDriverResponse::Void),
             LoadStatus::LoadTimeout => Err(WebDriverError::new(ErrorStatus::Timeout,
                                                                "Load timed out"))
         }
     }
 
-    fn handle_get_current_url(&self) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_root_pipeline());
+    fn handle_current_url(&self) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.root_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
 
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id,
                                                          WebDriverScriptCommand::GetUrl(sender));
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
 
@@ -222,55 +222,55 @@ impl Handler {
 
     fn handle_go_forward(&self) -> WebDriverResult<WebDriverResponse> {
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         const_chan.send(ConstellationMsg::Navigate(None, NavigationDirection::Forward)).unwrap();
         Ok(WebDriverResponse::Void)
     }
 
     fn handle_refresh(&self) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_root_pipeline());
+        let pipeline_id = try!(self.root_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
 
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd_msg = WebDriverCommandMsg::Refresh(pipeline_id, sender.clone());
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
 
         self.wait_for_load(sender, receiver)
     }
 
-    fn handle_get_title(&self) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_root_pipeline());
+    fn handle_title(&self) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.root_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id,
                                                          WebDriverScriptCommand::GetTitle(sender));
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
         let value = receiver.recv().unwrap();
         Ok(WebDriverResponse::Generic(ValueResponse::new(value.to_json())))
     }
 
-    fn handle_get_window_handle(&self) -> WebDriverResult<WebDriverResponse> {
+    fn handle_window_handle(&self) -> WebDriverResult<WebDriverResponse> {
         // For now we assume there's only one window so just use the session
         // id as the window id
         let handle = self.session.as_ref().unwrap().id.to_string();
         Ok(WebDriverResponse::Generic(ValueResponse::new(handle.to_json())))
     }
 
-    fn handle_get_window_handles(&self) -> WebDriverResult<WebDriverResponse> {
+    fn handle_window_handles(&self) -> WebDriverResult<WebDriverResponse> {
         // For now we assume there's only one window so just use the session
         // id as the window id
         let handles = vec![self.session.as_ref().unwrap().id.to_string().to_json()];
         Ok(WebDriverResponse::Generic(ValueResponse::new(handles.to_json())))
     }
 
     fn handle_find_element(&self, parameters: &LocatorParameters) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+        let pipeline_id = try!(self.frame_pipeline());
 
         if parameters.using != LocatorStrategy::CSSSelector {
             return Err(WebDriverError::new(ErrorStatus::UnsupportedOperation,
                                            "Unsupported locator strategy"))
         }
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
@@ -306,17 +306,17 @@ impl Handler {
         self.switch_to_frame(WebDriverFrameId::Parent)
     }
 
     fn switch_to_frame(&mut self, frame_id: WebDriverFrameId) -> WebDriverResult<WebDriverResponse> {
         if let WebDriverFrameId::Short(_) = frame_id {
             return Err(WebDriverError::new(ErrorStatus::UnsupportedOperation,
                                            "Selecting frame by id not supported"));
         }
-        let pipeline_id = try!(self.get_frame_pipeline());
+        let pipeline_id = try!(self.frame_pipeline());
         let (sender, receiver) = ipc::channel().unwrap();
         let cmd = WebDriverScriptCommand::GetFrameId(frame_id, sender);
         {
             let ConstellationChan(ref const_chan) = self.constellation_chan;
             const_chan.send(ConstellationMsg::WebDriverCommand(
                 WebDriverCommandMsg::ScriptCommand(pipeline_id, cmd))).unwrap();
         }
 
@@ -335,17 +335,17 @@ impl Handler {
         };
 
         self.set_frame_id(frame).unwrap();
         Ok(WebDriverResponse::Void)
     }
 
 
     fn handle_find_elements(&self, parameters: &LocatorParameters) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+        let pipeline_id = try!(self.frame_pipeline());
 
         if parameters.using != LocatorStrategy::CSSSelector {
             return Err(WebDriverError::new(ErrorStatus::UnsupportedOperation,
                                            "Unsupported locator strategy"))
         }
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
@@ -358,45 +358,45 @@ impl Handler {
                     |x| WebElement::new(x).to_json()).collect();
                 Ok(WebDriverResponse::Generic(ValueResponse::new(resp_value.to_json())))
             }
             Err(_) => Err(WebDriverError::new(ErrorStatus::InvalidSelector,
                                               "Invalid selector"))
         }
     }
 
-    fn handle_get_element_text(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+    fn handle_element_text(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.frame_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd = WebDriverScriptCommand::GetElementText(element.id.clone(), sender);
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id, cmd);
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
         match receiver.recv().unwrap() {
             Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse::new(value.to_json()))),
             Err(_) => Err(WebDriverError::new(ErrorStatus::StaleElementReference,
                                               "Unable to find element in document"))
         }
     }
 
-    fn handle_get_active_element(&self) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+    fn handle_active_element(&self) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.frame_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd = WebDriverScriptCommand::GetActiveElement(sender);
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id, cmd);
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
         let value = receiver.recv().unwrap().map(|x| WebElement::new(x).to_json());
         Ok(WebDriverResponse::Generic(ValueResponse::new(value.to_json())))
     }
 
-    fn handle_get_element_tag_name(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+    fn handle_element_tag_name(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.frame_pipeline());
 
         let (sender, receiver) = ipc::channel().unwrap();
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd = WebDriverScriptCommand::GetElementTagName(element.id.clone(), sender);
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id, cmd);
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
         match receiver.recv().unwrap() {
             Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse::new(value.to_json()))),
@@ -446,33 +446,33 @@ impl Handler {
         let command = WebDriverScriptCommand::ExecuteAsyncScript(script, sender);
         self.execute_script(command, receiver)
     }
 
     fn execute_script(&self,
                       command: WebDriverScriptCommand,
                       receiver: IpcReceiver<WebDriverJSResult>)
                       -> WebDriverResult<WebDriverResponse> {
-        let pipeline_id = try!(self.get_frame_pipeline());
+        let pipeline_id = try!(self.frame_pipeline());
 
         let ConstellationChan(ref const_chan) = self.constellation_chan;
         let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id, command);
         const_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
 
         match receiver.recv().unwrap() {
             Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse::new(value.to_json()))),
             Err(WebDriverJSError::Timeout) => Err(WebDriverError::new(ErrorStatus::Timeout, "")),
             Err(WebDriverJSError::UnknownType) => Err(WebDriverError::new(
                 ErrorStatus::UnsupportedOperation, "Unsupported return type"))
         }
     }
 
     fn handle_take_screenshot(&self) -> WebDriverResult<WebDriverResponse> {
         let mut img = None;
-        let pipeline_id = try!(self.get_root_pipeline());
+        let pipeline_id = try!(self.root_pipeline());
 
         let interval = 20;
         let iterations = 30_000 / interval;
 
         for _ in 0..iterations {
             let (sender, receiver) = ipc::channel().unwrap();
             let ConstellationChan(ref const_chan) = self.constellation_chan;
             let cmd_msg = WebDriverCommandMsg::TakeScreenshot(pipeline_id, sender);
@@ -512,37 +512,37 @@ impl WebDriverHandler for Handler {
                       _session: &Option<Session>,
                       msg: &WebDriverMessage) -> WebDriverResult<WebDriverResponse> {
 
         // Unless we are trying to create a new session, we need to ensure that a
         // session has previously been created
         match msg.command {
             WebDriverCommand::NewSession => {},
             _ => {
-                try!(self.get_session());
+                try!(self.session());
             }
         }
 
         match msg.command {
             WebDriverCommand::NewSession => self.handle_new_session(),
             WebDriverCommand::Get(ref parameters) => self.handle_get(parameters),
-            WebDriverCommand::GetCurrentUrl => self.handle_get_current_url(),
+            WebDriverCommand::GetCurrentUrl => self.handle_current_url(),
             WebDriverCommand::GoBack => self.handle_go_back(),
             WebDriverCommand::GoForward => self.handle_go_forward(),
             WebDriverCommand::Refresh => self.handle_refresh(),
-            WebDriverCommand::GetTitle => self.handle_get_title(),
-            WebDriverCommand::GetWindowHandle => self.handle_get_window_handle(),
-            WebDriverCommand::GetWindowHandles => self.handle_get_window_handles(),
+            WebDriverCommand::GetTitle => self.handle_title(),
+            WebDriverCommand::GetWindowHandle => self.handle_window_handle(),
+            WebDriverCommand::GetWindowHandles => self.handle_window_handles(),
             WebDriverCommand::SwitchToFrame(ref parameters) => self.handle_switch_to_frame(parameters),
             WebDriverCommand::SwitchToParentFrame => self.handle_switch_to_parent_frame(),
             WebDriverCommand::FindElement(ref parameters) => self.handle_find_element(parameters),
             WebDriverCommand::FindElements(ref parameters) => self.handle_find_elements(parameters),
-            WebDriverCommand::GetActiveElement => self.handle_get_active_element(),
-            WebDriverCommand::GetElementText(ref element) => self.handle_get_element_text(element),
-            WebDriverCommand::GetElementTagName(ref element) => self.handle_get_element_tag_name(element),
+            WebDriverCommand::GetActiveElement => self.handle_active_element(),
+            WebDriverCommand::GetElementText(ref element) => self.handle_element_text(element),
+            WebDriverCommand::GetElementTagName(ref element) => self.handle_element_tag_name(element),
             WebDriverCommand::ExecuteScript(ref x) => self.handle_execute_script(x),
             WebDriverCommand::ExecuteAsyncScript(ref x) => self.handle_execute_async_script(x),
             WebDriverCommand::SetTimeouts(ref x) => self.handle_set_timeouts(x),
             WebDriverCommand::TakeScreenshot => self.handle_take_screenshot(),
             _ => Err(WebDriverError::new(ErrorStatus::UnsupportedOperation,
                                          "Command not implemented"))
         }
     }
--- a/servo/ports/cef/browser.rs
+++ b/servo/ports/cef/browser.rs
@@ -35,20 +35,20 @@ impl ServoBrowser {
     fn handle_event(&mut self, event: WindowEvent) {
         match *self {
             ServoBrowser::OnScreen(ref mut browser) => { browser.handle_events(vec![event]); }
             ServoBrowser::OffScreen(ref mut browser) => { browser.handle_events(vec![event]); }
             ServoBrowser::Invalid => {}
         }
     }
 
-    pub fn get_title_for_main_frame(&self) {
+    pub fn request_title_for_main_frame(&self) {
         match *self {
-            ServoBrowser::OnScreen(ref browser) => browser.get_title_for_main_frame(),
-            ServoBrowser::OffScreen(ref browser) => browser.get_title_for_main_frame(),
+            ServoBrowser::OnScreen(ref browser) => browser.request_title_for_main_frame(),
+            ServoBrowser::OffScreen(ref browser) => browser.request_title_for_main_frame(),
             ServoBrowser::Invalid => {}
         }
     }
 
     pub fn pinch_zoom_level(&self) -> f32 {
         match *self {
             ServoBrowser::OnScreen(ref browser) => browser.pinch_zoom_level(),
             ServoBrowser::OffScreen(ref browser) => browser.pinch_zoom_level(),
@@ -160,17 +160,17 @@ impl ServoCefBrowser {
             window_handle: window_handle,
         }
     }
 }
 
 pub trait ServoCefBrowserExtensions {
     fn init(&self, window_info: &cef_window_info_t);
     fn send_window_event(&self, event: WindowEvent);
-    fn get_title_for_main_frame(&self);
+    fn request_title_for_main_frame(&self);
     fn pinch_zoom_level(&self) -> f32;
 }
 
 impl ServoCefBrowserExtensions for CefBrowser {
     fn init(&self, window_info: &cef_window_info_t) {
         if window_info.windowless_rendering_enabled != 0 {
             let window = window::Window::new(window_info.width, window_info.height);
             window.set_browser(self.clone());
@@ -202,18 +202,18 @@ impl ServoCefBrowserExtensions for CefBr
                     // cause general badness, so queue up that event instead of immediately
                     // processing it.
                     break
                 }
             }
         }
     }
 
-    fn get_title_for_main_frame(&self) {
-        self.downcast().servo_browser.borrow().get_title_for_main_frame()
+    fn request_title_for_main_frame(&self) {
+        self.downcast().servo_browser.borrow().request_title_for_main_frame()
     }
 
     fn pinch_zoom_level(&self) -> f32 {
         self.downcast().servo_browser.borrow().pinch_zoom_level()
     }
 }
 
 #[cfg(target_os="macos")]
--- a/servo/ports/cef/frame.rs
+++ b/servo/ports/cef/frame.rs
@@ -41,17 +41,17 @@ full_cef_class_impl! {
             let this = this.downcast();
             // FIXME(https://github.com/rust-lang/rust/issues/23338)
             let url = this.url.borrow();
             (*url).clone()
         }}
         fn get_text(&this, visitor: *mut cef_string_visitor_t [CefStringVisitor],) -> () {{
             let this = this.downcast();
             *this.title_visitor.borrow_mut() = Some(visitor);
-            this.browser.borrow().as_ref().unwrap().get_title_for_main_frame();
+            this.browser.borrow().as_ref().unwrap().request_title_for_main_frame();
         }}
     }
 }
 
 pub trait ServoCefFrameExtensions {
     fn set_browser(&self, browser: CefBrowser);
     fn set_url(&self, url: &[u16]);
     fn load(&self);