--- a/testing/geckodriver/src/marionette.rs
+++ b/testing/geckodriver/src/marionette.rs
@@ -67,27 +67,30 @@ pub fn extension_routes() -> Vec<(Method
               "/session/{sessionId}/moz/xbl/{elementId}/anonymous_children",
               GeckoExtensionRoute::XblAnonymousChildren),
              (Method::Post,
               "/session/{sessionId}/moz/xbl/{elementId}/anonymous_by_attribute",
               GeckoExtensionRoute::XblAnonymousByAttribute),
              (Method::Post, "/session/{sessionId}/moz/addon/install",
                 GeckoExtensionRoute::InstallAddon),
              (Method::Post, "/session/{sessionId}/moz/addon/uninstall",
-                GeckoExtensionRoute::UninstallAddon)];
+                GeckoExtensionRoute::UninstallAddon),
+             (Method::Get, "/session/{sessionId}/moz/screenshot/full",
+                GeckoExtensionRoute::TakeFullScreenshot)];
 }
 
 #[derive(Clone, PartialEq)]
 pub enum GeckoExtensionRoute {
     GetContext,
     SetContext,
     XblAnonymousChildren,
     XblAnonymousByAttribute,
     InstallAddon,
     UninstallAddon,
+    TakeFullScreenshot
 }
 
 impl WebDriverExtensionRoute for GeckoExtensionRoute {
     type Command = GeckoExtensionCommand;
 
     fn command(&self,
                captures: &Captures,
                body_data: &Json)
@@ -115,40 +118,43 @@ impl WebDriverExtensionRoute for GeckoEx
             &GeckoExtensionRoute::InstallAddon => {
                 let parameters: AddonInstallParameters = try!(Parameters::from_json(&body_data));
                 GeckoExtensionCommand::InstallAddon(parameters)
             }
             &GeckoExtensionRoute::UninstallAddon => {
                 let parameters: AddonUninstallParameters = try!(Parameters::from_json(&body_data));
                 GeckoExtensionCommand::UninstallAddon(parameters)
             }
+            &GeckoExtensionRoute::TakeFullScreenshot => GeckoExtensionCommand::TakeFullScreenshot
         };
         Ok(WebDriverCommand::Extension(command))
     }
 }
 
 #[derive(Clone, PartialEq)]
 pub enum GeckoExtensionCommand {
     GetContext,
     SetContext(GeckoContextParameters),
     XblAnonymousChildren(WebElement),
     XblAnonymousByAttribute(WebElement, AttributeParameters),
     InstallAddon(AddonInstallParameters),
-    UninstallAddon(AddonUninstallParameters)
+    UninstallAddon(AddonUninstallParameters),
+    TakeFullScreenshot
 }
 
 impl WebDriverExtensionCommand for GeckoExtensionCommand {
     fn parameters_json(&self) -> Option<Json> {
         match self {
             &GeckoExtensionCommand::GetContext => None,
             &GeckoExtensionCommand::SetContext(ref x) => Some(x.to_json()),
             &GeckoExtensionCommand::XblAnonymousChildren(_) => None,
             &GeckoExtensionCommand::XblAnonymousByAttribute(_, ref x) => Some(x.to_json()),
             &GeckoExtensionCommand::InstallAddon(ref x) => Some(x.to_json()),
             &GeckoExtensionCommand::UninstallAddon(ref x) => Some(x.to_json()),
+            &GeckoExtensionCommand::TakeFullScreenshot => None
         }
     }
 }
 
 #[derive(Clone, Debug, PartialEq)]
 enum GeckoContext {
     Content,
     Chrome,
@@ -914,17 +920,18 @@ impl MarionetteSession {
                 WebDriverResponse::NewSession(NewSessionResponse::new(
                     session_id.to_string(), Json::Object(capabilities.clone())))
             },
             DeleteSession => {
                 WebDriverResponse::DeleteSession
             },
             Extension(ref extension) => {
                 match extension {
-                    &GeckoExtensionCommand::GetContext => {
+                    &GeckoExtensionCommand::GetContext |
+                    &GeckoExtensionCommand::TakeFullScreenshot => {
                         let value = try_opt!(resp.result.find("value"),
                                              ErrorStatus::UnknownError,
                                              "Failed to find value field");
                         WebDriverResponse::Generic(ValueResponse::new(value.clone()))
                     },
                     &GeckoExtensionCommand::SetContext(_) => WebDriverResponse::Void,
                     &GeckoExtensionCommand::XblAnonymousChildren(_) => {
                         let els_vec = try_opt!(resp.result.as_array(),
@@ -1184,16 +1191,23 @@ impl MarionetteCommand {
                         data.insert("element".to_string(), e.id.to_json());
                         (Some("findElement"), Some(Ok(data)))
                     },
                     &GeckoExtensionCommand::InstallAddon(ref x) => {
                         (Some("addon:install"), Some(x.to_marionette()))
                     },
                     &GeckoExtensionCommand::UninstallAddon(ref x) => {
                         (Some("addon:uninstall"), Some(x.to_marionette()))
+                    },
+                    &GeckoExtensionCommand::TakeFullScreenshot => {
+                        let mut data = BTreeMap::new();
+                        data.insert("id".to_string(), Json::Null);
+                        data.insert("highlights".to_string(), Json::Array(vec![]));
+                        data.insert("full".to_string(), Json::Boolean(true));
+                        (Some("takeScreenshot"), Some(Ok(data)))
                     }
                 }
             }
         };
 
         let name = try_opt!(opt_name,
                             ErrorStatus::UnsupportedOperation,
                             "Operation not supported");