vendor servo commit b5f3d7dd413886037de8f1bc435ede34a98421b3 draft
authorVCS Sync <vcs-sync@mozilla.com>
Thu, 29 Dec 2016 19:57:22 +0000
changeset 458228 294073b80c1b49e996ecd9f1f3d13cb3d04cffa7
parent 458227 1675ac854c9a1507e7ed3ecffb80e1793d84eeb4
child 458229 7c7223a2f38d99b2a11d99ee43ca3c918c3c59c6
push id40933
push userbmo:slyu@mozilla.com
push dateTue, 10 Jan 2017 06:53:24 +0000
milestone53.0a1
vendor servo commit b5f3d7dd413886037de8f1bc435ede34a98421b3
servo/Info.plist
servo/python/servo/package_commands.py
servo/python/tidy/servo_tidy/tidy.py
servo/resources/package-prefs.json
servo/resources/prefs.json
servo/servo-tidy.toml
servo/support/android/build-apk/src/main.rs
servo/support/windows/Servo.wxs.mako
servo/tests/unit/servo_config/prefs.rs
--- a/servo/Info.plist
+++ b/servo/Info.plist
@@ -1,14 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
 	<key>CFBundleExecutable</key>
-	<string>run-servo</string>
+	<string>servo</string>
 	<key>CFBundleGetInfoString</key>
 	<string>Servo</string>
 	<key>CFBundleIconFile</key>
 	<string>servo.icns</string>
 	<key>CFBundleIdentifier</key>
 	<string>org.servo.Servo</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
--- a/servo/python/servo/package_commands.py
+++ b/servo/python/servo/package_commands.py
@@ -8,16 +8,17 @@
 # except according to those terms.
 
 from __future__ import print_function, unicode_literals
 
 import sys
 import os.path as path
 sys.path.append(path.join(path.dirname(sys.argv[0]), "components", "style", "properties", "Mako-0.9.1.zip"))
 
+import json
 import os
 import shutil
 import subprocess
 import mako.template
 
 from mach.registrar import Registrar
 
 from mach.decorators import (
@@ -73,17 +74,16 @@ def change_non_system_libraries_path(lib
     for lib in libraries:
         if is_system_library(lib):
             continue
         new_path = path.join(relative_path, path.basename(lib))
         install_name_tool(lib, new_path, binary)
 
 
 def copy_dependencies(binary_path, lib_path):
-
     relative_path = path.relpath(lib_path, path.dirname(binary_path)) + "/"
 
     # Update binary libraries
     binary_dependencies = set(otool(binary_path))
     change_non_system_libraries_path(binary_dependencies, relative_path, binary_path)
 
     # Update dependencies libraries
     need_checked = binary_dependencies
@@ -100,16 +100,41 @@ def copy_dependencies(binary_path, lib_p
             if not path.exists(new_path):
                 shutil.copyfile(f, new_path)
             change_non_system_libraries_path(need_relinked, relative_path, new_path)
             need_checked.update(need_relinked)
         checked.update(checking)
         need_checked.difference_update(checked)
 
 
+def change_prefs(resources_path, platform):
+    print("Swapping prefs")
+    prefs_path = path.join(resources_path, "prefs.json")
+    package_prefs_path = path.join(resources_path, "package-prefs.json")
+    os_type = "os:{}".format(platform)
+    with open(prefs_path) as prefs, open(package_prefs_path) as package_prefs:
+        prefs = json.load(prefs)
+        package_prefs = json.load(package_prefs)
+        for pref in package_prefs:
+            if os_type in pref:
+                prefs[pref.split(";")[1]] = package_prefs[pref]
+            if pref in prefs:
+                prefs[pref] = package_prefs[pref]
+        with open(prefs_path, "w") as out:
+            json.dump(prefs, out, sort_keys=True, indent=2)
+    delete(package_prefs_path)
+
+
+def get_browserhtml_path(binary_path):
+    browserhtml_path = find_dep_path_newest('browserhtml', binary_path)
+    if browserhtml_path:
+        return path.join(browserhtml_path, "out")
+    sys.exit("Could not find browserhtml package; perhaps you haven't built Servo.")
+
+
 @CommandProvider
 class PackageCommands(CommandBase):
     @Command('package',
              description='Package Servo',
              category='package')
     @CommandArgument('--release', '-r', action='store_true',
                      help='Package the release build')
     @CommandArgument('--dev', '-d', action='store_true',
@@ -118,75 +143,71 @@ class PackageCommands(CommandBase):
                      default=None,
                      action='store_true',
                      help='Package Android')
     def package(self, release=False, dev=False, android=None, debug=False, debugger=None):
         env = self.build_env()
         if android is None:
             android = self.config["build"]["android"]
         binary_path = self.get_binary_path(release, dev, android=android)
+        dir_to_root = self.get_top_dir()
+        target_dir = path.dirname(binary_path)
         if android:
             if dev:
                 env["NDK_DEBUG"] = "1"
                 env["ANT_FLAVOR"] = "debug"
                 dev_flag = "-d"
             else:
                 env["ANT_FLAVOR"] = "release"
                 dev_flag = ""
 
-            target_dir = path.dirname(binary_path)
             output_apk = "{}.apk".format(binary_path)
+
+            dir_to_apk = path.join(target_dir, "apk")
+            if path.exists(dir_to_apk):
+                print("Cleaning up from previous packaging")
+                delete(dir_to_apk)
+            shutil.copytree(path.join(dir_to_root, "support", "android", "apk"), dir_to_apk)
+
             blurdroid_path = find_dep_path_newest('blurdroid', binary_path)
             if blurdroid_path is None:
                 print("Could not find blurdroid package; perhaps you haven't built Servo.")
                 return 1
             else:
-                dir_to_libs = path.join("support", "android", "apk", "libs")
+                dir_to_libs = path.join(dir_to_apk, "libs")
                 if not path.exists(dir_to_libs):
                     os.makedirs(dir_to_libs)
                 shutil.copy2(blurdroid_path + '/out/blurdroid.jar', dir_to_libs)
             try:
                 with cd(path.join("support", "android", "build-apk")):
                     subprocess.check_call(["cargo", "run", "--", dev_flag, "-o", output_apk, "-t", target_dir,
-                                           "-r", self.get_top_dir()], env=env)
+                                           "-r", dir_to_root], env=env)
             except subprocess.CalledProcessError as e:
                 print("Packaging Android exited with return value %d" % e.returncode)
                 return e.returncode
         elif is_macosx():
-
-            dir_to_build = path.dirname(binary_path)
-            dir_to_root = self.get_top_dir()
-
             print("Creating Servo.app")
-            dir_to_dmg = path.join(dir_to_build, 'dmg')
+            dir_to_dmg = path.join(target_dir, 'dmg')
             dir_to_app = path.join(dir_to_dmg, 'Servo.app')
             dir_to_resources = path.join(dir_to_app, 'Contents', 'Resources')
             if path.exists(dir_to_dmg):
                 print("Cleaning up from previous packaging")
                 delete(dir_to_dmg)
-            browserhtml_path = find_dep_path_newest('browserhtml', binary_path)
-            if browserhtml_path is None:
-                print("Could not find browserhtml package; perhaps you haven't built Servo.")
-                return 1
+            browserhtml_path = get_browserhtml_path(binary_path)
 
             print("Copying files")
             shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
-            shutil.copytree(browserhtml_path, path.join(dir_to_resources, path.basename(browserhtml_path)))
+            shutil.copytree(browserhtml_path, path.join(dir_to_resources, 'browserhtml'))
             shutil.copy2(path.join(dir_to_root, 'Info.plist'), path.join(dir_to_app, 'Contents', 'Info.plist'))
 
             content_dir = path.join(dir_to_app, 'Contents', 'MacOS')
             os.makedirs(content_dir)
             shutil.copy2(binary_path, content_dir)
 
-            print("Swapping prefs")
-            package_prefs_path = path.join(dir_to_resources, 'package-prefs.json')
-            prefs_path = path.join(dir_to_resources, 'prefs.json')
-            delete(prefs_path)
-            shutil.copy2(package_prefs_path, prefs_path)
-            delete(package_prefs_path)
+            change_prefs(dir_to_resources, "macosx")
 
             print("Finding dylibs and relinking")
             copy_dependencies(path.join(content_dir, 'servo'), content_dir)
 
             print("Adding version to Credits.rtf")
             version_command = [binary_path, '--version']
             p = subprocess.Popen(version_command,
                                  stdout=subprocess.PIPE,
@@ -200,42 +221,32 @@ class PackageCommands(CommandBase):
             template_path = path.join(dir_to_resources, 'Credits.rtf.mako')
             credits_path = path.join(dir_to_resources, 'Credits.rtf')
             with open(template_path) as template_file:
                 template = mako.template.Template(template_file.read())
                 with open(credits_path, "w") as credits_file:
                     credits_file.write(template.render(version=version))
             delete(template_path)
 
-            print("Writing run-servo")
-            bhtml_path = path.join('${0%/*}', '..', 'Resources', path.basename(browserhtml_path), 'out', 'index.html')
-            runservo = os.open(
-                path.join(content_dir, 'run-servo'),
-                os.O_WRONLY | os.O_CREAT,
-                int("0755", 8)
-            )
-            os.write(runservo, '#!/bin/bash\nexec ${0%/*}/servo ' + bhtml_path)
-            os.close(runservo)
-
             print("Creating dmg")
             os.symlink('/Applications', path.join(dir_to_dmg, 'Applications'))
-            dmg_path = path.join(dir_to_build, "servo-tech-demo.dmg")
+            dmg_path = path.join(target_dir, "servo-tech-demo.dmg")
 
             try:
                 subprocess.check_call(['hdiutil', 'create', '-volname', 'Servo', dmg_path, '-srcfolder', dir_to_dmg])
             except subprocess.CalledProcessError as e:
                 print("Packaging MacOS dmg exited with return value %d" % e.returncode)
                 return e.returncode
             print("Cleaning up")
             delete(dir_to_dmg)
             print("Packaged Servo into " + dmg_path)
 
             print("Creating brew package")
-            dir_to_brew = path.join(dir_to_build, 'brew_tmp')
-            dir_to_tar = path.join(dir_to_build, 'brew')
+            dir_to_brew = path.join(target_dir, 'brew_tmp')
+            dir_to_tar = path.join(target_dir, 'brew')
             if not path.exists(dir_to_tar):
                 os.makedirs(dir_to_tar)
             tar_path = path.join(dir_to_tar, "servo.tar.gz")
             if path.exists(dir_to_brew):
                 print("Cleaning up from previous packaging")
                 delete(dir_to_brew)
             if path.exists(tar_path):
                 print("Deleting existing package")
@@ -245,39 +256,39 @@ class PackageCommands(CommandBase):
             shutil.copy2(binary_path, path.join(dir_to_brew, 'bin', 'servo'))
             # Note that in the context of Homebrew, libexec is reserved for private use by the formula
             # and therefore is not symlinked into HOMEBREW_PREFIX.
             os.makedirs(path.join(dir_to_brew, 'libexec'))
             copy_dependencies(path.join(dir_to_brew, 'bin', 'servo'), path.join(dir_to_brew, 'libexec'))
             archive_deterministically(dir_to_brew, tar_path, prepend_path='servo/')
             delete(dir_to_brew)
             print("Packaged Servo into " + tar_path)
-
         elif is_windows():
-            dir_to_package = path.dirname(binary_path)
-            dir_to_root = self.get_top_dir()
-            dir_to_msi = path.join(dir_to_package, 'msi')
+            dir_to_msi = path.join(target_dir, 'msi')
             if path.exists(dir_to_msi):
                 print("Cleaning up from previous packaging")
                 delete(dir_to_msi)
             os.makedirs(dir_to_msi)
-            top_path = dir_to_root
-            browserhtml_path = find_dep_path_newest('browserhtml', binary_path)
-            if browserhtml_path is None:
-                print("Could not find browserhtml package; perhaps you haven't built Servo.")
-                return 1
-            browserhtml_path = path.join(browserhtml_path, "out")
+            browserhtml_path = get_browserhtml_path(binary_path)
+
+            print("Copying files")
+            dir_to_resources = path.join(dir_to_msi, 'resources')
+            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
+
+            change_prefs(dir_to_resources, "windows")
+
             # generate Servo.wxs
             template_path = path.join(dir_to_root, "support", "windows", "Servo.wxs.mako")
             template = Template(open(template_path).read())
             wxs_path = path.join(dir_to_msi, "Servo.wxs")
             open(wxs_path, "w").write(template.render(
-                exe_path=dir_to_package,
-                top_path=top_path,
+                exe_path=target_dir,
+                resources_path=dir_to_resources,
                 browserhtml_path=browserhtml_path))
+
             # run candle and light
             print("Creating MSI")
             try:
                 with cd(dir_to_msi):
                     subprocess.check_call(['candle', wxs_path])
             except subprocess.CalledProcessError as e:
                 print("WiX candle exited with return value %d" % e.returncode)
                 return e.returncode
@@ -286,46 +297,33 @@ class PackageCommands(CommandBase):
                 with cd(dir_to_msi):
                     subprocess.check_call(['light', wxsobj_path])
             except subprocess.CalledProcessError as e:
                 print("WiX light exited with return value %d" % e.returncode)
                 return e.returncode
             msi_path = path.join(dir_to_msi, "Servo.msi")
             print("Packaged Servo into {}".format(msi_path))
         else:
-            dir_to_temp = path.join(path.dirname(binary_path), 'packaging-temp')
-            browserhtml_path = find_dep_path_newest('browserhtml', binary_path)
-            if browserhtml_path is None:
-                print("Could not find browserhtml package; perhaps you haven't built Servo.")
-                return 1
+            dir_to_temp = path.join(target_dir, 'packaging-temp')
+            browserhtml_path = get_browserhtml_path(binary_path)
             if path.exists(dir_to_temp):
                 # TODO(aneeshusa): lock dir_to_temp to prevent simultaneous builds
                 print("Cleaning up from previous packaging")
                 delete(dir_to_temp)
 
             print("Copying files")
             dir_to_resources = path.join(dir_to_temp, 'resources')
-            shutil.copytree(path.join(self.get_top_dir(), 'resources'), dir_to_resources)
+            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
             shutil.copytree(browserhtml_path, path.join(dir_to_temp, 'browserhtml'))
             shutil.copy(binary_path, dir_to_temp)
 
-            print("Writing runservo.sh")
-            # TODO: deduplicate this arg list from post_build_commands
-            servo_args = ['-b',
-                          '--pref', 'dom.mozbrowser.enabled',
-                          '--pref', 'dom.forcetouch.enabled',
-                          '--pref', 'shell.builtin-key-shortcuts.enabled=false',
-                          path.join('./browserhtml', 'out', 'index.html')]
-
-            runservo = os.open(path.join(dir_to_temp, 'runservo.sh'), os.O_WRONLY | os.O_CREAT, int("0755", 8))
-            os.write(runservo, "#!/usr/bin/env sh\n./servo " + ' '.join(servo_args))
-            os.close(runservo)
+            change_prefs(dir_to_resources, "linux")
 
             print("Creating tarball")
-            tar_path = path.join(path.dirname(binary_path), 'servo-tech-demo.tar.gz')
+            tar_path = path.join(target_dir, 'servo-tech-demo.tar.gz')
 
             archive_deterministically(dir_to_temp, tar_path, prepend_path='servo/')
 
             print("Cleaning up")
             delete(dir_to_temp)
             print("Packaged Servo into " + tar_path)
 
     @Command('install',
--- a/servo/python/tidy/servo_tidy/tidy.py
+++ b/servo/python/tidy/servo_tidy/tidy.py
@@ -729,17 +729,17 @@ def check_for_alphabetical_sorted_json_k
     for a, b in zip(key_value_pairs[:-1], key_value_pairs[1:]):
         if a[0] > b[0]:
             raise KeyError("Unordered key (found %s before %s)" % (a[0], b[0]))
 
 
 def check_json_requirements(filename):
     def check_fn(key_value_pairs):
         check_for_possible_duplicate_json_keys(key_value_pairs)
-        if filename in config["check-ordered-json-keys"]:
+        if filename in normilize_paths(config["check-ordered-json-keys"]):
             check_for_alphabetical_sorted_json_keys(key_value_pairs)
     return check_fn
 
 
 def check_json(filename, contents):
     if not filename.endswith(".json"):
         raise StopIteration
 
--- a/servo/resources/package-prefs.json
+++ b/servo/resources/package-prefs.json
@@ -1,59 +1,8 @@
 {
-  "dom.bluetooth.enabled": false,
-  "dom.bluetooth.testing.enabled": false,
   "dom.forcetouch.enabled": true,
-  "dom.mouseevent.which.enabled": false,
   "dom.mozbrowser.enabled": true,
-  "dom.serviceworker.timeout_seconds": 60,
-  "dom.testable_crash.enabled": false,
-  "dom.testbinding.enabled": false,
-  "js.asmjs.enabled": true,
-  "js.asyncstack.enabled": false,
-  "js.baseline.enabled": true,
-  "js.baseline.unsafe_eager_compilation.enabled": false,
-  "js.discard_system_source.enabled": false,
-  "js.dump_stack_on_debuggee_would_run.enabled": false,
-  "js.ion.enabled": true,
-  "js.ion.offthread_compilation.enabled": true,
-  "js.ion.unsafe_eager_compilation.enabled": false,
-  "js.mem.gc.allocation_threshold_mb": 30,
-  "js.mem.gc.compacting.enabled": true,
-  "js.mem.gc.decommit_threshold_mb": 32,
-  "js.mem.gc.dynamic_heap_growth.enabled": true,
-  "js.mem.gc.dynamic_mark_slice.enabled": true,
-  "js.mem.gc.empty_chunk_count_max": 30,
-  "js.mem.gc.empty_chunk_count_min": 1,
-  "js.mem.gc.high_frequency_heap_growth_max": 300,
-  "js.mem.gc.high_frequency_heap_growth_min": 150,
-  "js.mem.gc.high_frequency_high_limit_mb": 500,
-  "js.mem.gc.high_frequency_low_limit_mb": 100,
-  "js.mem.gc.high_frequency_time_limit_ms": 1000,
-  "js.mem.gc.incremental.enabled": true,
-  "js.mem.gc.incremental.slice_ms": 10,
-  "js.mem.gc.low_frequency_heap_growth": 150,
-  "js.mem.gc.per_compartment.enabled": true,
-  "js.mem.gc.refresh_frame_slices.enabled": true,
-  "js.mem.gc.zeal.frequency": 100,
-  "js.mem.gc.zeal.level": 0,
-  "js.mem.high_water_mark": 128,
-  "js.mem.max": -1,
-  "js.native_regexp.enabled": true,
-  "js.parallel_parsing.enabled": true,
-  "js.shared_memory.enabled": true,
-  "js.strict.debug.enabled": false,
-  "js.strict.enabled": false,
-  "js.throw_on_asmjs_validation_failure.enabled": false,
-  "js.throw_on_debuggee_would_run.enabled": false,
-  "js.werror.enabled": false,
-  "layout.column-count.enabled": false,
-  "layout.column-gap.enabled": false,
-  "layout.column-width.enabled": false,
-  "layout.columns.enabled": false,
-  "layout.text-orientation.enabled": false,
-  "layout.viewport.enabled": false,
-  "layout.writing-mode.enabled": false,
-  "network.mime.sniff": false,
   "shell.builtin-key-shortcuts.enabled": false,
-  "shell.homepage": "https://servo.org",
-  "shell.native-titlebar.enabled": false
+  "os:windows,os:linux;shell.homepage": "browserhtml/index.html",
+  "os:macosx;shell.homepage": "../Resources/browserhtml/index.html",
+  "os:macosx;shell.native-titlebar.enabled": false
 }
--- a/servo/resources/prefs.json
+++ b/servo/resources/prefs.json
@@ -50,11 +50,11 @@
   "layout.column-gap.enabled": false,
   "layout.column-width.enabled": false,
   "layout.columns.enabled": false,
   "layout.text-orientation.enabled": false,
   "layout.viewport.enabled": false,
   "layout.writing-mode.enabled": false,
   "network.mime.sniff": false,
   "shell.builtin-key-shortcuts.enabled": true,
-  "shell.homepage": "http://servo.org",
+  "shell.homepage": "https://servo.org",
   "shell.native-titlebar.enabled": true
 }
--- a/servo/servo-tidy.toml
+++ b/servo/servo-tidy.toml
@@ -1,14 +1,13 @@
 [configs]
 skip-check-length = false
 skip-check-licenses = false
 check-ordered-json-keys = [
   "./resources/prefs.json",
-  "./resources/package-prefs.json",
 ]
 lint-scripts = [
   "./python/servo/lints/wpt_lint.py",
 ]
 
 [ignore]
 # Ignored packages with duplicated versions
 packages = ["bitflags", "lazy_static", "semver", "libloading"]
--- a/servo/support/android/build-apk/src/main.rs
+++ b/servo/support/android/build-apk/src/main.rs
@@ -42,17 +42,17 @@ fn main() {
 
     // Get the standalone NDK path from NDK_STANDALONE env.
     //  let standalone_path = env::var("NDK_STANDALONE").ok().unwrap_or("/opt/ndk_standalone".to_string());
     //  let standalone_path = Path::new(&standalone_path);
 
     let debug = passthrough.contains(&"-d".to_string());
 
     // Set the build directory that will contain all the necessary files to create the apk
-    let directory = args.root_path.join("support").join("android").join("apk");
+    let directory = args.target_path.join("apk");
     let resdir = args.root_path.join("resources/");
 
     // executing ndk-build
     env::set_var("V", "1");
     if debug {
         env::set_var("NDK_DEBUG", "1");
         env::set_var("APP_OPTIM", "0");
     } else {
--- a/servo/support/windows/Servo.wxs.mako
+++ b/servo/support/windows/Servo.wxs.mako
@@ -33,28 +33,27 @@
                     Source="${windowize(exe_path)}\servo.exe"
                     KeyPath="yes">
                 <Shortcut Id="StartMenuServoTechDemo"
                           Directory="ProgramMenuDir"
                           Name="Servo Tech Demo"
                           WorkingDirectory="INSTALLDIR"
                           Icon="Servo.ico"
                           IconIndex="0"
-                          Arguments="-w --pref dom.mozbrowser.enabled --pref shell.builtin-key-shortcuts.enabled=false browserhtml\index.html"
                           Advertise="yes"/>
               </File>
               <File Id="ServoManifest"
                     Name="servo.exe.manifest"
                     Source="${windowize(exe_path)}\servo.exe.manifest"
                     DiskId="1"/>
 
               ${include_dependencies()}
             </Component>
 
-            ${include_directory(path.join(top_path, "resources"), "resources")}
+            ${include_directory(resources_path, "resources")}
             ${include_directory(browserhtml_path, "browserhtml")}
           </Directory>
         </Directory>
       </Directory>
 
       <Directory Id="ProgramMenuFolder" Name="Programs">
         <Directory Id="ProgramMenuDir" Name="Servo Tech Demo">
           <Component Id="ProgramMenuDir" Guid="e04737ce-16eb-4977-9b4c-ed2db8a5a77d">
@@ -72,17 +71,17 @@
     <Feature Id="Complete" Level="1">
       <ComponentRef Id="Servo"/>
       % for c in components:
       <ComponentRef Id="${c}"/>
       % endfor
       <ComponentRef Id="ProgramMenuDir"/>
     </Feature>
 
-    <Icon Id="Servo.ico" SourceFile="${windowize(top_path)}\resources\Servo.ico"/>
+    <Icon Id="Servo.ico" SourceFile="${windowize(resources_path)}\Servo.ico"/>
   </Product>
 </Wix>
 <%!
 import os
 import os.path as path
 import re
 import uuid
 from servo.command_base import host_triple
--- a/servo/tests/unit/servo_config/prefs.rs
+++ b/servo/tests/unit/servo_config/prefs.rs
@@ -7,17 +7,17 @@ use servo_config::prefs::{PREFS, PrefVal
 use std::fs::{self, File};
 use std::io::{Read, Write};
 
 #[test]
 fn test_create_pref() {
     let json_str = "{\
   \"layout.writing-mode.enabled\": true,\
   \"network.mime.sniff\": false,\
-  \"shell.homepage\": \"http://servo.org\"\
+  \"shell.homepage\": \"https://servo.org\"\
 }";
 
     let prefs = read_prefs_from_file(json_str.as_bytes());
     assert!(prefs.is_ok());
     let prefs = prefs.unwrap();
 
     assert_eq!(prefs.len(), 3);
 }
@@ -28,21 +28,21 @@ fn test_get_set_reset_extend() {
   \"layout.writing-mode.enabled\": true,\
   \"extra.stuff\": false,\
   \"shell.homepage\": \"https://google.com\"\
 }";
 
     assert_eq!(*PREFS.get("test"), PrefValue::Missing);
     PREFS.set("test", PrefValue::String("hi".to_owned()));
     assert_eq!(*PREFS.get("test"), PrefValue::String("hi".to_owned()));
-    assert_eq!(*PREFS.get("shell.homepage"), PrefValue::String("http://servo.org".to_owned()));
+    assert_eq!(*PREFS.get("shell.homepage"), PrefValue::String("https://servo.org".to_owned()));
     PREFS.set("shell.homepage", PrefValue::Boolean(true));
     assert_eq!(*PREFS.get("shell.homepage"), PrefValue::Boolean(true));
     PREFS.reset("shell.homepage");
-    assert_eq!(*PREFS.get("shell.homepage"), PrefValue::String("http://servo.org".to_owned()));
+    assert_eq!(*PREFS.get("shell.homepage"), PrefValue::String("https://servo.org".to_owned()));
 
     let extension = read_prefs_from_file(json_str.as_bytes()).unwrap();
     PREFS.extend(extension);
     assert_eq!(*PREFS.get("shell.homepage"), PrefValue::String("https://google.com".to_owned()));
     assert_eq!(*PREFS.get("layout.writing-mode.enabled"), PrefValue::Boolean(true));
     assert_eq!(*PREFS.get("extra.stuff"), PrefValue::Boolean(false));
 }