1. sfWebResponse.class.php
  2. /**
 * sfWebResponse class.
 *
 * This class manages web reponses. It supports cookies and headers management.
 *
 * @package    symfony
 * @subpackage response
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfWebResponse.class.php 24619 2009-11-30 23:14:18Z FabianLange $
 */
  3. class sfWebResponse extends sfResponse
  4. {
  5.   const
  6.     FIRST  = 'first',
  7.     MIDDLE = '',
  8.     LAST   = 'last',
  9.     ALL    = 'ALL',
  10.     RAW    = 'RAW';
  12.   protected
  13.     $cookies     = array(),
  14.     $statusCode  = 200,
  15.     $statusText  = 'OK',
  16.     $headerOnly  = false,
  17.     $headers     = array(),
  18.     $metas       = array(),
  19.     $httpMetas   = array(),
  20.     $positions   = array('first', '', 'last'),
  21.     $stylesheets = array(),
  22.     $javascripts = array(),
  23.     $slots       = array();
  25.   static protected $statusTexts = array(
  26.     '100' => 'Continue',
  27.     '101' => 'Switching Protocols',
  28.     '200' => 'OK',
  29.     '201' => 'Created',
  30.     '202' => 'Accepted',
  31.     '203' => 'Non-Authoritative Information',
  32.     '204' => 'No Content',
  33.     '205' => 'Reset Content',
  34.     '206' => 'Partial Content',
  35.     '300' => 'Multiple Choices',
  36.     '301' => 'Moved Permanently',
  37.     '302' => 'Found',
  38.     '303' => 'See Other',
  39.     '304' => 'Not Modified',
  40.     '305' => 'Use Proxy',
  41.     '306' => '(Unused)',
  42.     '307' => 'Temporary Redirect',
  43.     '400' => 'Bad Request',
  44.     '401' => 'Unauthorized',
  45.     '402' => 'Payment Required',
  46.     '403' => 'Forbidden',
  47.     '404' => 'Not Found',
  48.     '405' => 'Method Not Allowed',
  49.     '406' => 'Not Acceptable',
  50.     '407' => 'Proxy Authentication Required',
  51.     '408' => 'Request Timeout',
  52.     '409' => 'Conflict',
  53.     '410' => 'Gone',
  54.     '411' => 'Length Required',
  55.     '412' => 'Precondition Failed',
  56.     '413' => 'Request Entity Too Large',
  57.     '414' => 'Request-URI Too Long',
  58.     '415' => 'Unsupported Media Type',
  59.     '416' => 'Requested Range Not Satisfiable',
  60.     '417' => 'Expectation Failed',
  61.     '500' => 'Internal Server Error',
  62.     '501' => 'Not Implemented',
  63.     '502' => 'Bad Gateway',
  64.     '503' => 'Service Unavailable',
  65.     '504' => 'Gateway Timeout',
  66.     '505' => 'HTTP Version Not Supported',
  67.   );
  69.   /**
  70.    * Initializes this sfWebResponse.
  71.    *
  72.    * Available options:
  73.    *
  74.    *  * charset:           The charset to use (utf-8 by default)
  75.    *  * content_type:      The content type (text/html by default)
  76.    *  * send_http_headers: Whether to send HTTP headers or not (true by default)
  77.    *  * http_protocol:     The HTTP protocol to use for the response (HTTP/1.0 by default)
  78.    *
  79.    * @param  sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  80.    * @param  array             $options     An array of options
  81.    *
  82.    * @return bool true, if initialization completes successfully, otherwise false
  83.    *
  84.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfResponse
  85.    *
  86.    * @see sfResponse
  87.    */
  88.   public function initialize(sfEventDispatcher $dispatcher, $options = array())
  89.   {
  90.     parent::initialize($dispatcher, $options);
  92.     $this->javascripts = array_combine($this->positions, array_fill(0, count($this->positions), array()));
  93.     $this->stylesheets = array_combine($this->positions, array_fill(0, count($this->positions), array()));
  95.     if (!isset($this->options['charset']))
  96.     {
  97.       $this->options['charset'] = 'utf-8';
  98.     }
  100.     if (!isset($this->options['send_http_headers']))
  101.     {
  102.       $this->options['send_http_headers'] = true;
  103.     }
  105.     if (!isset($this->options['http_protocol']))
  106.     {
  107.       $this->options['http_protocol'] = 'HTTP/1.0';
  108.     }
  110.     $this->options['content_type'] = $this->fixContentType(isset($this->options['content_type']) ? $this->options['content_type'] : 'text/html');
  111.   }
  113.   /**
  114.    * Sets if the response consist of just HTTP headers.
  115.    *
  116.    * @param bool $value
  117.    */
  118.   public function setHeaderOnly($value = true)
  119.   {
  120.     $this->headerOnly = (boolean) $value;
  121.   }
  123.   /**
  124.    * Returns if the response must only consist of HTTP headers.
  125.    *
  126.    * @return bool returns true if, false otherwise
  127.    */
  128.   public function isHeaderOnly()
  129.   {
  130.     return $this->headerOnly;
  131.   }
  133.   /**
  134.    * Sets a cookie.
  135.    *
  136.    * @param  string  $name      HTTP header name
  137.    * @param  string  $value     Value for the cookie
  138.    * @param  string  $expire    Cookie expiration period
  139.    * @param  string  $path      Path
  140.    * @param  string  $domain    Domain name
  141.    * @param  bool    $secure    If secure
  142.    * @param  bool    $httpOnly  If uses only HTTP
  143.    *
  144.    * @throws <b>sfException</b> If fails to set the cookie
  145.    */
  146.   public function setCookie($name, $value, $expire = null, $path = '/', $domain = '', $secure = false, $httpOnly = false)
  147.   {
  148.     if ($expire !== null)
  149.     {
  150.       if (is_numeric($expire))
  151.       {
  152.         $expire = (int) $expire;
  153.       }
  154.       else
  155.       {
  156.         $expire = strtotime($expire);
  157.         if ($expire === false || $expire == -1)
  158.         {
  159.           throw new sfException('Your expire parameter is not valid.');
  160.         }
  161.       }
  162.     }
  164.     $this->cookies[$name] = array(
  165.       'name'     => $name,
  166.       'value'    => $value,
  167.       'expire'   => $expire,
  168.       'path'     => $path,
  169.       'domain'   => $domain,
  170.       'secure'   => $secure ? true : false,
  171.       'httpOnly' => $httpOnly,
  172.     );
  173.   }
  175.   /**
  176.    * Sets response status code.
  177.    *
  178.    * @param string $code  HTTP status code
  179.    * @param string $name  HTTP status text
  180.    *
  181.    */
  182.   public function setStatusCode($code, $name = null)
  183.   {
  184.     $this->statusCode = $code;
  185.     $this->statusText = null !== $name ? $name : self::$statusTexts[$code];
  186.   }
  188.   /**
  189.    * Retrieves status text for the current web response.
  190.    *
  191.    * @return string Status text
  192.    */
  193.   public function getStatusText()
  194.   {
  195.     return $this->statusText;
  196.   }
  198.   /**
  199.    * Retrieves status code for the current web response.
  200.    *
  201.    * @return integer Status code
  202.    */
  203.   public function getStatusCode()
  204.   {
  205.     return $this->statusCode;
  206.   }
  208.   /**
  209.    * Sets a HTTP header.
  210.    *
  211.    * @param string  $name     HTTP header name
  212.    * @param string  $value    Value (if null, remove the HTTP header)
  213.    * @param bool    $replace  Replace for the value
  214.    *
  215.    */
  216.   public function setHttpHeader($name, $value, $replace = true)
  217.   {
  218.     $name = $this->normalizeHeaderName($name);
  220.     if (null === $value)
  221.     {
  222.       unset($this->headers[$name]);
  224.       return;
  225.     }
  227.     if ('Content-Type' == $name)
  228.     {
  229.       if ($replace || !$this->getHttpHeader('Content-Type', null))
  230.       {
  231.         $this->setContentType($value);
  232.       }
  234.       return;
  235.     }
  237.     if (!$replace)
  238.     {
  239.       $current = isset($this->headers[$name]) ? $this->headers[$name] : '';
  240.       $value = ($current ? $current.', ' : '').$value;
  241.     }
  243.     $this->headers[$name] = $value;
  244.   }
  246.   /**
  247.    * Gets HTTP header current value.
  248.    *
  249.    * @param  string $name     HTTP header name
  250.    * @param  string $default  Default value returned if named HTTP header is not found
  251.    *
  252.    * @return string
  253.    */
  254.   public function getHttpHeader($name, $default = null)
  255.   {
  256.     $name = $this->normalizeHeaderName($name);
  258.     return isset($this->headers[$name]) ? $this->headers[$name] : $default;
  259.   }
  261.   /**
  262.    * Checks if response has given HTTP header.
  263.    *
  264.    * @param  string $name  HTTP header name
  265.    *
  266.    * @return bool
  267.    */
  268.   public function hasHttpHeader($name)
  269.   {
  270.     return array_key_exists($this->normalizeHeaderName($name), $this->headers);
  271.   }
  273.   /**
  274.    * Sets response content type.
  275.    *
  276.    * @param string $value  Content type
  277.    *
  278.    */
  279.   public function setContentType($value)
  280.   {
  281.     $this->headers['Content-Type'] = $this->fixContentType($value);
  282.   }
  284.   /**
  285.    * Gets the current charset as defined by the content type.
  286.    *
  287.    * @return string The current charset
  288.    */
  289.   public function getCharset()
  290.   {
  291.     return $this->options['charset'];
  292.   }
  294.   /**
  295.    * Gets response content type.
  296.    *
  297.    * @return array
  298.    */
  299.   public function getContentType()
  300.   {
  301.     return $this->getHttpHeader('Content-Type', $this->options['content_type']);
  302.   }
  304.   /**
  305.    * Sends HTTP headers and cookies. Only the first invocation of this method will send the headers.
  306.    * Subsequent invocations will silently do nothing. This allows certain actions to send headers early,
  307.    * while still using the standard controller.
  308.    */
  309.   public function sendHttpHeaders()
  310.   {
  311.     if (!$this->options['send_http_headers'])
  312.     {
  313.       return;
  314.     }
  316.     // status
  317.     $status = $this->options['http_protocol'].' '.$this->statusCode.' '.$this->statusText;
  318.     header($status);
  320.     if (substr(php_sapi_name(), 0, 3) == 'cgi')
  321.     {
  322.       // fastcgi servers cannot send this status information because it was sent by them already due to the HTT/1.0 line
  323.       // so we can safely unset them. see ticket #3191
  324.       unset($this->headers['Status']);
  325.     }
  327.     if ($this->options['logging'])
  328.     {
  329.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Send status "%s"', $status))));
  330.     }
  332.     // headers
  333.     if (!$this->getHttpHeader('Content-Type'))
  334.     {
  335.       $this->setContentType($this->options['content_type']);
  336.     }
  337.     foreach ($this->headers as $name => $value)
  338.     {
  339.       header($name.': '.$value);
  341.       if ($value != '' && $this->options['logging'])
  342.       {
  343.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Send header "%s: %s"', $name, $value))));
  344.       }
  345.     }
  347.     // cookies
  348.     foreach ($this->cookies as $cookie)
  349.     {
  350.       setrawcookie($cookie['name'], $cookie['value'], $cookie['expire'], $cookie['path'], $cookie['domain'], $cookie['secure'], $cookie['httpOnly']);
  352.       if ($this->options['logging'])
  353.       {
  354.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Send cookie "%s": "%s"', $cookie['name'], $cookie['value']))));
  355.       }
  356.     }
  357.     // prevent resending the headers
  358.     $this->options['send_http_headers'] = false;
  359.   }
  361.   /**
  362.    * Send content for the current web response.
  363.    *
  364.    */
  365.   public function sendContent()
  366.   {
  367.     if (!$this->headerOnly)
  368.     {
  369.       parent::sendContent();
  370.     }
  371.   }
  373.   /**
  374.    * Sends the HTTP headers and the content.
  375.    */
  376.   public function send()
  377.   {
  378.     $this->sendHttpHeaders();
  379.     $this->sendContent();
  380.   }
  382.   /**
  383.    * Retrieves a normalized Header.
  384.    *
  385.    * @param  string $name  Header name
  386.    *
  387.    * @return string Normalized header
  388.    */
  389.   protected function normalizeHeaderName($name)
  390.   {
  391.     return preg_replace('/\-(.)/e', "'-'.strtoupper('\\1')", strtr(ucfirst(strtolower($name)), '_', '-'));
  392.   }
  394.   /**
  395.    * Retrieves a formated date.
  396.    *
  397.    * @param  string $timestamp  Timestamp
  398.    * @param  string $type       Format type
  399.    *
  400.    * @return string Formatted date
  401.    */
  402.   static public function getDate($timestamp, $type = 'rfc1123')
  403.   {
  404.     $type = strtolower($type);
  406.     if ($type == 'rfc1123')
  407.     {
  408.       return substr(gmdate('r', $timestamp), 0, -5).'GMT';
  409.     }
  410.     else if ($type == 'rfc1036')
  411.     {
  412.       return gmdate('l, d-M-y H:i:s ', $timestamp).'GMT';
  413.     }
  414.     else if ($type == 'asctime')
  415.     {
  416.       return gmdate('D M j H:i:s', $timestamp);
  417.     }
  418.     else
  419.     {
  420.       throw new InvalidArgumentException('The second getDate() method parameter must be one of: rfc1123, rfc1036 or asctime.');
  421.     }
  422.   }
  424.   /**
  425.    * Adds vary to a http header.
  426.    *
  427.    * @param string $header  HTTP header
  428.    */
  429.   public function addVaryHttpHeader($header)
  430.   {
  431.     $vary = $this->getHttpHeader('Vary');
  432.     $currentHeaders = array();
  433.     if ($vary)
  434.     {
  435.       $currentHeaders = preg_split('/\s*,\s*/', $vary);
  436.     }
  437.     $header = $this->normalizeHeaderName($header);
  439.     if (!in_array($header, $currentHeaders))
  440.     {
  441.       $currentHeaders[] = $header;
  442.       $this->setHttpHeader('Vary', implode(', ', $currentHeaders));
  443.     }
  444.   }
  446.   /**
  447.    * Adds an control cache http header.
  448.    *
  449.    * @param string $name   HTTP header
  450.    * @param string $value  Value for the http header
  451.    */
  452.   public function addCacheControlHttpHeader($name, $value = null)
  453.   {
  454.     $cacheControl = $this->getHttpHeader('Cache-Control');
  455.     $currentHeaders = array();
  456.     if ($cacheControl)
  457.     {
  458.       foreach (preg_split('/\s*,\s*/', $cacheControl) as $tmp)
  459.       {
  460.         $tmp = explode('=', $tmp);
  461.         $currentHeaders[$tmp[0]] = isset($tmp[1]) ? $tmp[1] : null;
  462.       }
  463.     }
  464.     $currentHeaders[strtr(strtolower($name), '_', '-')] = $value;
  466.     $headers = array();
  467.     foreach ($currentHeaders as $key => $value)
  468.     {
  469.       $headers[] = $key.(null !== $value ? '='.$value : '');
  470.     }
  472.     $this->setHttpHeader('Cache-Control', implode(', ', $headers));
  473.   }
  475.   /**
  476.    * Retrieves meta headers for the current web response.
  477.    *
  478.    * @return string Meta headers
  479.    */
  480.   public function getHttpMetas()
  481.   {
  482.     return $this->httpMetas;
  483.   }
  485.   /**
  486.    * Adds a HTTP meta header.
  487.    *
  488.    * @param string  $key      Key to replace
  489.    * @param string  $value    HTTP meta header value (if null, remove the HTTP meta)
  490.    * @param bool    $replace  Replace or not
  491.    */
  492.   public function addHttpMeta($key, $value, $replace = true)
  493.   {
  494.     $key = $this->normalizeHeaderName($key);
  496.     // set HTTP header
  497.     $this->setHttpHeader($key, $value, $replace);
  499.     if (null === $value)
  500.     {
  501.       unset($this->httpMetas[$key]);
  503.       return;
  504.     }
  506.     if ('Content-Type' == $key)
  507.     {
  508.       $value = $this->getContentType();
  509.     }
  510.     elseif (!$replace)
  511.     {
  512.       $current = isset($this->httpMetas[$key]) ? $this->httpMetas[$key] : '';
  513.       $value = ($current ? $current.', ' : '').$value;
  514.     }
  516.     $this->httpMetas[$key] = $value;
  517.   }
  519.   /**
  520.    * Retrieves all meta headers.
  521.    *
  522.    * @return array List of meta headers
  523.    */
  524.   public function getMetas()
  525.   {
  526.     return $this->metas;
  527.   }
  529.   /**
  530.    * Adds a meta header.
  531.    *
  532.    * @param string  $key      Name of the header
  533.    * @param string  $value    Meta header value (if null, remove the meta)
  534.    * @param bool    $replace  true if it's replaceable
  535.    * @param bool    $escape   true for escaping the header
  536.    */
  537.   public function addMeta($key, $value, $replace = true, $escape = true)
  538.   {
  539.     $key = strtolower($key);
  541.     if (null === $value)
  542.     {
  543.       unset($this->metas[$key]);
  545.       return;
  546.     }
  548.     // FIXME: If you use the i18n layer and escape the data here, it won't work
  549.     // see include_metas() in AssetHelper
  550.     if ($escape)
  551.     {
  552.       $value = htmlspecialchars($value, ENT_QUOTES, $this->options['charset']);
  553.     }
  555.     $current = isset($this->metas[$key]) ? $this->metas[$key] : null;
  556.     if ($replace || !$current)
  557.     {
  558.       $this->metas[$key] = $value;
  559.     }
  560.   }
  562.   /**
  563.    * Retrieves title for the current web response.
  564.    *
  565.    * @return string Title
  566.    */
  567.   public function getTitle()
  568.   {
  569.     return isset($this->metas['title']) ? $this->metas['title'] : '';
  570.   }
  572.   /**
  573.    * Sets title for the current web response.
  574.    *
  575.    * @param string  $title   Title name
  576.    * @param bool    $escape  true, for escaping the title
  577.    */
  578.   public function setTitle($title, $escape = true)
  579.   {
  580.     $this->addMeta('title', $title, true, $escape);
  581.   }
  583.   /**
  584.    * Returns the available position names for stylesheets and javascripts in order.
  585.    *
  586.    * @return array An array of position names
  587.    */
  588.   public function getPositions()
  589.   {
  590.     return $this->positions;
  591.   }
  593.   /**
  594.    * Retrieves stylesheets for the current web response.
  595.    *
  596.    * By default, the position is sfWebResponse::ALL,
  597.    * and the method returns all stylesheets ordered by position.
  598.    *
  599.    * @param  string  $position The position
  600.    *
  601.    * @return array   An associative array of stylesheet files as keys and options as values
  602.    */
  603.   public function getStylesheets($position = self::ALL)
  604.   {
  605.     if (self::ALL === $position)
  606.     {
  607.       $stylesheets = array();
  608.       foreach ($this->getPositions() as $position)
  609.       {
  610.         foreach ($this->stylesheets[$position] as $file => $options)
  611.         {
  612.           $stylesheets[$file] = $options;
  613.         }
  614.       }
  616.       return $stylesheets;
  617.     }
  618.     else if (self::RAW === $position)
  619.     {
  620.       return $this->stylesheets;
  621.     }
  623.     $this->validatePosition($position);
  625.     return $this->stylesheets[$position];
  626.   }
  628.   /**
  629.    * Adds a stylesheet to the current web response.
  630.    *
  631.    * @param string $file      The stylesheet file
  632.    * @param string $position  Position
  633.    * @param string $options   Stylesheet options
  634.    */
  635.   public function addStylesheet($file, $position = '', $options = array())
  636.   {
  637.     $this->validatePosition($position);
  639.     $this->stylesheets[$position][$file] = $options;
  640.   }
  642.   /**
  643.    * Removes a stylesheet from the current web response.
  644.    *
  645.    * @param string $file The stylesheet file to remove
  646.    */
  647.   public function removeStylesheet($file)
  648.   {
  649.     foreach ($this->getPositions() as $position)
  650.     {
  651.       unset($this->stylesheets[$position][$file]);
  652.     }
  653.   }
  655.   /**
  656.    * Retrieves javascript files from the current web response.
  657.    *
  658.    * By default, the position is sfWebResponse::ALL,
  659.    * and the method returns all javascripts ordered by position.
  660.    *
  661.    * @param  string $position  The position
  662.    *
  663.    * @return array An associative array of javascript files as keys and options as values
  664.    */
  665.   public function getJavascripts($position = self::ALL)
  666.   {
  667.     if (self::ALL === $position)
  668.     {
  669.       $javascripts = array();
  670.       foreach ($this->getPositions() as $position)
  671.       {
  672.         foreach ($this->javascripts[$position] as $file => $options)
  673.         {
  674.           $javascripts[$file] = $options;
  675.         }
  676.       }
  678.       return $javascripts;
  679.     }
  680.     else if (self::RAW === $position)
  681.     {
  682.       return $this->javascripts;
  683.     }
  685.     $this->validatePosition($position);
  687.     return $this->javascripts[$position];
  688.   }
  690.   /**
  691.    * Adds javascript code to the current web response.
  692.    *
  693.    * @param string $file      The JavaScript file
  694.    * @param string $position  Position
  695.    * @param string $options   Javascript options
  696.    */
  697.   public function addJavascript($file, $position = '', $options = array())
  698.   {
  699.     $this->validatePosition($position);
  701.     $this->javascripts[$position][$file] = $options;
  702.   }
  704.   /**
  705.    * Removes a JavaScript file from the current web response.
  706.    *
  707.    * @param string $file The Javascript file to remove
  708.    */
  709.   public function removeJavascript($file)
  710.   {
  711.     foreach ($this->getPositions() as $position)
  712.     {
  713.       unset($this->javascripts[$position][$file]);
  714.     }
  715.   }
  717.   /**
  718.    * Retrieves slots from the current web response.
  719.    *
  720.    * @return string Javascript code
  721.    */
  722.   public function getSlots()
  723.   {
  724.     return $this->slots;
  725.   }
  727.   /**
  728.    * Sets a slot content.
  729.    *
  730.    * @param string $name     Slot name
  731.    * @param string $content  Content
  732.    */
  733.   public function setSlot($name, $content)
  734.   {
  735.     $this->slots[$name] = $content;
  736.   }
  738.   /**
  739.    * Retrieves cookies from the current web response.
  740.    *
  741.    * @return array Cookies
  742.    */
  743.   public function getCookies()
  744.   {
  745.     return $this->cookies;
  746.   }
  748.   /**
  749.    * Retrieves HTTP headers from the current web response.
  750.    *
  751.    * @return string HTTP headers
  752.    */
  753.   public function getHttpHeaders()
  754.   {
  755.     return $this->headers;
  756.   }
  758.   /**
  759.    * Cleans HTTP headers from the current web response.
  760.    */
  761.   public function clearHttpHeaders()
  762.   {
  763.     $this->headers = array();
  764.   }
  766.   /**
  767.    * Copies all properties from a given sfWebResponse object to the current one.
  768.    *
  769.    * @param sfWebResponse $response  An sfWebResponse instance
  770.    */
  771.   public function copyProperties(sfWebResponse $response)
  772.   {
  773.     $this->options     = $response->getOptions();
  774.     $this->headers     = $response->getHttpHeaders();
  775.     $this->metas       = $response->getMetas();
  776.     $this->httpMetas   = $response->getHttpMetas();
  777.     $this->stylesheets = $response->getStylesheets(self::RAW);
  778.     $this->javascripts = $response->getJavascripts(self::RAW);
  779.     $this->slots       = $response->getSlots();
  780.   }
  782.   /**
  783.    * Merges all properties from a given sfWebResponse object to the current one.
  784.    *
  785.    * @param sfWebResponse $response  An sfWebResponse instance
  786.    */
  787.   public function merge(sfWebResponse $response)
  788.   {
  789.     foreach ($this->getPositions() as $position)
  790.     {
  791.       $this->javascripts[$position] = array_merge($this->getJavascripts($position), $response->getJavascripts($position));
  792.       $this->stylesheets[$position] = array_merge($this->getStylesheets($position), $response->getStylesheets($position));
  793.     }
  795.     $this->slots = array_merge($this->getSlots(), $response->getSlots());
  796.   }
  798.   /**
  799.    * @see sfResponse
  800.    */
  801.   public function serialize()
  802.   {
  803.     return serialize(array($this->content, $this->statusCode, $this->statusText, $this->options, $this->cookies, $this->headerOnly, $this->headers, $this->metas, $this->httpMetas, $this->stylesheets, $this->javascripts, $this->slots));
  804.   }
  806.   /**
  807.    * @see sfResponse
  808.    */
  809.   public function unserialize($serialized)
  810.   {
  811.     list($this->content, $this->statusCode, $this->statusText, $this->options, $this->cookies, $this->headerOnly, $this->headers, $this->metas, $this->httpMetas, $this->stylesheets, $this->javascripts, $this->slots) = unserialize($serialized);
  812.   }
  814.   /**
  815.    * Validate a position name.
  816.    *
  817.    * @param  string $position
  818.    *
  819.    * @throws InvalidArgumentException if the position is not available
  820.    */
  821.   protected function validatePosition($position)
  822.   {
  823.     if (!in_array($position, $this->positions, true))
  824.     {
  825.       throw new InvalidArgumentException(sprintf('The position "%s" does not exist (available positions: %s).', $position, implode(', ', $this->positions)));
  826.     }
  827.   }
  829.   /**
  830.    * Fixes the content type by adding the charset for text content types.
  831.    *
  832.    * @param  string $contentType  The content type
  833.    *
  834.    * @return string The content type with the charset if needed
  835.    */
  836.   protected function fixContentType($contentType)
  837.   {
  838.     // add charset if needed (only on text content)
  839.     if (false === stripos($contentType, 'charset') && (0 === stripos($contentType, 'text/') || strlen($contentType) - 3 === strripos($contentType, 'xml')))
  840.     {
  841.       $contentType .= '; charset='.$this->options['charset'];
  842.     }
  844.     // change the charset for the response
  845.     if (preg_match('/charset\s*=\s*(.+)\s*$/', $contentType, $match))
  846.     {
  847.       $this->options['charset'] = $match[1];
  848.     }
  850.     return $contentType;
  851.   }
  852. }
Debug toolbar