WordPress.org

Make WordPress Core

Ticket #8674: 8674.diff

File 8674.diff, 5.7 KB (added by jacobsantos, 5 years ago)

Add Gzip support to the HTTP API.

  • http.php

     
    1313 */ 
    1414 
    1515/** 
     16 * Interface for the implementations of compression and decompression in PHP. 
     17 * 
     18 * This class will be checked for when adding classes that can be implemented. 
     19 * 
     20 * @abstract 
     21 * @since unknown 
     22 */ 
     23class WP_Http_Deflate_Interface { 
     24 
     25        /** 
     26         * Child classes should compress strings in this method. 
     27         * 
     28         * @since unknown 
     29         * 
     30         * @param string $raw Raw string to compress. 
     31         * @param int $level Optional, default is 9. Level of compression, usually 0 (none) through 9 (most). 
     32         * @return string 
     33         */ 
     34        function compress( $raw, $level = 9 ) { 
     35                trigger_error('Not implemented!', E_USER_FATAL); 
     36        } 
     37 
     38        /** 
     39         * Decompress string that was compressed by the compress method. 
     40         * 
     41         * @since unknown 
     42         * 
     43         * @param string $compressed 
     44         * @return string 
     45         */ 
     46        function decompress( $compressed ) { 
     47                trigger_error('Not implemented!', E_USER_FATAL); 
     48        } 
     49 
     50        /** 
     51         * Child classes should return the transfer encoding types that are supported. 
     52         * 
     53         * @since unknown 
     54         * @return array 
     55         */ 
     56        function accept() { 
     57                trigger_error('Not implemented!', E_USER_FATAL); 
     58        } 
     59 
     60        /** 
     61         * Child classes should return the transfer encoding type if used. 
     62         * 
     63         * @since unknown 
     64         * @return string 
     65         */ 
     66        function type() { 
     67                trigger_error('Not implemented!', E_USER_FATAL); 
     68        } 
     69 
     70        /** 
     71         * Child classes should return whether the class can be used. 
     72         * 
     73         * @since unknown 
     74         * @return bool 
     75         */ 
     76        function is_available() { 
     77                trigger_error('Not implemented!', E_USER_FATAL); 
     78        } 
     79 
     80} 
     81 
     82/** 
     83 * Decompression implementation for deflate transfer encodings. 
     84 * 
     85 * Includes both RFC 1950 and RFC 1951. 
     86 * 
     87 * @since unknown 
     88 * @uses WP_Http_Deflate_Interface Extends class. 
     89 */ 
     90class WP_Http_Deflate extends WP_Http_Deflate_Interface { 
     91 
     92        /** 
     93         * Compress raw string using the deflate format. 
     94         * 
     95         * Supports the RFC 1950 standard. 
     96         * 
     97         * @since unknown 
     98         * 
     99         * @param string $raw String to compress. 
     100         * @param int $level Optional, default is 9. Compression level, 9 is highest. 
     101         * @return string|bool False on failure. 
     102         */ 
     103        function compress( $raw, $level = 9 ) { 
     104                return gzcompress( $raw, $level ); 
     105        } 
     106 
     107        /** 
     108         * Decompression of deflated string. 
     109         * 
     110         * Will attempt to decompress using the RFC 1950 standard, and if that fails 
     111         * then the RFC 1951 standard deflate will be attempted. 
     112         * 
     113         * @since unknown 
     114         * 
     115         * @param string $compressed String to decompress. 
     116         * @return string|bool False on failure. 
     117         */ 
     118        function decompress( $compressed ) { 
     119                $decompressed = gzuncompress( $text ); 
     120 
     121                if( false === $decompressed ) 
     122                        return gzinflate( $text ); 
     123 
     124                return $decompressed; 
     125        } 
     126 
     127        /** 
     128         * Supported transfer encoding types. 
     129         * 
     130         * @since unknown 
     131         * 
     132         * @return array 
     133         */ 
     134        function accept() { 
     135                return array( 'compress', 'x-compress', 'deflate' ) 
     136        } 
     137 
     138        /** 
     139         * The accept encoding type, if supported. 
     140         * 
     141         * @since unknown 
     142         * 
     143         * @return string 
     144         */ 
     145        function type() { 
     146                return 'deflate'; 
     147        } 
     148 
     149        /** 
     150         * Whether decompression and compression are supported by the PHP version. 
     151         * 
     152         * Each function is tested instead of checking for the zlib extension, to 
     153         * ensure that the functions all exist in the PHP version and aren't 
     154         * disabled. 
     155         * 
     156         * @since unknown 
     157         * 
     158         * @return bool 
     159         */ 
     160        function is_available() { 
     161                return ( function_exists('gzuncompress') && function_exists('gzcompress') && 
     162                                 function_exists('gzinflate') ); 
     163        } 
     164 
     165} 
     166 
     167/** 
     168 * Decompression implementation for Gzip transfer encodings. 
     169 * 
     170 * For RFC 1952. 
     171 * 
     172 * @since unknown 
     173 * @uses WP_Http_Deflate_Interface Extends class. 
     174 */ 
     175class WP_Http_Gzip extends WP_Http_Deflate_Interface { 
     176 
     177        /** 
     178         * Compress raw string using the gzip format. 
     179         * 
     180         * Supports the RFC 1952 standard. 
     181         * 
     182         * @since unknown 
     183         * 
     184         * @param string $raw String to compress. 
     185         * @param int $level Optional, default is 9. Compression level, 9 is highest. 
     186         * @return string|bool False on failure. 
     187         */ 
     188        function compress( $raw, $level = 9 ) { 
     189                return gzencode( $raw, $level ); 
     190        } 
     191 
     192        /** 
     193         * Decompression of gzip string. 
     194         * 
     195         * Supports the RFC 1952 standard. 
     196         * 
     197         * @since unknown 
     198         * 
     199         * @param string $compressed String to decompress. 
     200         * @return string|bool False on failure. 
     201         */ 
     202        function decompress( $compressed ) { 
     203                return gzdecode( $text ); 
     204        } 
     205 
     206        /** 
     207         * Supported transfer encoding types. 
     208         * 
     209         * @since unknown 
     210         * 
     211         * @return array 
     212         */ 
     213        function accept() { 
     214                return array( 'gzip', 'x-gzip' ) 
     215        } 
     216 
     217        /** 
     218         * The accept encoding type, if supported. 
     219         * 
     220         * @since unknown 
     221         * 
     222         * @return string 
     223         */ 
     224        function type() { 
     225                return 'gzip'; 
     226        } 
     227 
     228        /** 
     229         * Whether decompression and compression are supported by the PHP version. 
     230         * 
     231         * Each function is tested instead of checking for the zlib extension, to 
     232         * ensure that the functions all exist in the PHP version and aren't 
     233         * disabled. 
     234         * 
     235         * @since unknown 
     236         * 
     237         * @return bool 
     238         */ 
     239        function is_available() { 
     240                return ( function_exists('gzencode') && function_exists('gzdecode') ); 
     241        } 
     242 
     243} 
     244 
     245/** 
    16246 * WordPress HTTP Class for managing HTTP Transports and making HTTP requests. 
    17247 * 
    18248 * This class is called for the functionality of making HTTP requests and should 
     
    217447                        'httpversion' => apply_filters( 'http_request_version', '1.0'), 
    218448                        'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version ), 
    219449                        'blocking' => true, 
    220                         'headers' => array(), 'body' => null 
     450                        'headers' => array(), 
     451                        'body' => null, 
     452                        'compress' => false 
    221453                ); 
    222454 
    223455                $r = wp_parse_args( $args, $defaults );