          
          # Serialize the response content
          # TODO: renderer.media_type isn't the right thing to do here...
          if response.has_content_body:
              content = renderer(self).render(response.cleaned_content, renderer.media_type)
          else:
              content = renderer(self).render()
  
          # Build the HTTP Response
          # TODO: renderer.media_type isn't the right thing to do here...
 
</s> remove             content = renderer(self).render()
 </s> add             content = renderer.render() </s> remove             renderer = self._default_renderer
 </s> add             renderer = self._default_renderer(self) </s> remove     # TODO: This should be simpler now.
    #       Add a handles_response() to the renderer, then iterate through the
    #       acceptable media types, ordered by how specific they are,
    #       calling handles_response on each renderer.
 </s> add  </s> remove         except ErrorResponse, exc:
            response = exc.response

        # Always add these headers.
        #
        # TODO - this isn't actually the correct way to set the vary header,
        # also it's currently sub-obtimal for HTTP caching - need to sort that out. 
        response.headers['Allow'] = ', '.join(self.allowed_methods)
        response.headers['Vary'] = 'Authenticate, Accept'

        return self.render(response)
 </s> add             # Calls to 'reverse' will not be fully qualified unless we set the scheme/host/port here.
            prefix = '%s://%s' % (request.is_secure() and 'https' or 'http', request.get_host())
            set_script_prefix(prefix)
    
            try:
                self.initial(request, *args, **kwargs)
    
                # Authenticate and check request has the relevant permissions
                self._check_permissions()
    
                # Get the appropriate handler method
                if self.method.lower() in self.http_method_names:
                    handler = getattr(self, self.method.lower(), self.http_method_not_allowed)
                else:
                    handler = self.http_method_not_allowed
    
                response_obj = handler(request, *args, **kwargs)
    
                # Allow return value to be either HttpResponse, Response, or an object, or None
                if isinstance(response_obj, HttpResponse):
                    return response_obj
                elif isinstance(response_obj, Response):
                    response = response_obj
                elif response_obj is not None:
                    response = Response(status.HTTP_200_OK, response_obj)
                else:
                    response = Response(status.HTTP_204_NO_CONTENT)
    
                # Pre-serialize filtering (eg filter complex objects into natively serializable types)
                response.cleaned_content = self.filter_response(response.raw_content)
        
            except ErrorResponse, exc:
                response = exc.response
    
            # Always add these headers.
            #
            # TODO - this isn't actually the correct way to set the vary header,
            # also it's currently sub-obtimal for HTTP caching - need to sort that out. 
            response.headers['Allow'] = ', '.join(self.allowed_methods)
            response.headers['Vary'] = 'Authenticate, Accept'
    
            return self.render(response)
                    
        except:
            import traceback
            traceback.print_exc()
            raise
            content = renderer.render(response.cleaned_content, renderer.media_type)
          
          # Serialize the response content
          # TODO: renderer.media_type isn't the right thing to do here...
          if response.has_content_body:
            content = renderer.render(response.cleaned_content, renderer.media_type)
          else:
              content = renderer(self).render()
  
          # Build the HTTP Response
          # TODO: renderer.media_type isn't the right thing to do here...
keep keep keep keep replace keep keep keep keep keep
 Renderers can now cope with parameterised args.  ResponseMixin gets cleaned up & added Renderer.can_handle_response(), mirroring Parsers.can_handle_request() 
djangorestframework/mixins.py