WordPress.org

Make WordPress Core

Ticket #29779: 29779.patch

File 29779.patch, 9.0 KB (added by azaozz, 7 years ago)
  • src/wp-includes/js/heartbeat.js

     
    5757                                // Used when the interval is reset
    5858                                originalInterval: 0,
    5959
     60                                // Used to limit the number of AJAX requests.
     61                                minimalInterval: 0,
     62
    6063                                // Used together with tempInterval
    6164                                countdown: 0,
    6265
     
    8184                                // Flags whether events tracking user activity were set
    8285                                userActivityEvents: false,
    8386
    84                                 // References to various timeouts
    85                                 beatTimer: 0,
    86                                 winBlurTimer: 0,
    87                                 frameBlurTimer: 0
     87                                beatTimer: 0
    8888                        };
    8989
    9090                /**
     
    9595                 * @return void
    9696                 */
    9797                function initialize() {
     98                        var options, hidden, visibilityState, visibilitychange;
     99
    98100                        if ( typeof window.pagenow === 'string' ) {
    99101                                settings.screenId = window.pagenow;
    100102                        }
     
    105107
    106108                        // Pull in options passed from PHP
    107109                        if ( typeof window.heartbeatSettings === 'object' ) {
    108                                 var options = window.heartbeatSettings;
     110                                options = window.heartbeatSettings;
    109111
    110112                                // The XHR URL can be passed as option when window.ajaxurl is not set
    111113                                if ( ! settings.url && options.ajaxurl ) {
     
    112114                                        settings.url = options.ajaxurl;
    113115                                }
    114116
    115                                 // The interval can be from 15 to 60 sec. and can be set temporarily to 5 sec.
     117                                // The interval can be from 15 to 120 sec. and can be set temporarily to 5 sec.
     118                                // It can be set in the initial options or changed later from JS and/or from PHP.
    116119                                if ( options.interval ) {
    117120                                        settings.mainInterval = options.interval;
    118121
    119122                                        if ( settings.mainInterval < 15 ) {
    120123                                                settings.mainInterval = 15;
    121                                         } else if ( settings.mainInterval > 60 ) {
    122                                                 settings.mainInterval = 60;
     124                                        } else if ( settings.mainInterval > 120 ) {
     125                                                settings.mainInterval = 120;
    123126                                        }
    124127                                }
    125128
     129                                // Used to limit the number of AJAX requests. Overrides all other intervals if they are shorter.
     130                                // Needed for some hosts that cannot handle frequent requests and the user may exceed the allocated server CPU time, etc.
     131                                // The minimal interval can be up to 600 sec. however setting it to longer than 120 sec. will limit or disable
     132                                // some of the functionality (like post locks).
     133                                // Once set at initialization, minimalInterval cannot be changed/overriden.
     134                                if ( options.minimalInterval ) {
     135                                        options.minimalInterval = parseInt( options.minimalInterval, 10 );
     136                                        settings.minimalInterval = options.minimalInterval > 0 && options.minimalInterval <= 600 ? options.minimalInterval * 1000 : 0;
     137                                }
     138
     139                                if ( settings.minimalInterval && settings.mainInterval < settings.minimalInterval ) {
     140                                        settings.mainInterval = settings.minimalInterval;
     141                                }
     142
    126143                                // 'screenId' can be added from settings on the front-end where the JS global 'pagenow' is not set
    127144                                if ( ! settings.screenId ) {
    128145                                        settings.screenId = options.screenId || 'front';
     
    137154                        settings.mainInterval = settings.mainInterval * 1000;
    138155                        settings.originalInterval = settings.mainInterval;
    139156
    140                         // Set focus/blur events on the window
    141                         $(window).on( 'blur.wp-heartbeat-focus', function() {
    142                                 setFrameFocusEvents();
    143                                 // We don't know why the 'blur' was fired. Either the user clicked in an iframe or outside the browser.
    144                                 // Running blurred() after some timeout lets us cancel it if the user clicked in an iframe.
    145                                 settings.winBlurTimer = window.setTimeout( function(){ blurred(); }, 500 );
    146                         }).on( 'focus.wp-heartbeat-focus', function() {
    147                                 removeFrameFocusEvents();
    148                                 focused();
    149                         }).on( 'unload.wp-heartbeat', function() {
     157                        // Switch the interval to 120 sec. by using the Page Visibility API.
     158                        // If the browser doesn't support it (Safari < 7, Android < 4.4, IE < 10), the interval
     159                        // will be increased to 120 sec. after 5 min. of mouse and keyboard inactivity.
     160                        if ( typeof document.hidden !== 'undefined' ) {
     161                                hidden = 'hidden';
     162                                visibilitychange = 'visibilitychange';
     163                                visibilityState = 'visibilityState';
     164                        } else if ( typeof document.msHidden !== 'undefined' ) { // IE10
     165                                hidden = 'msHidden';
     166                                visibilitychange = 'msvisibilitychange';
     167                                visibilityState = 'msVisibilityState';
     168                        } else if ( typeof document.webkitHidden !== 'undefined' ) { // Android
     169                                hidden = 'webkitHidden';
     170                                visibilitychange = 'webkitvisibilitychange';
     171                                visibilityState = 'webkitVisibilityState';
     172                        }
     173
     174                        if ( hidden ) {
     175                                if ( document[hidden] ) {
     176                                        settings.hasFocus = false;
     177                                }
     178
     179                                $document.on( visibilitychange + '.wp-heartbeat', function() {
     180                                        if ( document[visibilityState] === 'hidden' ) {
     181                                                blurred();
     182                                        } else {
     183                                                focused();
     184                                        }
     185                                });
     186                        }
     187
     188                        $(window).on( 'unload.wp-heartbeat', function() {
    150189                                // Don't connect any more
    151190                                settings.suspend = true;
    152191
     
    374413                                }
    375414                        }
    376415
     416                        if ( settings.minimalInterval && interval < settings.minimalInterval ) {
     417                                interval = settings.minimalInterval;
     418                        }
     419
    377420                        window.clearTimeout( settings.beatTimer );
    378421
    379422                        if ( delta < interval ) {
     
    389432                }
    390433
    391434                /**
    392                  * Set the internal state when the browser window looses focus
     435                 * Set the internal state when the browser window is hidden
    393436                 *
    394437                 * @access private
    395438                 *
     
    396439                 * @return void
    397440                 */
    398441                function blurred() {
    399                         clearFocusTimers();
    400442                        settings.hasFocus = false;
    401443                }
    402444
    403445                /**
    404                  * Set the internal state when the browser window is focused
     446                 * Set the internal state when the browser window is visible
    405447                 *
    406448                 * @access private
    407449                 *
     
    408450                 * @return void
    409451                 */
    410452                function focused() {
    411                         clearFocusTimers();
    412453                        settings.userActivity = time();
    413454
    414455                        // Resume if suspended
     
    421462                }
    422463
    423464                /**
    424                  * Add focus/blur events to all local iframes
    425                  *
    426                  * Used to detect when focus is moved from the main window to an iframe
    427                  *
    428                  * @access private
    429                  *
    430                  * @return void
    431                  */
    432                 function setFrameFocusEvents() {
    433                         $('iframe').each( function( i, frame ) {
    434                                 if ( ! isLocalFrame( frame ) ) {
    435                                         return;
    436                                 }
    437 
    438                                 if ( $.data( frame, 'wp-heartbeat-focus' ) ) {
    439                                         return;
    440                                 }
    441 
    442                                 $.data( frame, 'wp-heartbeat-focus', 1 );
    443 
    444                                 $( frame.contentWindow ).on( 'focus.wp-heartbeat-focus', function() {
    445                                         focused();
    446                                 }).on('blur.wp-heartbeat-focus', function() {
    447                                         setFrameFocusEvents();
    448                                         // We don't know why 'blur' was fired. Either the user clicked in the main window or outside the browser.
    449                                         // Running blurred() after some timeout lets us cancel it if the user clicked in the main window.
    450                                         settings.frameBlurTimer = window.setTimeout( function(){ blurred(); }, 500 );
    451                                 });
    452                         });
    453                 }
    454 
    455                 /**
    456                  * Remove the focus/blur events to all local iframes
    457                  *
    458                  * @access private
    459                  *
    460                  * @return void
    461                  */
    462                 function removeFrameFocusEvents() {
    463                         $('iframe').each( function( i, frame ) {
    464                                 if ( ! isLocalFrame( frame ) ) {
    465                                         return;
    466                                 }
    467 
    468                                 $.removeData( frame, 'wp-heartbeat-focus' );
    469                                 $( frame.contentWindow ).off( '.wp-heartbeat-focus' );
    470                         });
    471                 }
    472 
    473                 /**
    474                  * Clear the reset timers for focus/blur events on the window and iframes
    475                  *
    476                  * @access private
    477                  *
    478                  * @return void
    479                  */
    480                 function clearFocusTimers() {
    481                         window.clearTimeout( settings.winBlurTimer );
    482                         window.clearTimeout( settings.frameBlurTimer );
    483                 }
    484 
    485                 /**
    486465                 * Runs when the user becomes active after a period of inactivity
    487466                 *
    488467                 * @access private
     
    524503                                blurred();
    525504                        }
    526505
    527                         if ( settings.suspendEnabled && lastActive > 1200000 ) {
    528                                 // Suspend after 20 min. of inactivity
     506                        if ( settings.suspendEnabled && lastActive > 600000 ) {
     507                                // Suspend after 10 min. of inactivity when suspending is enabled.
    529508                                settings.suspend = true;
     509                        } else if ( lastActive > 3600000 ) {
     510                                // Always suspend after 60 min. of inactivity. This will release the post lock, etc.
     511                                settings.suspend = true;
    530512                        }
    531513
    532514                        if ( ! settings.userActivityEvents ) {
     
    597579                 * In this case the number of 'ticks' can be passed as second argument.
    598580                 * If the window doesn't have focus, the interval slows down to 2 min.
    599581                 *
    600                  * @param mixed speed Interval: 'fast' or 5, 15, 30, 60
     582                 * @param mixed speed Interval: 'fast' or 5, 15, 30, 60, 120
    601583                 * @param string ticks Used with speed = 'fast' or 5, how many ticks before the interval reverts back
    602584                 * @return int Current interval in seconds
    603585                 */
     
    620602                                        case 60:
    621603                                                newInterval = 60000;
    622604                                                break;
     605                                        case 120:
     606                                                newInterval = 120000;
     607                                                break;
    623608                                        case 'long-polling':
    624609                                                // Allow long polling, (experimental)
    625610                                                settings.mainInterval = 0;
     
    628613                                                newInterval = settings.originalInterval;
    629614                                }
    630615
     616                                if ( settings.minimalInterval && newInterval < settings.minimalInterval ) {
     617                                        newInterval = settings.minimalInterval;
     618                                }
     619
    631620                                if ( 5000 === newInterval ) {
    632621                                        ticks = parseInt( ticks, 10 ) || 30;
    633622                                        ticks = ticks < 1 || ticks > 30 ? 30 : ticks;