diff --git a/django/http/__init__.py b/django/http/__init__.py
index 49acd57..d609eb5 100644
--- a/django/http/__init__.py
+++ b/django/http/__init__.py
@@ -751,20 +751,27 @@ class HttpResponse(HttpResponseBase):
     else:
         __str__ = serialize
 
+    def _consume_content(self):
+        # If the response was instantiated with an iterator, and its content
+        # is accessed, the iterator is going be exhausted and the content
+        # loaded in memory. At this point, it's better to abandon the original
+        # iterator and save the content for later reuse.
+        if not isinstance(self._container, list):
+            self._container = list(self._container)
+
     @property
     def content(self):
+        self._consume_content()
         return b''.join(self.make_bytes(e) for e in self._container)
 
     @content.setter
     def content(self, value):
         if hasattr(value, '__iter__') and not isinstance(value, (bytes, six.string_types)):
             self._container = value
-            self._base_content_is_iter = True
             if hasattr(value, 'close'):
                 self._closable_objects.append(value)
         else:
             self._container = [value]
-            self._base_content_is_iter = False
 
     def __iter__(self):
         self._iterator = iter(self._container)
@@ -782,14 +789,12 @@ class HttpResponse(HttpResponseBase):
     next = __next__             # Python 2 compatibility
 
     def write(self, content):
-        if self._base_content_is_iter:
-            raise Exception("This %s instance is not writable" % self.__class__.__name__)
+        self._consume_content()
         self._container.append(content)
 
     def tell(self):
-        if self._base_content_is_iter:
-            raise Exception("This %s instance cannot tell its position" % self.__class__.__name__)
-        return sum([len(chunk) for chunk in self])
+        self._consume_content()
+        return sum(len(chunk) for chunk in self)
 
 class StreamingHttpResponse(HttpResponseBase):
     """
diff --git a/docs/ref/request-response.txt b/docs/ref/request-response.txt
index 89d0fe8..6dda15e 100644
--- a/docs/ref/request-response.txt
+++ b/docs/ref/request-response.txt
@@ -578,9 +578,11 @@ use this technique, the iterator should return strings.
     If you want to guarantee that your response will stream to the client, you
     should use the new :class:`StreamingHttpResponse` class instead.
 
-If an :class:`HttpResponse` instance has been initialized with an iterator as
-its content, you can't use it as a file-like object. Doing so will raise an
-exception.
+.. versionchanged:: 1.5
+
+    You can now use :class:`HttpResponse` as a file-like object even if it was
+    instantiated with an iterator. Django will consume and save the content of
+    the iterator on first access.
 
 Setting headers
 ~~~~~~~~~~~~~~~
diff --git a/tests/regressiontests/httpwrappers/tests.py b/tests/regressiontests/httpwrappers/tests.py
index bfb4ae1..5de4c15 100644
--- a/tests/regressiontests/httpwrappers/tests.py
+++ b/tests/regressiontests/httpwrappers/tests.py
@@ -330,6 +330,16 @@ class HttpResponseTests(unittest.TestCase):
         self.assertRaises(UnicodeEncodeError,
                           getattr, r, 'content')
 
+        # content can safely be accessed multiple times.
+        r = HttpResponse(iter(['hello', 'world']))
+        self.assertEqual(r.content, r.content)
+        self.assertEqual(r.content, b'helloworld')
+
+        # additional content can be written to the response.
+        r.write('!')
+        self.assertEqual(r.content, b'helloworld!')
+
+
     def test_file_interface(self):
         r = HttpResponse()
         r.write(b"hello")
@@ -338,7 +348,9 @@ class HttpResponseTests(unittest.TestCase):
         self.assertEqual(r.tell(), 17)
 
         r = HttpResponse(['abc'])
-        self.assertRaises(Exception, r.write, 'def')
+        r.write('def')
+        self.assertEqual(r.tell(), 6)
+        self.assertEqual(r.content, b'abcdef')
 
     def test_unsafe_redirect(self):
         bad_urls = [