diff --git a/res/values/strings.xml b/res/values/strings.xml
index 307459c..47f217b 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -567,6 +567,8 @@
     <!-- Do not tranlsate.  Development option -->
     <string name="pref_development_visual_indicator" translatable="false">Enable Visual Indicator</string>
     <!-- Do not tranlsate.  Development option -->
+    <string name="pref_development_cpu_upload_path" translatable="false">Enable Cpu Upload Path</string>
+    <!-- Do not tranlsate.  Development option -->
     <string name="js_engine_flags" translatable="false">Set JS flags</string>
     <!-- Do not tranlsate.  Development option -->
     <string name="pref_development_uastring" translatable="false">UAString</string>
diff --git a/res/xml/debug_preferences.xml b/res/xml/debug_preferences.xml
index 2d15ab2..abbd07e 100644
--- a/res/xml/debug_preferences.xml
+++ b/res/xml/debug_preferences.xml
@@ -39,6 +39,11 @@
         android:defaultValue="false"
         android:title="@string/pref_development_visual_indicator" />
 
+    <CheckBoxPreference
+        android:key="enable_cpu_upload_path"
+        android:defaultValue="true"
+        android:title="@string/pref_development_cpu_upload_path" />
+
     <!-- The javascript console is enabled by default when the user has
          also enabled debug mode by navigating to about:debug. -->
     <CheckBoxPreference
