                request.META.has_key('HTTP_USER_AGENT') and
                MSIE_USER_AGENT_REGEX.match(request.META['HTTP_USER_AGENT'])):
              accept_list = ['text/html', '*/*']
          elif request.META.has_key('HTTP_ACCEPT'):
              # Use standard HTTP Accept negotiation
              accept_list = [token.strip() for token in request.META["HTTP_ACCEPT"].split(',')]
 
</s> remove             accept_list = request.META["HTTP_ACCEPT"].split(',')
 </s> add             accept_list = [token.strip() for token in request.META["HTTP_ACCEPT"].split(',')] </s> remove             return self._default_renderer
        
        # Parse the accept header into a dict of {qvalue: set of media types}
        # We ignore mietype parameters
        accept_dict = {}    
        for token in accept_list:
            components = token.split(';')
            mimetype = components[0].strip()
            qvalue = Decimal('1.0')
            
            if len(components) > 1:
                # Parse items that have a qvalue eg 'text/html; q=0.9'
                try:
                    (q, num) = components[-1].split('=')
                    if q == 'q':
                        qvalue = Decimal(num)
                except:
                    # Skip malformed entries
                    continue

            if accept_dict.has_key(qvalue):
                accept_dict[qvalue].add(mimetype)
            else:
                accept_dict[qvalue] = set((mimetype,))
        
        # Convert to a list of sets ordered by qvalue (highest first)
        accept_sets = [accept_dict[qvalue] for qvalue in sorted(accept_dict.keys(), reverse=True)]
 </s> add             return self._default_renderer(self)

        # Check the acceptable media types against each renderer,
        # attempting more specific media types first
        # NB. The inner loop here isn't as bad as it first looks :)
        #     We're effectivly looping over max len(accept_list) * len(self.renderers)
        renderers = [renderer_cls(self) for renderer_cls in self.renderers]

        for media_type_lst in order_by_precedence(accept_list):
            for renderer in renderers:
                for media_type in media_type_lst:
                    if renderer.can_handle_response(media_type):
                        return renderer </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 </s> remove             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)
 </s> add             self.request = request
            self.args = args
            self.kwargs = kwargs </s> remove             content = renderer(self).render()
 </s> add             content = renderer.render()
            # Ignore MSIE's broken accept behavior and do something sensible instead
                request.META.has_key('HTTP_USER_AGENT') and
                MSIE_USER_AGENT_REGEX.match(request.META['HTTP_USER_AGENT'])):
            # Ignore MSIE's broken accept behavior and do something sensible instead
              accept_list = ['text/html', '*/*']
          elif request.META.has_key('HTTP_ACCEPT'):
              # Use standard HTTP Accept negotiation
              accept_list = [token.strip() for token in request.META["HTTP_ACCEPT"].split(',')]
keep add 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