diff --git a/spec/chapters/changes.tex b/spec/chapters/changes.tex
index 7f7fb99..e549206 100644
--- a/spec/chapters/changes.tex
+++ b/spec/chapters/changes.tex
@@ -7,6 +7,7 @@
 \item Section \ref{javaee}: requirements for Java EE 6 containers.
 \item Section \ref{standard_entity_providers}: requirements on standard entity providers when presented with an empty request entity.
 \item Section \ref{message_body_writer}: add closeness of generic type as secondary sort key.
+\item Section \ref{message_body_reader}: default to application/octet-stream if a request does not contain a content-type header.
 \end{itemize}
 
 \section{Changes Since Proposed Final Draft}
diff --git a/spec/chapters/providers.tex b/spec/chapters/providers.tex
index c459aee..7e3a5b5 100644
--- a/spec/chapters/providers.tex
+++ b/spec/chapters/providers.tex
@@ -29,6 +29,7 @@
 The following describes the logical\footnote{Implementations are free to optimize their processing provided the results are equivalent to those that would be obtained if these steps are followed.} steps taken by a \jaxrs\ implementation when mapping a request entity body to a Java method parameter:
 
 \begin{enumerate}
+\item Obtain the media type of the request. If the request does not contain a \code{Content-Type} header then use \code{application/octet-stream}.
 \item Identify the Java type of the parameter whose value will be mapped from the entity body. Section \ref{mapping_requests_to_java_methods} describes how the Java method is chosen.
 \item Select the set of \MsgRead\ classes that support the media type of the request, see section \ref{declaring_provider_capabilities}.
 \item\label{findreader} Iterate through the selected \MsgRead\ classes and, utilizing the \code{isReadable} method of each, choose a \MsgRead\ provider that supports the desired Java type.
diff --git a/src/jsr311-api/src/javax/ws/rs/ext/MessageBodyReader.java b/src/jsr311-api/src/javax/ws/rs/ext/MessageBodyReader.java
index cca0961..e5e1da9 100644
--- a/src/jsr311-api/src/javax/ws/rs/ext/MessageBodyReader.java
+++ b/src/jsr311-api/src/javax/ws/rs/ext/MessageBodyReader.java
@@ -54,7 +54,9 @@
      * message body is to be converted into a method parameter, this will be
      * the annotations on that parameter returned by 
      * <code>Class.getParameterAnnotations</code>.
-     * @param mediaType the media type of the HTTP entity.
+     * @param mediaType the media type of the HTTP entity, if one is not
+     * specified in the request then <code>application/octet-stream</code> is
+     * used.
      * @return true if the type is supported, otherwise false.
      */
     boolean isReadable(Class<?> type, Type genericType, 
