commit de8837599112608feecea65a1e520866bc171569
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Fri Dec 25 23:37:36 2015 -0500

    * admin/gitmerge.el: Tweaks that seemed necessary
    
    * admin/gitmerge.el (gitmerge-skip-regexp): Remove "sync".
    (gitmerge-maybe-resume): Provide explicit empty commit message.

diff --git a/admin/gitmerge.el b/admin/gitmerge.el
index 1e92c8c..69e4d28 100644
--- a/admin/gitmerge.el
+++ b/admin/gitmerge.el
@@ -48,7 +48,9 @@
 (require 'smerge-mode)
 
 (defvar gitmerge-skip-regexp
-  "back[- ]?port\\|merge\\|sync\\|re-?generate\\|bump version\\|from trunk\\|\
+  ;; We used to include "sync" in there, but in my experience it only
+  ;; caused false positives.  --Stef
+  "back[- ]?port\\|merge\\|re-?generate\\|bump version\\|from trunk\\|\
 Auto-commit"
   "Regexp matching logs of revisions that might be skipped.
 `gitmerge-missing' will ask you if it should skip any matches.")
@@ -429,8 +431,14 @@ If so, add no longer conflicted files and commit."
 	(when mergehead
 	  (with-current-buffer (get-buffer-create gitmerge-output-buffer)
 	    (erase-buffer)
+            ;; FIXME: We add "-m-" because the default commit message
+            ;; apparently tickles our commit hook:
+            ;;    Line longer than 78 characters in commit message
+            ;;    Line longer than 78 characters in commit message
+            ;;    Line longer than 78 characters in commit message
+            ;;    Commit aborted; please see the file CONTRIBUTE
 	    (unless (zerop (call-process "git" nil t nil
-					 "commit" "--no-edit"))
+					 "commit" "--no-edit" "-m-"))
 	      (error "Git error during merge - fix it manually"))))
 	;; Successfully resumed.
 	t))))

commit 5917b504874faaa849f3976e0bfd75383745bd44
Author: Łukasz Stelmach <stlman@poczta.fm>
Date:   Sat Dec 26 03:47:21 2015 +0100

    Use a different port for TLS erc
    
    * lisp/erc/erc.el (erc-default-port-tls): New variable
    (bug#19497).
    * lisp/erc/erc.el (erc-tls): Use it.
    
    Copyright-paperwork-exempt: yes

diff --git a/etc/NEWS b/etc/NEWS
index edd8147..20a1232 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -376,6 +376,9 @@ hide all messages of the specified type, where `erc-network-hide-list'
 and `erc-channel-hide-list' will only hide the specified message types
 for the respective specified targets.
 
+*** New variable `erc-default-port-tls' used to connect to TLS IRC
+servers.
+
 ** Midnight-mode
 *** `midnight-mode' is a proper minor mode.
 *** clean-buffer-*-regexps can now specify buffers via predicate functions.
diff --git a/lisp/erc/erc.el b/lisp/erc/erc.el
index 8e26db1..cd8c8a8 100644
--- a/lisp/erc/erc.el
+++ b/lisp/erc/erc.el
@@ -1471,6 +1471,10 @@ Defaults to the server buffer."
 (defconst erc-default-port 6667
   "IRC port to use if it cannot be detected otherwise.")
 
+(defconst erc-default-port-tls 6697
+  "IRC port to use for encrypted connections if it cannot be
+  detected otherwise.")
+
 (defcustom erc-join-buffer 'buffer
   "Determines how to display a newly created IRC buffer.
 
@@ -2194,7 +2198,8 @@ be invoked for the values of the other parameters."
 (defun erc-tls (&rest r)
   "Interactively select TLS connection parameters and run ERC.
 Arguments are the same as for `erc'."
-  (interactive (erc-select-read-args))
+  (interactive (let ((erc-default-port erc-default-port-tls))
+		 (erc-select-read-args)))
   (let ((erc-server-connect-function 'erc-open-tls-stream))
     (apply #'erc r)))
 

commit b792ecea1715e080ad8e232d3d154b8a25d2edfb
Author: Alain Schneble <a.s@realize.ch>
Date:   Sat Dec 26 00:50:25 2015 +0100

    Make relative URL parsing and resolution consistent with RFC 3986 (bug#22044)
    
    * test/lisp/url/url-parse-tests.el: Add tests covering url-generic-parse-url.
    * test/lisp/url/url-expand-tests.el: Add tests covering url-expand-file-name.
    * lisp/url/url-parse.el (url-generic-parse-url): Keep empty fragment
    information in URL-struct.
    * lisp/url/url-parse.el (url-path-and-query): Do not artificially turn empty
    path and query into nil path and query, respectively.
    * lisp/url/url-expand.el (url-expander-remove-relative-links): Do not turn
    empty path into an absolute ("/") path.
    * lisp/url/url-expand.el (url-expand-file-name): Properly resolve
    fragment-only URIs. Do not just return them unchanged.
    * lisp/url/url-expand.el (url-default-expander): An empty path in the relative
    reference URI should not drop the last segment.

diff --git a/lisp/url/url-expand.el b/lisp/url/url-expand.el
index c468a79..600a36d 100644
--- a/lisp/url/url-expand.el
+++ b/lisp/url/url-expand.el
@@ -26,32 +26,35 @@
 (require 'url-parse)
 
 (defun url-expander-remove-relative-links (name)
-  ;; Strip . and .. from pathnames
-  (let ((new (if (not (string-match "^/" name))
-		 (concat "/" name)
-	       name)))
-
-    ;; If it ends with a '/.' or '/..', tack on a trailing '/' sot hat
-    ;; the tests that follow are not too complicated in terms of
-    ;; looking for '..' or '../', etc.
-    (if (string-match "/\\.+$" new)
-	(setq new (concat new "/")))
-
-    ;; Remove '/./' first
-    (while (string-match "/\\(\\./\\)" new)
-      (setq new (concat (substring new 0 (match-beginning 1))
-			(substring new (match-end 1)))))
-
-    ;; Then remove '/../'
-    (while (string-match "/\\([^/]*/\\.\\./\\)" new)
-      (setq new (concat (substring new 0 (match-beginning 1))
-			(substring new (match-end 1)))))
-
-    ;; Remove cruft at the beginning of the string, so people that put
-    ;; in extraneous '..' because they are morons won't lose.
-    (while (string-match "^/\\.\\.\\(/\\)" new)
-      (setq new (substring new (match-beginning 1) nil)))
-    new))
+  (if (equal name "")
+      ;; An empty name is a properly valid relative URL reference/path.
+      ""
+    ;; Strip . and .. from pathnames
+    (let ((new (if (not (string-match "^/" name))
+                   (concat "/" name)
+                 name)))
+
+      ;; If it ends with a '/.' or '/..', tack on a trailing '/' sot hat
+      ;; the tests that follow are not too complicated in terms of
+      ;; looking for '..' or '../', etc.
+      (if (string-match "/\\.+$" new)
+          (setq new (concat new "/")))
+
+      ;; Remove '/./' first
+      (while (string-match "/\\(\\./\\)" new)
+        (setq new (concat (substring new 0 (match-beginning 1))
+                          (substring new (match-end 1)))))
+
+      ;; Then remove '/../'
+      (while (string-match "/\\([^/]*/\\.\\./\\)" new)
+        (setq new (concat (substring new 0 (match-beginning 1))
+                          (substring new (match-end 1)))))
+
+      ;; Remove cruft at the beginning of the string, so people that put
+      ;; in extraneous '..' because they are morons won't lose.
+      (while (string-match "^/\\.\\.\\(/\\)" new)
+        (setq new (substring new (match-beginning 1) nil)))
+      new)))
 
 (defun url-expand-file-name (url &optional default)
   "Convert URL to a fully specified URL, and canonicalize it.
@@ -89,8 +92,6 @@ path components followed by `..' are removed, along with the `..' itself."
   (cond
    ((= (length url) 0)			; nil or empty string
     (url-recreate-url default))
-   ((string-match "^#" url)		; Offset link, use it raw
-    url)
    ((string-match url-nonrelative-link url) ; Fully-qualified URL, return it immediately
     url)
    (t
@@ -120,29 +121,24 @@ path components followed by `..' are removed, along with the `..' itself."
 	(setf (url-host urlobj) (or (url-host urlobj) (url-host defobj))))
     (if (string= "ftp"  (url-type urlobj))
 	(setf (url-user urlobj) (or (url-user urlobj) (url-user defobj))))
-    (if (string= (url-filename urlobj) "")
-	(setf (url-filename urlobj) "/"))
     ;; If the object we're expanding from is full, then we are now
     ;; full.
     (unless (url-fullness urlobj)
       (setf (url-fullness urlobj) (url-fullness defobj)))
-    (if (string-match "^/" (url-filename urlobj))
-	nil
-      (let ((query nil)
-	    (file nil)
-	    (sepchar nil))
-	(if (string-match "[?#]" (url-filename urlobj))
-	    (setq query (substring (url-filename urlobj) (match-end 0))
-		  file (substring (url-filename urlobj) 0 (match-beginning 0))
-		  sepchar (substring (url-filename urlobj) (match-beginning 0) (match-end 0)))
-	  (setq file (url-filename urlobj)))
+    (let* ((pathandquery (url-path-and-query urlobj))
+           (defpathandquery (url-path-and-query defobj))
+           (file (car pathandquery))
+           (query (or (cdr pathandquery) (and (equal file "") (cdr defpathandquery)))))
+      (if (string-match "^/" (url-filename urlobj))
+          (setq file (url-expander-remove-relative-links file))
 	;; We use concat rather than expand-file-name to combine
 	;; directory and file name, since urls do not follow the same
 	;; rules as local files on all platforms.
-	(setq file (url-expander-remove-relative-links
-		    (concat (url-file-directory (url-filename defobj)) file)))
-	(setf (url-filename urlobj)
-              (if query (concat file sepchar query) file))))))
+        (setq file (url-expander-remove-relative-links
+                    (if (equal file "")
+                        (or (car (url-path-and-query defobj)) "")
+                      (concat (url-file-directory (url-filename defobj)) file)))))
+      (setf (url-filename urlobj) (if query (concat file "?" query) file)))))
 
 (provide 'url-expand)
 
diff --git a/lisp/url/url-parse.el b/lisp/url/url-parse.el
index dbf0c38..c3159a7 100644
--- a/lisp/url/url-parse.el
+++ b/lisp/url/url-parse.el
@@ -59,8 +59,6 @@ where each of PATH and QUERY are strings or nil."
 	  (setq path  (substring name 0 (match-beginning 0))
 		query (substring name (match-end 0)))
 	(setq path name)))
-    (if (equal path "") (setq path nil))
-    (if (equal query "") (setq query nil))
     (cons path query)))
 
 (defun url-port-if-non-default (urlobj)
@@ -217,8 +215,7 @@ parses to
 	    (when (looking-at "#")
 	      (let ((opoint (point)))
 		(forward-char 1)
-		(unless (eobp)
-		  (setq fragment (buffer-substring (point) (point-max))))
+                (setq fragment (buffer-substring (point) (point-max)))
 		(delete-region opoint (point-max)))))
 
           (if (and host (string-match "%[0-9][0-9]" host))
diff --git a/test/lisp/url/url-expand-tests.el b/test/lisp/url/url-expand-tests.el
new file mode 100644
index 0000000..2bd2868
--- /dev/null
+++ b/test/lisp/url/url-expand-tests.el
@@ -0,0 +1,105 @@
+;;; url-expand-tests.el --- Test suite for relative URI/URL resolution.
+
+;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
+
+;; Author: Alain Schneble <a.s@realize.ch>
+;; Version: 1.0
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Test cases covering URI reference resolution as described in RFC3986,
+;; section 5. Reference Resolution and especially the relative resolution
+;; rules specified in section 5.2. Relative Resolution.
+
+;; Each test calls `url-expand-file-name', typically with a relative
+;; reference URI and a base URI as string and compares the result (Actual)
+;; against a manually specified URI (Expected)
+
+;;; Code:
+
+(require 'url-expand)
+(require 'ert)
+
+(ert-deftest url-expand-file-name/relative-resolution-normal-examples ()
+  "RFC 3986, Section 5.4 Reference Resolution Examples / Section 5.4.1. Normal Examples"
+  (should (equal (url-expand-file-name "g:h"     "http://a/b/c/d;p?q") "g:h"))
+  (should (equal (url-expand-file-name "g"       "http://a/b/c/d;p?q") "http://a/b/c/g"))
+  (should (equal (url-expand-file-name "./g"     "http://a/b/c/d;p?q") "http://a/b/c/g"))
+  (should (equal (url-expand-file-name "g/"      "http://a/b/c/d;p?q") "http://a/b/c/g/"))
+  (should (equal (url-expand-file-name "/g"      "http://a/b/c/d;p?q") "http://a/g"))
+  (should (equal (url-expand-file-name "//g"     "http://a/b/c/d;p?q") "http://g"))
+  (should (equal (url-expand-file-name "?y"      "http://a/b/c/d;p?q") "http://a/b/c/d;p?y"))
+  (should (equal (url-expand-file-name "g?y"     "http://a/b/c/d;p?q") "http://a/b/c/g?y"))
+  (should (equal (url-expand-file-name "#s"      "http://a/b/c/d;p?q") "http://a/b/c/d;p?q#s"))
+  (should (equal (url-expand-file-name "g#s"     "http://a/b/c/d;p?q") "http://a/b/c/g#s"))
+  (should (equal (url-expand-file-name "g?y#s"   "http://a/b/c/d;p?q") "http://a/b/c/g?y#s"))
+  (should (equal (url-expand-file-name ";x"      "http://a/b/c/d;p?q") "http://a/b/c/;x"))
+  (should (equal (url-expand-file-name "g;x"     "http://a/b/c/d;p?q") "http://a/b/c/g;x"))
+  (should (equal (url-expand-file-name "g;x?y#s" "http://a/b/c/d;p?q") "http://a/b/c/g;x?y#s"))
+  (should (equal (url-expand-file-name ""        "http://a/b/c/d;p?q") "http://a/b/c/d;p?q"))
+  (should (equal (url-expand-file-name "."       "http://a/b/c/d;p?q") "http://a/b/c/"))
+  (should (equal (url-expand-file-name "./"      "http://a/b/c/d;p?q") "http://a/b/c/"))
+  (should (equal (url-expand-file-name ".."      "http://a/b/c/d;p?q") "http://a/b/"))
+  (should (equal (url-expand-file-name "../"     "http://a/b/c/d;p?q") "http://a/b/"))
+  (should (equal (url-expand-file-name "../g"    "http://a/b/c/d;p?q") "http://a/b/g"))
+  (should (equal (url-expand-file-name "../.."   "http://a/b/c/d;p?q") "http://a/"))
+  (should (equal (url-expand-file-name "../../"  "http://a/b/c/d;p?q") "http://a/"))
+  (should (equal (url-expand-file-name "../../g" "http://a/b/c/d;p?q") "http://a/g")))
+
+(ert-deftest url-expand-file-name/relative-resolution-absolute-examples ()
+  "RFC 3986, Section 5.4 Reference Resolution Examples / Section 5.4.2. Abnormal Examples"
+  (should (equal (url-expand-file-name "../../../g"    "http://a/b/c/d;p?q") "http://a/g"))
+  (should (equal (url-expand-file-name "../../../../g" "http://a/b/c/d;p?q") "http://a/g"))
+
+  (should (equal (url-expand-file-name "/./g"          "http://a/b/c/d;p?q") "http://a/g"))
+  (should (equal (url-expand-file-name "/../g"         "http://a/b/c/d;p?q") "http://a/g"))
+  (should (equal (url-expand-file-name "g."            "http://a/b/c/d;p?q") "http://a/b/c/g."))
+  (should (equal (url-expand-file-name ".g"            "http://a/b/c/d;p?q") "http://a/b/c/.g"))
+  (should (equal (url-expand-file-name "g.."           "http://a/b/c/d;p?q") "http://a/b/c/g.."))
+  (should (equal (url-expand-file-name "..g"           "http://a/b/c/d;p?q") "http://a/b/c/..g"))
+
+  (should (equal (url-expand-file-name "./../g"        "http://a/b/c/d;p?q") "http://a/b/g"))
+  (should (equal (url-expand-file-name "./g/."         "http://a/b/c/d;p?q") "http://a/b/c/g/"))
+  (should (equal (url-expand-file-name "g/./h"         "http://a/b/c/d;p?q") "http://a/b/c/g/h"))
+  (should (equal (url-expand-file-name "g/../h"        "http://a/b/c/d;p?q") "http://a/b/c/h"))
+  (should (equal (url-expand-file-name "g;x=1/./y"     "http://a/b/c/d;p?q") "http://a/b/c/g;x=1/y"))
+  (should (equal (url-expand-file-name "g;x=1/../y"    "http://a/b/c/d;p?q") "http://a/b/c/y"))
+
+  (should (equal (url-expand-file-name "g?y/./x"       "http://a/b/c/d;p?q") "http://a/b/c/g?y/./x"))
+  (should (equal (url-expand-file-name "g?y/../x"      "http://a/b/c/d;p?q") "http://a/b/c/g?y/../x"))
+  (should (equal (url-expand-file-name "g#s/./x"       "http://a/b/c/d;p?q") "http://a/b/c/g#s/./x"))
+  (should (equal (url-expand-file-name "g#s/../x"      "http://a/b/c/d;p?q") "http://a/b/c/g#s/../x"))
+
+  (should (equal (url-expand-file-name "http:g"        "http://a/b/c/d;p?q") "http:g")) ; for strict parsers
+  )
+
+(ert-deftest url-expand-file-name/relative-resolution-additional-examples ()
+  "Reference Resolution Examples / Arbitrary Examples"
+  (should (equal (url-expand-file-name "" "http://host/foobar") "http://host/foobar"))
+  (should (equal (url-expand-file-name "?y"      "http://a/b/c/d") "http://a/b/c/d?y"))
+  (should (equal (url-expand-file-name "?y"      "http://a/b/c/d/") "http://a/b/c/d/?y"))
+  (should (equal (url-expand-file-name "?y#fragment"      "http://a/b/c/d;p?q") "http://a/b/c/d;p?y#fragment"))
+  (should (equal (url-expand-file-name "#bar" "http://host") "http://host#bar"))
+  (should (equal (url-expand-file-name "#bar" "http://host/") "http://host/#bar"))
+  (should (equal (url-expand-file-name "#bar" "http://host/foo") "http://host/foo#bar"))
+  (should (equal (url-expand-file-name "foo#bar" "http://host/foobar") "http://host/foo#bar"))
+  (should (equal (url-expand-file-name "foo#bar" "http://host/foobar/") "http://host/foobar/foo#bar")))
+
+(provide 'url-expand-tests)
+
+;;; url-expand-tests.el ends here

commit 1dee11d874de5ff3d5634e1629054c4398b27b72
Author: Alain Schneble <a.s@realize.ch>
Date:   Sat Dec 26 00:50:13 2015 +0100

    Make relative URL parsing and resolution consistent with RFC 3986 (bug#22044)
    
    * test/lisp/url/url-parse-tests.el: Add tests covering url-generic-parse-url.
    * test/lisp/url/url-expand-tests.el: Add tests covering url-expand-file-name.
    * lisp/url/url-parse.el (url-generic-parse-url): Keep empty fragment
    information in URL-struct.
    * lisp/url/url-parse.el (url-path-and-query): Do not artificially turn empty
    path and query into nil path and query, respectively.
    * lisp/url/url-expand.el (url-expander-remove-relative-links): Do not turn
    empty path into an absolute ("/") path.
    * lisp/url/url-expand.el (url-expand-file-name): Properly resolve
    fragment-only URIs. Do not just return them unchanged.
    * lisp/url/url-expand.el (url-default-expander): An empty path in the relative
    reference URI should not drop the last segment.

diff --git a/test/lisp/url/url-parse-tests.el b/test/lisp/url/url-parse-tests.el
new file mode 100644
index 0000000..154e091
--- /dev/null
+++ b/test/lisp/url/url-parse-tests.el
@@ -0,0 +1,167 @@
+;;; url-parse-tests.el --- Test suite for URI/URL parsing.
+
+;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
+
+;; Author: Alain Schneble <a.s@realize.ch>
+;; Version: 1.0
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Test cases covering generic URI syntax as described in RFC3986,
+;; section 3. Syntax Components and 4. Usage. See also appendix
+;; A. Collected ABNF for URI, as the example given here are all
+;; productions of this grammar.
+
+;; Each tests parses a given URI string - whether relative or absolute -
+;; using `url-generic-parse-url' and compares the constructed
+;; URL-struct (Actual) against a manually `url-parse-make-urlobj'-
+;; constructed URL-struct (Expected).
+
+;;; Code:
+
+(require 'url-parse)
+(require 'ert)
+
+(ert-deftest url-generic-parse-url/generic-uri-examples ()
+  "RFC 3986, section 1.1.2. Examples / Example illustrating several URI schemes and variations in their common syntax components"
+  (should (equal (url-generic-parse-url "ftp://ftp.is.co.za/rfc/rfc1808.txt") (url-parse-make-urlobj "ftp" nil nil "ftp.is.co.za" nil "/rfc/rfc1808.txt" nil nil t)))
+  (should (equal (url-generic-parse-url "http://www.ietf.org/rfc/rfc2396.txt") (url-parse-make-urlobj "http" nil nil "www.ietf.org" nil "/rfc/rfc2396.txt" nil nil t)))
+  (should (equal (url-generic-parse-url "ldap://[2001:db8::7]/c=GB?objectClass?one") (url-parse-make-urlobj "ldap" nil nil "[2001:db8::7]" nil "/c=GB?objectClass?one" nil nil t)))
+  (should (equal (url-generic-parse-url "mailto:John.Doe@example.com") (url-parse-make-urlobj "mailto" nil nil nil nil "John.Doe@example.com" nil nil nil)))
+  (should (equal (url-generic-parse-url "news:comp.infosystems.www.servers.unix") (url-parse-make-urlobj "news" nil nil nil nil "comp.infosystems.www.servers.unix" nil nil nil)))
+  (should (equal (url-generic-parse-url "tel:+1-816-555-1212") (url-parse-make-urlobj "tel" nil nil nil nil "+1-816-555-1212" nil nil nil)))
+  (should (equal (url-generic-parse-url "telnet://192.0.2.16:80/") (url-parse-make-urlobj "telnet" nil nil "192.0.2.16" 80 "/" nil nil t)))
+  (should (equal (url-generic-parse-url "urn:oasis:names:specification:docbook:dtd:xml:4.1.2") (url-parse-make-urlobj "urn" nil nil nil nil "oasis:names:specification:docbook:dtd:xml:4.1.2" nil nil nil))))
+
+(ert-deftest url-generic-parse-url/generic-uri ()
+  "RFC 3986, section 3. Syntax Components / generic URI syntax"
+  ;; empty path
+  (should (equal (url-generic-parse-url "http://host#") (url-parse-make-urlobj "http" nil nil "host" nil "" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host?#") (url-parse-make-urlobj "http" nil nil "host" nil "?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host?query#") (url-parse-make-urlobj "http" nil nil "host" nil "?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "?query" "fragment" nil t)))
+  ;; absolute path /
+  (should (equal (url-generic-parse-url "http://host/#") (url-parse-make-urlobj "http" nil nil "host" nil "/" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/?#") (url-parse-make-urlobj "http" nil nil "host" nil "/?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/?query#") (url-parse-make-urlobj "http" nil nil "host" nil "/?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/?query" "fragment" nil t)))
+  ;; absolute path /foo
+  (should (equal (url-generic-parse-url "http://host/foo#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?query#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?query" "fragment" nil t)))
+  ;; absolute path /foo/
+  (should (equal (url-generic-parse-url "http://host/foo/#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?query#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?query" "fragment" nil t)))
+  ;; absolute path /foo/bar
+  (should (equal (url-generic-parse-url "http://host/foo/bar#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?query#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?query" "fragment" nil t)))
+  ;; absolute path /foo/bar/
+  (should (equal (url-generic-parse-url "http://host/foo/bar/#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?query#") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?query" "" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?" "fragment" nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?query#fragment") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?query" "fragment" nil t)))
+  ;; for more examples of URIs without fragments, see tests covering section 4.3. Absolute URI
+  )
+
+(ert-deftest url-generic-parse-url/network-path-reference ()
+  "RFC 3986, section 4.2. Relative Reference / network-path reference: a relative reference that begins with two slash characters"
+  (should (equal (url-generic-parse-url "//host") (url-parse-make-urlobj nil nil nil "host" nil "" nil nil t)))
+  (should (equal (url-generic-parse-url "//host/") (url-parse-make-urlobj nil nil nil "host" nil "/" nil nil t)))
+  (should (equal (url-generic-parse-url "//host/foo") (url-parse-make-urlobj nil nil nil "host" nil "/foo" nil nil t)))
+  (should (equal (url-generic-parse-url "//host/foo/bar") (url-parse-make-urlobj nil nil nil "host" nil "/foo/bar" nil nil t)))
+  (should (equal (url-generic-parse-url "//host/foo/bar/") (url-parse-make-urlobj nil nil nil "host" nil "/foo/bar/" nil nil t))))
+
+(ert-deftest url-generic-parse-url/absolute-path-reference ()
+  "RFC 3986, section 4.2. Relative Reference / absolute-path reference: a relative reference that begins with a single slash character"
+  (should (equal (url-generic-parse-url "/") (url-parse-make-urlobj nil nil nil nil nil "/" nil nil nil)))
+  (should (equal (url-generic-parse-url "/foo") (url-parse-make-urlobj nil nil nil nil nil "/foo" nil nil nil)))
+  (should (equal (url-generic-parse-url "/foo/bar") (url-parse-make-urlobj nil nil nil nil nil "/foo/bar" nil nil nil)))
+  (should (equal (url-generic-parse-url "/foo/bar/") (url-parse-make-urlobj nil nil nil nil nil "/foo/bar/" nil nil nil)))
+  (should (equal (url-generic-parse-url "/foo/bar#") (url-parse-make-urlobj nil nil nil nil nil "/foo/bar" "" nil nil)))
+  (should (equal (url-generic-parse-url "/foo/bar/#") (url-parse-make-urlobj nil nil nil nil nil "/foo/bar/" "" nil nil))))
+
+(ert-deftest url-generic-parse-url/relative-path-reference ()
+  "RFC 3986, section 4.2. Relative Reference / relative-path reference: a relative reference that does not begin with a slash character"
+  (should (equal (url-generic-parse-url "foo") (url-parse-make-urlobj nil nil nil nil nil "foo" nil nil nil)))
+  (should (equal (url-generic-parse-url "foo/bar") (url-parse-make-urlobj nil nil nil nil nil "foo/bar" nil nil nil)))
+  (should (equal (url-generic-parse-url "foo/bar/") (url-parse-make-urlobj nil nil nil nil nil "foo/bar/" nil nil nil)))
+  (should (equal (url-generic-parse-url "./foo") (url-parse-make-urlobj nil nil nil nil nil "./foo" nil nil nil)))
+  (should (equal (url-generic-parse-url "./foo/bar") (url-parse-make-urlobj nil nil nil nil nil "./foo/bar" nil nil nil)))
+  (should (equal (url-generic-parse-url "./foo/bar/") (url-parse-make-urlobj nil nil nil nil nil "./foo/bar/" nil nil nil)))
+  (should (equal (url-generic-parse-url "../foo") (url-parse-make-urlobj nil nil nil nil nil "../foo" nil nil nil)))
+  (should (equal (url-generic-parse-url "../foo/bar") (url-parse-make-urlobj nil nil nil nil nil "../foo/bar" nil nil nil)))
+  (should (equal (url-generic-parse-url "../foo/bar/") (url-parse-make-urlobj nil nil nil nil nil "../foo/bar/" nil nil nil)))
+  (should (equal (url-generic-parse-url "./this:that") (url-parse-make-urlobj nil nil nil nil nil "./this:that" nil nil nil)))
+  ;; for more examples of relative-path references, see tests covering section 4.4. Same-Document Reference
+  )
+
+(ert-deftest url-generic-parse-url/absolute-uri ()
+  "RFC 3986, section 4.3. Absolute URI / absolute URI: absolute form of a URI without a fragment identifier"
+  ;; empty path
+  (should (equal (url-generic-parse-url "http://host") (url-parse-make-urlobj "http" nil nil "host" nil "" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host?") (url-parse-make-urlobj "http" nil nil "host" nil "?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host?query") (url-parse-make-urlobj "http" nil nil "host" nil "?query" nil nil t)))
+  ;; absolute path /
+  (should (equal (url-generic-parse-url "http://host/") (url-parse-make-urlobj "http" nil nil "host" nil "/" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/?") (url-parse-make-urlobj "http" nil nil "host" nil "/?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/?query") (url-parse-make-urlobj "http" nil nil "host" nil "/?query" nil nil t)))
+  ;; absolute path /foo
+  (should (equal (url-generic-parse-url "http://host/foo") (url-parse-make-urlobj "http" nil nil "host" nil "/foo" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo?query") (url-parse-make-urlobj "http" nil nil "host" nil "/foo?query" nil nil t)))
+  ;; absolute path /foo/
+  (should (equal (url-generic-parse-url "http://host/foo/") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/?query") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/?query" nil nil t)))
+  ;; absolute path /foo/bar
+  (should (equal (url-generic-parse-url "http://host/foo/bar") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar?query") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar?query" nil nil t)))
+  ;; absolute path /foo/bar/
+  (should (equal (url-generic-parse-url "http://host/foo/bar/") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?" nil nil t)))
+  (should (equal (url-generic-parse-url "http://host/foo/bar/?query") (url-parse-make-urlobj "http" nil nil "host" nil "/foo/bar/?query" nil nil t)))
+  ;; example mentioned in RFC3986, section 5.4. Reference Resolution Examples
+  (should (equal (url-generic-parse-url "http://a/b/c/d;p?q") (url-parse-make-urlobj "http" nil nil "a" nil "/b/c/d;p?q" nil nil t))))
+
+(ert-deftest url-generic-parse-url/same-decument-reference ()
+  "RFC 3986, section 4.4. Same-Document Reference / same-document reference: empty or number sign (\"#\") followed by a fragment identifier"
+  (should (equal (url-generic-parse-url "") (url-parse-make-urlobj nil nil nil nil nil "" nil nil nil)))
+  (should (equal (url-generic-parse-url "#") (url-parse-make-urlobj nil nil nil nil nil "" "" nil nil)))
+  (should (equal (url-generic-parse-url "#foo") (url-parse-make-urlobj nil nil nil nil nil "" "foo" nil nil))))
+
+(provide 'url-parse-tests)
+
+;;; url-parse-tests.el ends here

commit 0697719d7368f232f7c0ba5003387c28908bbfdb
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 22:36:32 2015 +0100

    Let url use default file modes when copying files
    
    * lisp/url/url-handlers.el (url-copy-file): Use default file
    modes when copying files (bug#11400).

diff --git a/lisp/url/url-handlers.el b/lisp/url/url-handlers.el
index d13df69..6d2a5c2 100644
--- a/lisp/url/url-handlers.el
+++ b/lisp/url/url-handlers.el
@@ -269,7 +269,8 @@ A prefix arg makes KEEP-TIME non-nil."
 	(error "Opening input file: No such file or directory, %s" url))
     (with-current-buffer buffer
       (setq handle (mm-dissect-buffer t)))
-    (mm-save-part-to-file handle newname)
+    (let ((mm-attachment-file-modes (default-file-modes)))
+      (mm-save-part-to-file handle newname))
     (kill-buffer buffer)
     (mm-destroy-parts handle)))
 (put 'copy-file 'url-file-handlers 'url-copy-file)

commit 344303c8d9cb03d4778a73940e80e966280aa694
Author: Devon Sean McCullough <Emacs-Hacker2012@jovi.net>
Date:   Fri Dec 25 22:21:22 2015 +0100

    Doc fix for url-http
    
    * lisp/url/url-http.el (url-http): Document better return values
      (bug#13187) (tiny change)

diff --git a/lisp/url/url-http.el b/lisp/url/url-http.el
index 7367a1e..916f263 100644
--- a/lisp/url/url-http.el
+++ b/lisp/url/url-http.el
@@ -1206,17 +1206,20 @@ the end of the document."
   "Retrieve URL via HTTP asynchronously.
 URL must be a parsed URL.  See `url-generic-parse-url' for details.
 
-When retrieval is completed, execute the function CALLBACK, passing it
-an updated value of CBARGS as arguments.  The first element in CBARGS
-should be a plist describing what has happened so far during the
-request, as described in the docstring of `url-retrieve' (if in
-doubt, specify nil).
+When retrieval is completed, execute the function CALLBACK,
+passing it an updated value of CBARGS as arguments.  The first
+element in CBARGS should be a plist describing what has happened
+so far during the request, as described in the docstring of
+`url-retrieve' (if in doubt, specify nil).  The current buffer
+then CALLBACK is executed is the retrieval buffer.
 
 Optional arg RETRY-BUFFER, if non-nil, specifies the buffer of a
 previous `url-http' call, which is being re-attempted.
 
 Optional arg GATEWAY-METHOD specifies the gateway to be used,
-overriding the value of `url-gateway-method'."
+overriding the value of `url-gateway-method'.
+
+The return value of this function is the retrieval buffer."
   (cl-check-type url vector "Need a pre-parsed URL.")
   (let* ((host (url-host (or url-using-proxy url)))
 	 (port (url-port (or url-using-proxy url)))

commit 608b15d59d08ff7054fdc5458d1d2ae54dd043e2
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 21:44:57 2015 +0100

    * eww.el (eww-display-html): Support <button> tags (bug#20485).

diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index d7f3f3f..babfdef 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -412,6 +412,7 @@ Currently this means either text/html or application/xhtml+xml."
               '((title . eww-tag-title)
                 (form . eww-tag-form)
                 (input . eww-tag-input)
+                (button . eww-form-submit)
                 (textarea . eww-tag-textarea)
                 (select . eww-tag-select)
                 (link . eww-tag-link)

commit a68633e774886ab7da16772a7eef10f0471a6b77
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 20:43:36 2015 +0100

    Made ffap-url-p a defun instead of a defsubst
    
    * lisp/ffap.el (ffap-url-p): Change from defsusbt to defun,
    since there doesn't seem to be much of a reason for it to be a
    defsubst (bug#18203).

diff --git a/lisp/ffap.el b/lisp/ffap.el
index 8d3f8bf..037b978 100644
--- a/lisp/ffap.el
+++ b/lisp/ffap.el
@@ -570,7 +570,7 @@ Looks at `ffap-ftp-default-user', returns \"\" for \"localhost\"."
 (defvaralias 'ffap-newsgroup-heads  'thing-at-point-newsgroup-heads)
 (defalias 'ffap-newsgroup-p 'thing-at-point-newsgroup-p)
 
-(defsubst ffap-url-p (string)
+(defun ffap-url-p (string)
   "If STRING looks like an URL, return it (maybe improved), else nil."
   (when (and (stringp string) ffap-url-regexp)
     (let* ((case-fold-search t)

commit 65c64058b817f169e356ea7825d173eb4c27fcf6
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 20:36:54 2015 +0100

    Add a command to view files in the browser to dired
    
    * lisp/dired.el (dired-mode-map): Add the `W' command
    (bug#18810).

diff --git a/doc/emacs/dired.texi b/doc/emacs/dired.texi
index e7e4944..04cef38 100644
--- a/doc/emacs/dired.texi
+++ b/doc/emacs/dired.texi
@@ -1414,6 +1414,13 @@ names into arguments for other Emacs commands.  It also displays what
 it added to the kill ring, so you can use it to display the list of
 currently marked files in the echo area.
 
+@kindex W @r{(Dired)}
+@findex browse-url-of-dired-file
+  If you have an HTML file in the file listing, it can be useful to
+view that file with a browser.  The @kbd{W}
+(@code{browse-url-of-dired-file}) command will use the standard
+configured browser to view that file.
+
 @kindex ( @r{(Dired)}
 @findex dired-hide-details-mode
 @vindex dired-hide-details-hide-symlink-targets
diff --git a/etc/NEWS b/etc/NEWS
index 76fac3e..edd8147 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -900,6 +900,10 @@ compress many marked files into a single named archive.  The
 compression command is determined from the new
 `dired-compress-files-alist' variable.
 
++++
+*** `W' is now bound to `browse-url-of-dired-file', and is useful for
+viewing HTML files and the like.
+
 ** Obsolete packages
 
 ---
diff --git a/lisp/dired.el b/lisp/dired.el
index ab6a820..0a1b064 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -1538,6 +1538,7 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "u" 'dired-unmark)
     (define-key map "v" 'dired-view-file)
     (define-key map "w" 'dired-copy-filename-as-kill)
+    (define-key map "W" 'browse-url-of-dired-file)
     (define-key map "x" 'dired-do-flagged-delete)
     (define-key map "y" 'dired-show-file-type)
     (define-key map "+" 'dired-create-directory)

commit b563715a2db265517d5a77f165a42afa1e233fdd
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 20:21:46 2015 +0100

    Allow http://user:pass@foo/ URLs again
    
    * lisp/url/url-auth.el (url-basic-auth): Allow explicit
    user/passwords in URLs (bug#19046).

diff --git a/lisp/url/url-auth.el b/lisp/url/url-auth.el
index 87f6718..b419db5 100644
--- a/lisp/url/url-auth.el
+++ b/lisp/url/url-auth.el
@@ -80,6 +80,9 @@ instead of the filename inheritance method."
 	  byserv (cdr-safe (assoc server
 				  (symbol-value url-basic-auth-storage))))
     (cond
+     ((and user pass)
+      ;; Explicit http://user:pass@foo/ URL.  Just return the credentials.
+      (setq retval (base64-encode-string (format "%s:%s" user pass))))
      ((and prompt (not byserv))
       (setq user (or
 		  (url-do-auth-source-search server type :user)

commit 596338b3b9b946c6948fd57369fdced9ea50afa3
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 19:08:03 2015 +0100

    * eww.el (eww-mode-map): Fix command name of eww-toggle-colors.

diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index 0bd6036..d7f3f3f 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -681,7 +681,7 @@ the like."
     (define-key map "E" 'eww-set-character-encoding)
     (define-key map "S" 'eww-list-buffers)
     (define-key map "F" 'eww-toggle-fonts)
-    (define-key map [(meta C)] 'eww-toggle-fonts)
+    (define-key map [(meta C)] 'eww-toggle-colors)
 
     (define-key map "b" 'eww-add-bookmark)
     (define-key map "B" 'eww-list-bookmarks)

commit 7a7b5b492ff9929eecd90c4564db6fbf3b192323
Author: Samer Masterson <samer@samertm.com>
Date:   Fri Dec 25 19:04:55 2015 +0100

    Autoload url-insert-buffer-contents
    
    * lisp/url/url-handlers.el: Add autoload cookie so that
    `package-list-packages' doesn't bug out (bug#21927) (tiny change)

diff --git a/lisp/url/url-handlers.el b/lisp/url/url-handlers.el
index bafe3e5..d13df69 100644
--- a/lisp/url/url-handlers.el
+++ b/lisp/url/url-handlers.el
@@ -309,6 +309,7 @@ They count bytes from the beginning of the body."
 
 (defvar url-http-codes)
 
+;;;###autoload
 (defun url-insert-buffer-contents (buffer url &optional visit beg end replace)
   "Insert the contents of BUFFER into current buffer.
 This is like `url-insert', but also decodes the current buffer as

commit 6d124eef1c940b251277b3eed6dd55eb7565d97e
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 18:50:43 2015 +0100

    Allow toggling colors in eww
    
    * doc/misc/eww.texi (Basics): Mention "C".
    
    * lisp/net/eww.el (eww-toggle-colors): New command and keystroke.
    
    * lisp/net/shr.el (shr-use-colors): New variable.
    (shr-colorize-region): Use it.

diff --git a/doc/misc/eww.texi b/doc/misc/eww.texi
index f1347b7..15cc867 100644
--- a/doc/misc/eww.texi
+++ b/doc/misc/eww.texi
@@ -109,6 +109,12 @@ only display this part.  This usually gets rid of menus and the like.
   The @kbd{F} command (@code{eww-toggle-fonts}) toggles whether to use
 variable-pitch fonts or not.  This sets the @code{shr-use-fonts} variable.
 
+@findex eww-toggle-colors
+@findex shr-use-colors
+@kindex F
+  The @kbd{C} command (@code{eww-toggle-colors}) toggles whether to use
+HTML-specified colors or not.  This sets the @code{shr-use-colors} variable.
+
 @findex eww-download
 @vindex eww-download-directory
 @kindex d
diff --git a/etc/NEWS b/etc/NEWS
index 1ef496c..76fac3e 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -524,6 +524,11 @@ whether to use variable-pitch fonts or not.  The user can also
 customize the `shr-use-fonts' variable.
 
 +++
+*** A new command `C' (`eww-toggle-colors) can be used to toggle
+whether to use the HTML-specified colors or not.  The user can also
+customize the `shr-use-colors variable.
+
++++
 *** A new command `R' (`eww-readable') will try do identify the main
 textual parts of a web page and display only that, leaving menus and
 the like off the page.
diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index 742e1e4..0bd6036 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -681,6 +681,7 @@ the like."
     (define-key map "E" 'eww-set-character-encoding)
     (define-key map "S" 'eww-list-buffers)
     (define-key map "F" 'eww-toggle-fonts)
+    (define-key map [(meta C)] 'eww-toggle-fonts)
 
     (define-key map "b" 'eww-add-bookmark)
     (define-key map "B" 'eww-list-bookmarks)
@@ -705,6 +706,8 @@ the like."
 	["Add bookmark" eww-add-bookmark t]
 	["List bookmarks" eww-list-bookmarks t]
 	["List cookies" url-cookie-list t]
+	["Toggle fonts" eww-toggle-fonts t]
+	["Toggle colors" eww-toggle-colors t]
        ["Character Encoding" eww-set-character-encoding]))
     map))
 
@@ -1495,6 +1498,15 @@ If CHARSET is nil then use UTF-8."
 	     "off"))
   (eww-reload))
 
+(defun eww-toggle-colors ()
+  "Toggle whether to use HTML-specified colors or not."
+  (interactive)
+  (message "Colors are now %s"
+	   (if (setq shr-use-colors (not shr-use-colors))
+	       "on"
+	     "off"))
+  (eww-reload))
+
 ;;; Bookmarks code
 
 (defvar eww-bookmarks nil)
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index a7fdf9e..3d5f02c 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -63,6 +63,12 @@ fit these criteria."
   :group 'shr
   :type 'boolean)
 
+(defcustom shr-use-colors t
+  "If non-nil, respect color specifications in the HTML."
+  :version "25.2"
+  :group 'shr
+  :type 'boolean)
+
 (defcustom shr-table-horizontal-line nil
   "Character used to draw horizontal table lines.
 If nil, don't draw horizontal table lines."
@@ -1082,7 +1088,9 @@ ones, in case fg and bg are nil."
                (shr-color-visible bg fg)))))))
 
 (defun shr-colorize-region (start end fg &optional bg)
-  (when (and (or fg bg) (>= (display-color-cells) 88))
+  (when (and shr-use-colors
+             (or fg bg)
+             (>= (display-color-cells) 88))
     (let ((new-colors (shr-color-check fg bg)))
       (when new-colors
 	(when fg

commit bdaff9c813973c31dfe1cd357b0f5099ccd0b883
Author: Lars Ingebrigtsen <larsi@gnus.org>
Date:   Fri Dec 25 18:18:42 2015 +0100

    Follow meta refresh tags in eww
    
    * eww.el (eww-tag-meta): Follow meta refresh tags (bug#22234).

diff --git a/lisp/net/eww.el b/lisp/net/eww.el
index 593ed22..742e1e4 100644
--- a/lisp/net/eww.el
+++ b/lisp/net/eww.el
@@ -415,6 +415,7 @@ Currently this means either text/html or application/xhtml+xml."
                 (textarea . eww-tag-textarea)
                 (select . eww-tag-select)
                 (link . eww-tag-link)
+                (meta . eww-tag-meta)
                 (a . eww-tag-a)))))
 	(erase-buffer)
 	(shr-insert-document document)
@@ -460,6 +461,27 @@ Currently this means either text/html or application/xhtml+xml."
 	 where
 	 (plist-put eww-data (cdr where) href))))
 
+(defvar eww-redirect-level 1)
+
+(defun eww-tag-meta (dom)
+  (when (and (cl-equalp (dom-attr dom 'http-equiv) "refresh")
+             (< eww-redirect-level 5))
+    (when-let (refresh (dom-attr dom 'content))
+      (when (or (string-match "^\\([0-9]+\\) *;.*url=\"\\([^\"]+\\)\"" refresh)
+                (string-match "^\\([0-9]+\\) *;.*url=\\([^ ]+\\)" refresh))
+        (let ((timeout (match-string 1 refresh))
+              (url (match-string 2 refresh))
+              (eww-redirect-level (1+ eww-redirect-level)))
+          (if (equal timeout "0")
+              (eww (shr-expand-url url))
+            (eww-tag-a
+             (dom-node 'a `((href . ,(shr-expand-url url)))
+                       (format "Auto refresh in %s second%s disabled"
+                               timeout
+                               (if (equal timeout "1")
+                                   ""
+                                 "s"))))))))))
+
 (defun eww-tag-link (dom)
   (eww-handle-link dom)
   (shr-generic dom))