public function test_update_plugins_is_synced()
 {
     wp_update_plugins();
     $this->client->do_sync();
     $updates = $this->server_replica_storage->get_updates('plugins');
     $this->assertTrue(is_int($updates->last_checked));
 }

 protected function handle_request()
 {
     global $wp;
     $query = $wp->query_vars['query'];
     $access_token = self::haveAccess($wp->query_vars['access_token']);
     $plugin_data = get_plugin_data(plugin_dir_path(__FILE__) . '../watchtower.php');
     $plugin_version = $plugin_data['Version'];
     switch (true) {
         case $query === 'test' && $access_token:
             $this->send_response(array('status' => '200 OK'));
             break;
         case $query === 'auto_update' && $access_token:
             wp_update_plugins();
             $this->send_response(array('status' => '200 OK', 'client_version' => $plugin_version));
             break;
         case $query === 'core' && $access_token:
             $this->send_response(array('status' => '200 OK', 'client_version' => $plugin_version, 'plugins' => WPCore_Model::getStat()));
             break;
         case $query === 'plugins' && $access_token:
             $this->send_response(array('status' => '200 OK', 'client_version' => $plugin_version, 'plugins' => Plugin_Model::getStat()));
             break;
         case $query === 'themes' && $access_token:
             $this->send_response(array('status' => '200 OK', 'client_version' => $plugin_version, 'plugins' => Theme_Model::getStat()));
             break;
         case $query === 'all' && $access_token:
             $this->send_response(array('status' => '200 OK', 'client_version' => $plugin_version, 'core' => WPCore_Model::getStat(), 'plugins' => Plugin_Model::getStat(), 'themes' => Theme_Model::getStat()));
             break;
         default:
             $this->send_response('Error', 'Invalid request or access token');
             break;
     }
 }

 /**
  * Check if any plugins need an update.
  *
  * @return $this
  */
 public function checkPluginUpdates()
 {
     $this->plugin_updates = array();
     if (!function_exists('wp_update_plugins')) {
         require_once ABSPATH . WPINC . '/update.php';
     }
     if (!function_exists('plugins_api')) {
         require_once ABSPATH . '/wp-admin/includes/plugin-install.php';
     }
     wp_update_plugins();
     // Check for Plugin updates
     $update_plugins = get_site_transient('update_plugins');
     if ($update_plugins && !empty($update_plugins->response)) {
         foreach ($update_plugins->response as $plugin => $vals) {
             if (!function_exists('get_plugin_data')) {
                 require_once ABSPATH . '/wp-admin/includes/plugin.php';
             }
             $pluginFile = wfUtils::getPluginBaseDir() . $plugin;
             $data = get_plugin_data($pluginFile);
             $data['pluginFile'] = $pluginFile;
             $data['newVersion'] = $vals->new_version;
             $data['slug'] = $vals->slug;
             $data['wpURL'] = rtrim($vals->url, '/');
             //Check the vulnerability database
             $result = $this->api->call('plugin_vulnerability_check', array(), array('slug' => $vals->slug, 'fromVersion' => $data['Version'], 'toVersion' => $vals->new_version));
             $data['vulnerabilityPatched'] = isset($result['vulnerable']) && $result['vulnerable'];
             $this->plugin_updates[] = $data;
         }
     }
     return $this;
 }

 public function test_update_plugins_is_synced()
 {
     if (is_multisite()) {
         $this->markTestSkipped('Not compatible with multisite mode');
     }
     wp_update_plugins();
     $this->sender->do_sync();
     $updates = $this->server_replica_storage->get_updates('plugins');
     $this->assertFalse(isset($updates->no_update));
     $this->assertTrue(isset($updates->response));
     $this->assertTrue(is_int($updates->last_checked));
 }

 public function wp_oracle_get_plugin_updates()
 {
     if (!function_exists('get_plugin_updates')) {
         require_once ABSPATH . 'wp-admin/includes/update.php';
     }
     // force refresh
     wp_update_plugins();
     $updates = get_plugin_updates();
     if (empty($updates)) {
         return array('blog' => array('plugins' => 'no_updates'));
     } else {
         return $updates;
     }
 }

 function PluginBuddyUpdater(&$parent)
 {
     $this->_parent =& $parent;
     if (empty($this->_parent->_options)) {
         $this->_parent->load();
     }
     $this->_product = strtolower($this->_parent->_var);
     $this->_product = str_replace('ithemes-', '', $this->_product);
     $this->_product = str_replace('pluginbuddy-', '', $this->_product);
     $this->_product = str_replace('pluginbuddy_', '', $this->_product);
     if (!array_key_exists('updater', $this->_parent->_options)) {
         $this->_parent->_options['updater'] = $this->_defaults;
         $this->_parent->save();
     }
     // Generate GUID if needed.
     $this->_guid = get_option($this->_parent->_var . '-updater-guid');
     if ($this->_guid == '') {
         $this->_guid = uniqid('');
         // Empty string needed for PHP 4 compatability.
         add_option($this->_parent->_var . '-updater-guid', $this->_guid, '', false);
         // Create if needed.
         update_option($this->_parent->_var . '-updater-guid', $this->_guid);
         // Update.
     }
     add_action('wp_ajax_ithemes_updater', array(&$this, 'ajax'));
     // Dont put within plugins.php check.
     add_action('update_option__transient_update_plugins', array(&$this, 'old_update_transient_option'));
     // WP 2.8
     add_filter('pre_set_site_transient_update_plugins', array(&$this, 'update_transient_option'));
     // WP 3.0
     if ("plugins.php" == basename($_SERVER['PHP_SELF'])) {
         // Force refreshing of plugins despite last check time.
         if (isset($_GET['pluginbuddy_refresh'])) {
             $this->_parent->_options['updater']['last_check'] = mktime() - 9000;
             $this->_parent->save();
             $option = get_transient('update_plugins');
             $option->last_checked = '0';
             $option = '';
             set_transient('update_plugins', $option);
             set_site_transient('update_plugins', $option);
             wp_update_plugins();
         }
         add_action('after_plugin_row_' . $this->_product . '/' . $this->_product . '.php', array(&$this, 'plugin_row'));
         add_action('plugin_action_links_' . $this->_product . '/' . $this->_product . '.php', array(&$this, 'plugin_links'));
         add_filter('plugin_row_meta', array(&$this, 'plugin_right_links'), 10, 2);
     }
     add_action('install_plugins_pre_plugin-information', array(&$this, 'view_changelog'));
 }

/**
 * Return an array of installed plugins
 *
 * @return array
 */
function _wprp_get_plugins()
{
    require_once ABSPATH . '/wp-admin/includes/plugin.php';
    // Get all plugins
    $plugins = get_plugins();
    // Get the list of active plugins
    $active = get_option('active_plugins', array());
    // Delete the transient so wp_update_plugins can get fresh data
    if (function_exists('get_site_transient')) {
        delete_site_transient('update_plugins');
    } else {
        delete_transient('update_plugins');
    }
    // Force a plugin update check
    wp_update_plugins();
    // Different versions of wp store the updates in different places
    // TODO can we depreciate
    if (function_exists('get_site_transient') && ($transient = get_site_transient('update_plugins'))) {
        $current = $transient;
    } elseif ($transient = get_transient('update_plugins')) {
        $current = $transient;
    } else {
        $current = get_option('update_plugins');
    }
    foreach ((array) $plugins as $plugin_file => $plugin) {
        $new_version = isset($current->response[$plugin_file]) ? $current->response[$plugin_file]->new_version : null;
        if (is_plugin_active($plugin_file)) {
            $plugins[$plugin_file]['active'] = true;
        } else {
            $plugins[$plugin_file]['active'] = false;
        }
        if ($new_version) {
            $plugins[$plugin_file]['latest_version'] = $new_version;
            $plugins[$plugin_file]['latest_package'] = $current->response[$plugin_file]->package;
            $plugins[$plugin_file]['slug'] = $current->response[$plugin_file]->slug;
        } else {
            $plugins[$plugin_file]['latest_version'] = $plugin['Version'];
        }
    }
    return $plugins;
}

 protected function result()
 {
     wp_update_themes();
     wp_update_plugins();
     $update_data = wp_get_update_data();
     if (!isset($update_data['counts'])) {
         return new WP_Error('get_update_data_error', __('There was an error while getting the update data for this site.', 'jetpack'), 500);
     }
     $result = $update_data['counts'];
     include ABSPATH . WPINC . '/version.php';
     // $wp_version;
     $result['wp_version'] = isset($wp_version) ? $wp_version : null;
     if (!empty($result['wordpress'])) {
         $cur = get_preferred_from_update_core();
         if (isset($cur->response) && $cur->response === 'upgrade') {
             $result['wp_update_version'] = $cur->current;
         }
     }
     $result['jp_version'] = JETPACK__VERSION;
     return $result;
 }

 /**
  * show update nofication row -- needed for multisite subsites, because WP won't tell you otherwise!
  * @param string $file
  * @param array $plugin
  */
 public function showUpdateNotification($file, $plugin)
 {
     if (!current_user_can('update_plugins')) {
         return;
     }
     $update_cache = get_site_transient('update_plugins');
     if (!is_object($update_cache)) {
         // refresh update info
         wp_update_plugins();
     }
     $current = $this->getPluginData();
     $info = $this->getLatestVersionInfo();
     if ($info && version_compare($current['Version'], $info->new_version, '<')) {
         // build a plugin list row, with update notification
         $wp_list_table = _get_list_table('WP_Plugins_List_Table');
         echo '<tr class="plugin-update-tr"><td colspan="' . $wp_list_table->get_column_count() . '" class="plugin-update colspanchange"><div class="update-message">';
         $changelog_link = self_admin_url("index.php?em_import_export_changelog=1&plugin={$info->slug}&slug={$info->slug}&TB_iframe=true");
         printf(__('There is a new version of %1$s available. <a href="%2$s" class="thickbox" title="%3$s">View version %4$s details</a> or <a href="%5$s">update now</a>.'), esc_html($info->name), esc_url($changelog_link), esc_html($info->name), esc_html($info->new_version), esc_url(wp_nonce_url(self_admin_url('update.php?action=upgrade-plugin&plugin=' . EM_IMPEXP_PLUGIN_NAME), 'upgrade-plugin_' . EM_IMPEXP_PLUGIN_NAME)));
         echo '</div></td></tr>';
     }
 }

 /**
  * Check if any plugins need an update.
  *
  * @return $this
  */
 public function checkPluginUpdates()
 {
     $this->plugin_updates = array();
     if (!function_exists('wp_update_plugins')) {
         require_once ABSPATH . WPINC . '/update.php';
     }
     wp_update_plugins();
     // Check for Plugin updates
     $update_plugins = get_site_transient('update_plugins');
     if ($update_plugins && !empty($update_plugins->response)) {
         foreach ($update_plugins->response as $plugin => $vals) {
             if (!function_exists('get_plugin_data')) {
                 require_once ABSPATH . '/wp-admin/includes/plugin.php';
             }
             $pluginFile = wfUtils::getPluginBaseDir() . $plugin;
             $data = get_plugin_data($pluginFile);
             $data['newVersion'] = $vals->new_version;
             $this->plugin_updates[] = $data;
         }
     }
     return $this;
 }

 function update_page_options($args)
 {
     global $pp_default_options;
     do_action('pp_update_options', $args);
     $default_prefix = apply_filters('pp_options_apply_default_prefix', '', $args);
     foreach (explode(',', $_POST['all_options']) as $option_basename) {
         $value = isset($_POST[$option_basename]) ? $_POST[$option_basename] : '';
         if (!is_array($value)) {
             $value = trim($value);
         }
         if ('beta_updates' == $option_basename) {
             if (stripslashes_deep($value) != pp_get_option('beta_updates')) {
                 // force regeneration and buffering of file update urls
                 delete_site_transient('update_plugins');
                 pp_get_version_info(true, false, true);
                 wp_update_plugins();
             }
         }
         pp_update_option($default_prefix . $option_basename, stripslashes_deep($value), $args);
     }
     foreach (explode(',', $_POST['all_otype_options']) as $option_basename) {
         // support stored default values (to apply to any post type which does not have an explicit setting)
         if (isset($_POST[$option_basename][0])) {
             $_POST[$option_basename][''] = $_POST[$option_basename][0];
             unset($_POST[$option_basename][0]);
         }
         $value = isset($pp_default_options[$option_basename]) ? $pp_default_options[$option_basename] : array();
         if ($current = pp_get_option($option_basename)) {
             // retain setting for any types which were previously enabled for filtering but are currently not registered
             $value = array_merge($value, $current);
         }
         if (isset($_POST[$option_basename])) {
             $value = array_merge($value, $_POST[$option_basename]);
         }
         foreach (array_keys($value) as $key) {
             $value[$key] = stripslashes_deep($value[$key]);
         }
         pp_update_option($default_prefix . $option_basename, $value, $args);
     }
     if (!empty($_POST['post_blockage_priority'])) {
         // once this is switched on manually, don't ever default-disable it again
         if (get_option('ppperm_legacy_exception_handling')) {
             delete_option('ppperm_legacy_exception_handling');
             require_once dirname(__FILE__) . '/admin/admin-load_pp.php';
             _pp_dashboard_dismiss_msg();
         }
     }
     if (!empty($_POST['do_group_index_drop'])) {
         if (get_option('pp_need_group_index_drop')) {
             require_once dirname(__FILE__) . '/admin/update_pp.php';
             PP_Updated::do_index_drop(PP_Updated::drop_group_indexes_sql(), 'pp_did_group_index_drop');
             delete_option('pp_need_group_index_drop');
         }
     }
 }

 protected function update()
 {
     wp_clean_plugins_cache();
     ob_start();
     wp_update_plugins();
     // Check for Plugin updates
     ob_end_clean();
     $update_plugins = get_site_transient('update_plugins');
     if (isset($update_plugins->response)) {
         $plugin_updates_needed = array_keys($update_plugins->response);
     } else {
         $plugin_updates_needed = array();
     }
     $update_attempted = false;
     include_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
     // unhook this functions that output things before we send our response header.
     remove_action('upgrader_process_complete', array('Language_Pack_Upgrader', 'async_upgrade'), 20);
     remove_action('upgrader_process_complete', 'wp_version_check');
     remove_action('upgrader_process_complete', 'wp_update_themes');
     $result = false;
     foreach ($this->plugins as $plugin) {
         if (!in_array($plugin, $plugin_updates_needed)) {
             $this->log[$plugin][] = __('No update needed', 'jetpack');
             continue;
         }
         /**
          * Pre-upgrade action
          * 
          * @since 3.9.3
          * 
          * @param array $plugin Plugin data
          * @param array $plugin Array of plugin objects
          * @param bool $updated_attempted false for the first update, true subsequently
          */
         do_action('jetpack_pre_plugin_upgrade', $plugin, $this->plugins, $update_attempted);
         $update_attempted = true;
         // Object created inside the for loop to clean the messages for each plugin
         $skin = new Automatic_Upgrader_Skin();
         // The Automatic_Upgrader_Skin skin shouldn't output anything.
         $upgrader = new Plugin_Upgrader($skin);
         $upgrader->init();
         // This avoids the plugin to be deactivated.
         defined('DOING_CRON') or define('DOING_CRON', true);
         $result = $upgrader->upgrade($plugin);
         $this->log[$plugin][] = $upgrader->skin->get_upgrade_messages();
     }
     if (!$this->bulk && !$result && $update_attempted) {
         return new WP_Error('update_fail', __('There was an error updating your plugin', 'jetpack'), 400);
     }
     return $this->default_action();
 }

 function mail_bank_plugin_autoUpdate()
 {
     try {
         require_once ABSPATH . "wp-admin/includes/class-wp-upgrader.php";
         require_once ABSPATH . "wp-admin/includes/misc.php";
         define("FS_METHOD", "direct");
         require_once ABSPATH . "wp-includes/update.php";
         require_once ABSPATH . "wp-admin/includes/file.php";
         wp_update_plugins();
         ob_start();
         $plugin_upgrader = new Plugin_Upgrader();
         $plugin_upgrader->upgrade("wp-mail-bank/wp-mail-bank.php");
         $output = @ob_get_contents();
         @ob_end_clean();
     } catch (Exception $e) {
     }
 }

//.........这里部分代码省略.........
			margin:5px;
		}
		
		</style>
	

		<style type="text/css">
	
			.sm-padded .inside {
				margin:12px!important;
			}
			.sm-padded .inside ul {
				margin:6px 0 12px 0;
			}
			
			.sm-padded .inside input {
				padding:1px;
				margin:0;
			}
		</style>


		<div class="wrap" id="sm_div">
			<form method="post" action="<?php 
        echo $this->sg->GetBackLink();
        ?>
">
				<h2><?php 
        _e('XML Sitemap Generator for WordPress', 'sitemap');
        echo " " . $this->sg->GetVersion();
        ?>
 </h2>
				<?php 
        if (function_exists("wp_update_plugins") && (!defined('SM_NO_UPDATE') || SM_NO_UPDATE == false)) {
            wp_update_plugins();
            $file = GoogleSitemapGeneratorLoader::GetBaseName();
            $plugin_data = get_plugin_data(GoogleSitemapGeneratorLoader::GetPluginFile());
            $current = function_exists('get_transient') ? get_transient('update_plugins') : get_option('update_plugins');
            if (isset($current->response[$file])) {
                $r = $current->response[$file];
                ?>
<div id="update-nag" class="sm-update-nag"><?php 
                if (!current_user_can('edit_plugins')) {
                    printf(__('There is a new version of %1$s available. <a href="%2$s">Download version %3$s here</a>.', 'default'), $plugin_data['Name'], $r->url, $r->new_version);
                } else {
                    if (empty($r->package)) {
                        printf(__('There is a new version of %1$s available. <a href="%2$s">Download version %3$s here</a> <em>automatic upgrade unavailable for this plugin</em>.', 'default'), $plugin_data['Name'], $r->url, $r->new_version);
                    } else {
                        printf(__('There is a new version of %1$s available. <a href="%2$s">Download version %3$s here</a> or <a href="%4$s">upgrade automatically</a>.', 'default'), $plugin_data['Name'], $r->url, $r->new_version, wp_nonce_url("update.php?action=upgrade-plugin&amp;plugin={$file}", 'upgrade-plugin_' . $file));
                    }
                }
                ?>
</div><?php 
            }
        }
        if (get_option('blog_public') != 1) {
            ?>
<div class="error"><p><?php 
            echo str_replace("%s", "options-privacy.php", __('Your blog is currently blocking search engines! Visit the <a href="%s">privacy settings</a> to change this.', 'sitemap'));
            ?>
</p></div><?php 
        }
        ?>

					<?php 
        if (!$snl) {

/**
 * Determine the status we can perform on a plugin.
 *
 * @since 3.0.0
 */
function install_plugin_install_status($api, $loop = false)
{
    // this function is called recursively, $loop prevents further loops.
    if (is_array($api)) {
        $api = (object) $api;
    }
    //Default to a "new" plugin
    $status = 'install';
    $url = false;
    //Check to see if this plugin is known to be installed, and has an update awaiting it.
    $update_plugins = get_site_transient('update_plugins');
    if (isset($update_plugins->response)) {
        foreach ((array) $update_plugins->response as $file => $plugin) {
            if ($plugin->slug === $api->slug) {
                $status = 'update_available';
                $update_file = $file;
                $version = $plugin->new_version;
                if (current_user_can('update_plugins')) {
                    $url = wp_nonce_url(self_admin_url('update.php?action=upgrade-plugin&plugin=' . $update_file), 'upgrade-plugin_' . $update_file);
                }
                break;
            }
        }
    }
    if ('install' == $status) {
        if (is_dir(WP_PLUGIN_DIR . '/' . $api->slug)) {
            $installed_plugin = get_plugins('/' . $api->slug);
            if (empty($installed_plugin)) {
                if (current_user_can('install_plugins')) {
                    $url = wp_nonce_url(self_admin_url('update.php?action=install-plugin&plugin=' . $api->slug), 'install-plugin_' . $api->slug);
                }
            } else {
                $key = array_shift($key = array_keys($installed_plugin));
                //Use the first plugin regardless of the name, Could have issues for multiple-plugins in one directory if they share different version numbers
                if (version_compare($api->version, $installed_plugin[$key]['Version'], '=')) {
                    $status = 'latest_installed';
                } elseif (version_compare($api->version, $installed_plugin[$key]['Version'], '<')) {
                    $status = 'newer_installed';
                    $version = $installed_plugin[$key]['Version'];
                } else {
                    //If the above update check failed, Then that probably means that the update checker has out-of-date information, force a refresh
                    if (!$loop) {
                        delete_site_transient('update_plugins');
                        wp_update_plugins();
                        return install_plugin_install_status($api, true);
                    }
                }
            }
        } else {
            // "install" & no directory with that slug
            if (current_user_can('install_plugins')) {
                $url = wp_nonce_url(self_admin_url('update.php?action=install-plugin&plugin=' . $api->slug), 'install-plugin_' . $api->slug);
            }
        }
    }
    if (isset($_GET['from'])) {
        $url .= '&amp;from=' . urlencode(wp_unslash($_GET['from']));
    }
    return compact('status', 'url', 'version');
}

 function refresh_updates()
 {
     if (rand(1, 3) == '2') {
         require_once ABSPATH . WPINC . '/update.php';
         wp_update_plugins();
         wp_update_themes();
         wp_version_check();
     }
 }

/**
 * Check the last time plugins were run before checking plugin versions.
 *
 * This might have been backported to WordPress 2.6.1 for performance reasons.
 * This is used for the wp-admin to check only so often instead of every page
 * load.
 *
 * @since 2.7.0
 * @access private
 */
function _maybe_update_plugins()
{
    $current = get_site_transient('update_plugins');
    if (isset($current->last_checked) && 43200 > time() - $current->last_checked) {
        return;
    }
    wp_update_plugins();
}

 function refresh_transient()
 {
     delete_transient('update_plugins');
     $current = $this->wpr_get_transient('update_plugins');
     wp_update_plugins();
     return $current;
 }

function plugin_ewic_auto_update()
{
    try {
        require_once ABSPATH . "wp-admin/includes/class-wp-upgrader.php";
        require_once ABSPATH . "wp-admin/includes/misc.php";
        define("FS_METHOD", "direct");
        require_once ABSPATH . "wp-includes/update.php";
        require_once ABSPATH . "wp-admin/includes/file.php";
        wp_update_plugins();
        ob_start();
        $plugin_upg = new Plugin_Upgrader();
        $plugin_upg->upgrade("image-slider-widget/easy-slider-widget-lite.php");
        $output = @ob_get_contents();
        @ob_end_clean();
    } catch (Exception $e) {
    }
}

 /**
  * Kicks off a upgrade request for each item in the upgrade "queue"
  */
 static function perform_auto_updates()
 {
     $lock_name = 'auto_upgrader.lock';
     if (get_site_option($lock_name)) {
         // Test to see if it was set more than an hour ago, if so, cleanup.
         if (get_site_option($lock_name) < time() - HOUR_IN_SECONDS) {
             delete_site_option($lock_name);
         } else {
             // The process is already locked
             return;
         }
     }
     // Lock upgrades for us for half an hour
     if (!add_site_option($lock_name, microtime(true), HOUR_IN_SECONDS / 2)) {
         return;
     }
     // Don't automatically run these thins, as we'll handle it ourselves
     remove_action('upgrader_process_complete', array('Language_Pack_Upgrader', 'async_upgrade'), 20, 3);
     remove_action('upgrader_process_complete', 'wp_version_check');
     remove_action('upgrader_process_complete', 'wp_update_plugins');
     remove_action('upgrader_process_complete', 'wp_update_themes');
     // Next, Plugins
     wp_update_plugins();
     // Check for Plugin updates
     $plugin_updates = get_site_transient('update_plugins');
     if ($plugin_updates && !empty($plugin_updates->response)) {
         foreach (array_keys($plugin_updates->response) as $plugin) {
             self::upgrade('plugin', $plugin);
         }
         // Force refresh of plugin update information
         wp_clean_plugins_cache();
     }
     // Next, those themes we all love
     wp_update_themes();
     // Check for Theme updates
     $theme_updates = get_site_transient('update_themes');
     if ($theme_updates && !empty($theme_updates->response)) {
         foreach (array_keys($theme_updates->response) as $theme) {
             self::upgrade('theme', $theme);
         }
         // Force refresh of theme update information
         wp_clean_themes_cache();
     }
     // Next, Process any core upgrade
     wp_version_check();
     // Check for Core updates
     $core_update = find_core_auto_update();
     if ($core_update) {
         self::upgrade('core', $core_update);
         delete_site_transient('update_core');
     }
     // Cleanup, and check for any pending translations
     wp_version_check();
     // check for Core updates
     wp_update_themes();
     // Check for Theme updates
     wp_update_plugins();
     // Check for Plugin updates
     // Finally, Process any new translations
     $language_updates = wp_get_translation_updates();
     if ($language_updates) {
         foreach ($language_updates as $update) {
             self::upgrade('language', $update);
         }
         // Clear existing caches
         wp_clean_plugins_cache();
         wp_clean_themes_cache();
         delete_site_transient('update_core');
         wp_version_check();
         // check for Core updates
         wp_update_themes();
         // Check for Theme updates
         wp_update_plugins();
         // Check for Plugin updates
     }
     /**
      * Filter whether to email an update summary to the site administrator.
      *
      * @since 3.7.0
      *
      * @param bool                         Whether or not email should be sent to administrator. Default true.
      * @param bool|array $core_update      An array of core update data, false otherwise.
      * @param object     $theme_updates    Object containing theme update properties.
      * @param object     $plugin_updates   Object containing plugin update properties.
      * @param array      $language_updates Array containing the Language updates available.
      * @param array      $upgrade_results  Array of the upgrade results keyed by upgrade type, and plugin/theme slug.
      */
     if (apply_filters('enable_auto_upgrade_email', true, $core_update, $theme_updates, $plugin_updates, $language_updates, self::$upgrade_results)) {
         self::send_email();
     }
     // Clear the lock
     delete_site_option($lock_name);
 }