From 83b059aa1927897e5c7394c35d3aebac5b34f2d1 Mon Sep 17 00:00:00 2001
From: Weston Ruter <westonruter@git.wordpress.org>
Date: Tue, 18 Oct 2016 20:04:36 +0000
Subject: [PATCH] Customize: Implement customized state persistence with
 changesets.

Includes infrastructure developed in the Customize Snapshots feature plugin.

See https://make.wordpress.org/core/2016/10/12/customize-changesets-technical-design-decisions/

Props westonruter, valendesigns, utkarshpatel, stubgo, lgedeon, ocean90, ryankienstra, mihai2u, dlh, aaroncampbell, jonathanbardo, jorbin.
See #28721.
See #31089.
Fixes #30937.
Fixes #31517.
Fixes #30028.
Fixes #23225.
Fixes #34142.
Fixes #36485.


git-svn-id: https://develop.svn.wordpress.org/trunk@38810 602fd350-edb4-49c9-b593-d223f7449a82
---
 src/wp-admin/customize.php                    |   37 +-
 src/wp-admin/js/customize-controls.js         | 1114 ++++++++++----
 src/wp-admin/js/customize-widgets.js          |    2 +-
 src/wp-includes/admin-bar.php                 |   15 +
 .../class-wp-customize-manager.php            | 1287 +++++++++++++++--
 .../class-wp-customize-nav-menus.php          |   27 +-
 .../class-wp-customize-widgets.php            |   11 +-
 .../class-wp-customize-selective-refresh.php  |    2 -
 .../class-wp-customize-theme-control.php      |    4 +-
 src/wp-includes/default-filters.php           |    2 +
 src/wp-includes/functions.php                 |   17 +
 src/wp-includes/functions.wp-scripts.php      |    2 +-
 src/wp-includes/js/customize-base.js          |   50 +-
 src/wp-includes/js/customize-loader.js        |   13 +
 .../js/customize-preview-nav-menus.js         |   27 +-
 .../js/customize-preview-widgets.js           |    5 +
 src/wp-includes/js/customize-preview.js       |  568 +++++++-
 .../js/customize-selective-refresh.js         |   10 +-
 src/wp-includes/post.php                      |   45 +
 src/wp-includes/script-loader.php             |    2 +-
 src/wp-includes/theme.php                     |  142 +-
 tests/phpunit/tests/adminbar.php              |   33 +
 tests/phpunit/tests/ajax/CustomizeManager.php |  310 ++++
 tests/phpunit/tests/customize/manager.php     |  805 ++++++++++-
 .../customize/selective-refresh-ajax.php      |   19 -
 tests/phpunit/tests/customize/setting.php     |    6 +
 tests/phpunit/tests/functions.php             |   18 +
 tests/phpunit/tests/post.php                  |   46 +
 tests/qunit/fixtures/customize-settings.js    |   11 +
 tests/qunit/index.html                        |    4 +
 tests/qunit/wp-admin/js/customize-base.js     |   19 +
 tests/qunit/wp-admin/js/customize-controls.js |   72 +-
 32 files changed, 4186 insertions(+), 539 deletions(-)
 create mode 100644 tests/phpunit/tests/ajax/CustomizeManager.php

diff --git a/src/wp-admin/customize.php b/src/wp-admin/customize.php
index e45254c74a..0a5350f54c 100644
--- a/src/wp-admin/customize.php
+++ b/src/wp-admin/customize.php
@@ -20,6 +20,31 @@ if ( ! current_user_can( 'customize' ) ) {
 	);
 }
 
+/**
+ * @global WP_Scripts           $wp_scripts
+ * @global WP_Customize_Manager $wp_customize
+ */
+global $wp_scripts, $wp_customize;
+
+if ( $wp_customize->changeset_post_id() ) {
+	if ( ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->edit_post, $wp_customize->changeset_post_id() ) ) {
+		wp_die(
+			'<h1>' . __( 'Cheatin&#8217; uh?' ) . '</h1>' .
+			'<p>' . __( 'Sorry, you are not allowed to edit this changeset.' ) . '</p>',
+			403
+		);
+	}
+	if ( in_array( get_post_status( $wp_customize->changeset_post_id() ), array( 'publish', 'trash' ), true ) ) {
+		wp_die(
+			'<h1>' . __( 'Cheatin&#8217; uh?' ) . '</h1>' .
+			'<p>' . __( 'This changeset has already been published and cannot be further modified.' ) . '</p>' .
+			'<p><a href="' . esc_url( remove_query_arg( 'changeset_uuid' ) ) . '">' . __( 'Customize New Changes' ) . '</a></p>',
+			403
+		);
+	}
+}
+
+
 wp_reset_vars( array( 'url', 'return', 'autofocus' ) );
 if ( ! empty( $url ) ) {
 	$wp_customize->set_preview_url( wp_unslash( $url ) );
@@ -31,12 +56,6 @@ if ( ! empty( $autofocus ) && is_array( $autofocus ) ) {
 	$wp_customize->set_autofocus( wp_unslash( $autofocus ) );
 }
 
-/**
- * @global WP_Scripts           $wp_scripts
- * @global WP_Customize_Manager $wp_customize
- */
-global $wp_scripts, $wp_customize;
-
 $registered = $wp_scripts->registered;
 $wp_scripts = new WP_Scripts;
 $wp_scripts->registered = $registered;
@@ -115,7 +134,11 @@ do_action( 'customize_controls_print_scripts' );
 		<div id="customize-header-actions" class="wp-full-overlay-header">
 			<?php
 			$save_text = $wp_customize->is_theme_active() ? __( 'Save &amp; Publish' ) : __( 'Save &amp; Activate' );
-			submit_button( $save_text, 'primary save', 'save', false );
+			$save_attrs = array();
+			if ( ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->publish_posts ) ) {
+				$save_attrs['style'] = 'display: none';
+			}
+			submit_button( $save_text, 'primary save', 'save', false, $save_attrs );
 			?>
 			<span class="spinner"></span>
 			<button type="button" class="customize-controls-preview-toggle">
diff --git a/src/wp-admin/js/customize-controls.js b/src/wp-admin/js/customize-controls.js
index 4410593a0b..db6403879e 100644
--- a/src/wp-admin/js/customize-controls.js
+++ b/src/wp-admin/js/customize-controls.js
@@ -22,26 +22,42 @@
 	 */
 	api.Setting = api.Value.extend({
 		initialize: function( id, value, options ) {
-			api.Value.prototype.initialize.call( this, value, options );
+			var setting = this;
+			api.Value.prototype.initialize.call( setting, value, options );
 
-			this.id = id;
-			this.transport = this.transport || 'refresh';
-			this._dirty = options.dirty || false;
-			this.notifications = new api.Values({ defaultConstructor: api.Notification });
+			setting.id = id;
+			setting.transport = setting.transport || 'refresh';
+			setting._dirty = options.dirty || false;
+			setting.notifications = new api.Values({ defaultConstructor: api.Notification });
 
 			// Whenever the setting's value changes, refresh the preview.
-			this.bind( this.preview );
+			setting.bind( setting.preview );
 		},
 
 		/**
 		 * Refresh the preview, respective of the setting's refresh policy.
+		 *
+		 * If the preview hasn't sent a keep-alive message and is likely
+		 * disconnected by having navigated to a non-allowed URL, then the
+		 * refresh transport will be forced when postMessage is the transport.
+		 * Note that postMessage does not throw an error when the recipient window
+		 * fails to match the origin window, so using try/catch around the
+		 * previewer.send() call to then fallback to refresh will not work.
+		 *
+		 * @since 3.4.0
 		 */
 		preview: function() {
-			switch ( this.transport ) {
-				case 'refresh':
-					return this.previewer.refresh();
-				case 'postMessage':
-					return this.previewer.send( 'setting', [ this.id, this() ] );
+			var setting = this, transport;
+			transport = setting.transport;
+
+			if ( 'postMessage' === transport && ! api.state( 'previewerAlive' ).get() ) {
+				transport = 'refresh';
+			}
+
+			if ( 'postMessage' === transport ) {
+				return setting.previewer.send( 'setting', [ setting.id, setting() ] );
+			} else if ( 'refresh' === transport ) {
+				return setting.previewer.refresh();
 			}
 		},
 
@@ -65,9 +81,166 @@
 	});
 
 	/**
-	 * Utility function namespace
+	 * Current change count.
+	 *
+	 * @since 4.7.0
+	 * @type {number}
+	 * @protected
 	 */
-	api.utils = {};
+	api._latestRevision = 0;
+
+	/**
+	 * Last revision that was saved.
+	 *
+	 * @since 4.7.0
+	 * @type {number}
+	 * @protected
+	 */
+	api._lastSavedRevision = 0;
+
+	/**
+	 * Latest revisions associated with the updated setting.
+	 *
+	 * @since 4.7.0
+	 * @type {object}
+	 * @protected
+	 */
+	api._latestSettingRevisions = {};
+
+	/*
+	 * Keep track of the revision associated with each updated setting so that
+	 * requestChangesetUpdate knows which dirty settings to include. Also, once
+	 * ready is triggered and all initial settings have been added, increment
+	 * revision for each newly-created initially-dirty setting so that it will
+	 * also be included in changeset update requests.
+	 */
+	api.bind( 'change', function incrementChangedSettingRevision( setting ) {
+		api._latestRevision += 1;
+		api._latestSettingRevisions[ setting.id ] = api._latestRevision;
+	} );
+	api.bind( 'ready', function() {
+		api.bind( 'add', function incrementCreatedSettingRevision( setting ) {
+			if ( setting._dirty ) {
+				api._latestRevision += 1;
+				api._latestSettingRevisions[ setting.id ] = api._latestRevision;
+			}
+		} );
+	} );
+
+	/**
+	 * Get the dirty setting values.
+	 *
+	 * @param {object} [options] Options.
+	 * @param {boolean} [options.unsaved=false] Whether only values not saved yet into a changeset will be returned (differential changes).
+	 * @returns {object} Dirty setting values.
+	 */
+	api.dirtyValues = function dirtyValues( options ) {
+		var values = {};
+		api.each( function( setting ) {
+			var settingRevision;
+
+			if ( ! setting._dirty ) {
+				return;
+			}
+
+			settingRevision = api._latestSettingRevisions[ setting.id ];
+
+			// Skip including settings that have already been included in the changeset, if only requesting unsaved.
+			if ( ( options && options.unsaved ) && ( _.isUndefined( settingRevision ) || settingRevision <= api._lastSavedRevision ) ) {
+				return;
+			}
+
+			values[ setting.id ] = setting.get();
+		} );
+		return values;
+	};
+
+	/**
+	 * Request updates to the changeset.
+	 *
+	 * @param {object} [changes] Mapping of setting IDs to setting params each normally including a value property, or mapping to null.
+	 *                           If not provided, then the changes will still be obtained from unsaved dirty settings.
+	 * @returns {jQuery.Promise}
+	 */
+	api.requestChangesetUpdate = function requestChangesetUpdate( changes ) {
+		var deferred, request, submittedChanges = {}, data;
+		deferred = new $.Deferred();
+
+		if ( changes ) {
+			_.extend( submittedChanges, changes );
+		}
+
+		// Ensure all revised settings (changes pending save) are also included, but not if marked for deletion in changes.
+		_.each( api.dirtyValues( { unsaved: true } ), function( dirtyValue, settingId ) {
+			if ( ! changes || null !== changes[ settingId ] ) {
+				submittedChanges[ settingId ] = _.extend(
+					{},
+					submittedChanges[ settingId ] || {},
+					{ value: dirtyValue }
+				);
+			}
+		} );
+
+		// Short-circuit when there are no pending changes.
+		if ( _.isEmpty( submittedChanges ) ) {
+			deferred.resolve( {} );
+			return deferred.promise();
+		}
+
+		// Make sure that publishing a changeset waits for all changeset update requests to complete.
+		api.state( 'processing' ).set( api.state( 'processing' ).get() + 1 );
+		deferred.always( function() {
+			api.state( 'processing' ).set( api.state( 'processing' ).get() - 1 );
+		} );
+
+		// Allow plugins to attach additional params to the settings.
+		api.trigger( 'changeset-save', submittedChanges );
+
+		// Ensure that if any plugins add data to save requests by extending query() that they get included here.
+		data = api.previewer.query( { excludeCustomizedSaved: true } );
+		delete data.customized; // Being sent in customize_changeset_data instead.
+		_.extend( data, {
+			nonce: api.settings.nonce.save,
+			customize_theme: api.settings.theme.stylesheet,
+			customize_changeset_data: JSON.stringify( submittedChanges )
+		} );
+
+		request = wp.ajax.post( 'customize_save', data );
+
+		request.done( function requestChangesetUpdateDone( data ) {
+			var savedChangesetValues = {};
+
+			// Ensure that all settings updated subsequently will be included in the next changeset update request.
+			api._lastSavedRevision = Math.max( api._latestRevision, api._lastSavedRevision );
+
+			api.state( 'changesetStatus' ).set( data.changeset_status );
+			deferred.resolve( data );
+			api.trigger( 'changeset-saved', data );
+
+			if ( data.setting_validities ) {
+				_.each( data.setting_validities, function( validity, settingId ) {
+					if ( true === validity && _.isObject( submittedChanges[ settingId ] ) && ! _.isUndefined( submittedChanges[ settingId ].value ) ) {
+						savedChangesetValues[ settingId ] = submittedChanges[ settingId ].value;
+					}
+				} );
+			}
+
+			api.previewer.send( 'changeset-saved', _.extend( {}, data, { saved_changeset_values: savedChangesetValues } ) );
+		} );
+		request.fail( function requestChangesetUpdateFail( data ) {
+			deferred.reject( data );
+			api.trigger( 'changeset-error', data );
+		} );
+		request.always( function( data ) {
+			if ( data.setting_validities ) {
+				api._handleSettingValidities( {
+					settingValidities: data.setting_validities
+				} );
+			}
+		} );
+
+		return deferred.promise();
+	};
 
 	/**
 	 * Watch all changes to Value properties, and bubble changes to parent Values instance
@@ -1215,6 +1388,57 @@
 			}
 		},
 
+		/**
+		 * Load theme preview.
+		 *
+		 * @since 4.7.0
+		 *
+		 * @param {string} themeId Theme ID.
+		 * @returns {jQuery.promise} Promise.
+		 */
+		loadThemePreview: function( themeId ) {
+			var deferred = $.Deferred(), onceProcessingComplete, overlay, urlParser;
+
+			urlParser = document.createElement( 'a' );
+			urlParser.href = location.href;
+			urlParser.search = $.param( _.extend(
+				api.utils.parseQueryString( urlParser.search.substr( 1 ) ),
+				{
+					theme: themeId,
+					changeset_uuid: api.settings.changeset.uuid
+				}
+			) );
+
+			overlay = $( '.wp-full-overlay' );
+			overlay.addClass( 'customize-loading' );
+
+			onceProcessingComplete = function() {
+				var request;
+				if ( api.state( 'processing' ).get() > 0 ) {
+					return;
+				}
+
+				api.state( 'processing' ).unbind( onceProcessingComplete );
+
+				request = api.requestChangesetUpdate();
+				request.done( function() {
+					$( window ).off( 'beforeunload.customize-confirm' );
+					window.location.href = urlParser.href;
+				} );
+				request.fail( function() {
+					overlay.removeClass( 'customize-loading' );
+				} );
+			};
+
+			if ( 0 === api.state( 'processing' ).get() ) {
+				onceProcessingComplete();
+			} else {
+				api.state( 'processing' ).bind( onceProcessingComplete );
+			}
+
+			return deferred.promise();
+		},
+
 		/**
 		 * Render & show the theme details for a given theme model.
 		 *
@@ -1223,7 +1447,7 @@
 		 * @param {Object}   theme
 		 */
 		showDetails: function ( theme, callback ) {
-			var section = this;
+			var section = this, link;
 			callback = callback || function(){};
 			section.currentTheme = theme.id;
 			section.overlay.html( section.template( theme ) )
@@ -1232,6 +1456,22 @@
 			$( 'body' ).addClass( 'modal-open' );
 			section.containFocus( section.overlay );
 			section.updateLimits();
+
+			link = section.overlay.find( '.inactive-theme > a' );
+
+			link.on( 'click', function( event ) {
+				event.preventDefault();
+
+				// Short-circuit if request is currently being made.
+				if ( link.hasClass( 'disabled' ) ) {
+					return;
+				}
+				link.addClass( 'disabled' );
+
+				section.loadThemePreview( theme.id ).fail( function() {
+					link.removeClass( 'disabled' );
+				} );
+			} );
 			callback();
 		},
 
@@ -2227,7 +2467,7 @@
 			wp.ajax.post( 'custom-background-add', {
 				nonce: _wpCustomizeBackground.nonces.add,
 				wp_customize: 'on',
-				theme: api.settings.theme.stylesheet,
+				customize_theme: api.settings.theme.stylesheet,
 				attachment_id: this.params.attachment.id
 			} );
 		}
@@ -2592,7 +2832,7 @@
 
 			// Ensure custom-header-crop Ajax requests bootstrap the Customizer to activate the previewed theme.
 			wp.media.controller.Cropper.prototype.defaults.doCropArgs.wp_customize = 'on';
-			wp.media.controller.Cropper.prototype.defaults.doCropArgs.theme = api.settings.theme.stylesheet;
+			wp.media.controller.Cropper.prototype.defaults.doCropArgs.customize_theme = api.settings.theme.stylesheet;
 		},
 
 		/**
@@ -2883,11 +3123,7 @@
 					return;
 				}
 
-				var previewUrl = $( this ).data( 'previewUrl' );
-
-				$( '.wp-full-overlay' ).addClass( 'customize-loading' );
-
-				window.parent.location = previewUrl;
+				api.section( control.section() ).loadThemePreview( control.params.theme.id );
 			});
 
 			control.container.on( 'click keydown', '.theme-actions .theme-details', function( event ) {
@@ -2948,13 +3184,12 @@
 	 * @mixes wp.customize.Events
 	 */
 	api.PreviewFrame = api.Messenger.extend({
-		sensitivity: 2000,
+		sensitivity: null, // Will get set to api.settings.timeouts.previewFrameSensitivity.
 
 		/**
 		 * Initialize the PreviewFrame.
 		 *
 		 * @param {object} params.container
-		 * @param {object} params.signature
 		 * @param {object} params.previewUrl
 		 * @param {object} params.query
 		 * @param {object} options
@@ -2969,7 +3204,6 @@
 			deferred.promise( this );
 
 			this.container = params.container;
-			this.signature = params.signature;
 
 			$.extend( params, { channel: api.PreviewFrame.uuid() });
 
@@ -2989,143 +3223,118 @@
 		 *                          the request.
 		 */
 		run: function( deferred ) {
-			var self   = this,
+			var previewFrame = this,
 				loaded = false,
-				ready  = false;
+				ready = false,
+				readyData = null,
+				hasPendingChangesetUpdate = '{}' !== previewFrame.query.customized,
+				urlParser,
+				params,
+				form;
 
-			if ( this._ready ) {
-				this.unbind( 'ready', this._ready );
+			if ( previewFrame._ready ) {
+				previewFrame.unbind( 'ready', previewFrame._ready );
 			}
 
-			this._ready = function() {
+			previewFrame._ready = function( data ) {
 				ready = true;
-
-				if ( loaded ) {
-					deferred.resolveWith( self );
-				}
-			};
-
-			this.bind( 'ready', this._ready );
-
-			this.bind( 'ready', function ( data ) {
-
-				this.container.addClass( 'iframe-ready' );
-
+				readyData = data;
+				previewFrame.container.addClass( 'iframe-ready' );
 				if ( ! data ) {
 					return;
 				}
 
-				/*
-				 * Walk over all panels, sections, and controls and set their
-				 * respective active states to true if the preview explicitly
-				 * indicates as such.
-				 */
-				var constructs = {
-					panel: data.activePanels,
-					section: data.activeSections,
-					control: data.activeControls
-				};
-				_( constructs ).each( function ( activeConstructs, type ) {
-					api[ type ].each( function ( construct, id ) {
-						var isDynamicallyCreated = _.isUndefined( api.settings[ type + 's' ][ id ] );
+				if ( loaded ) {
+					deferred.resolveWith( previewFrame, [ data ] );
+				}
+			};
 
-						/*
-						 * If the construct was created statically in PHP (not dynamically in JS)
-						 * then consider a missing (undefined) value in the activeConstructs to
-						 * mean it should be deactivated (since it is gone). But if it is
-						 * dynamically created then only toggle activation if the value is defined,
-						 * as this means that the construct was also then correspondingly
-						 * created statically in PHP and the active callback is available.
-						 * Otherwise, dynamically-created constructs should normally have
-						 * their active states toggled in JS rather than from PHP.
-						 */
-						if ( ! isDynamicallyCreated || ! _.isUndefined( activeConstructs[ id ] ) ) {
-							if ( activeConstructs[ id ] ) {
-								construct.activate();
-							} else {
-								construct.deactivate();
-							}
-						}
-					} );
+			previewFrame.bind( 'ready', previewFrame._ready );
+
+			urlParser = document.createElement( 'a' );
+			urlParser.href = previewFrame.previewUrl();
+
+			params = _.extend(
+				api.utils.parseQueryString( urlParser.search.substr( 1 ) ),
+				{
+					customize_changeset_uuid: previewFrame.query.customize_changeset_uuid,
+					customize_theme: previewFrame.query.customize_theme,
+					customize_messenger_channel: previewFrame.query.customize_messenger_channel
+				}
+			);
+
+			urlParser.search = $.param( params );
+			previewFrame.iframe = $( '<iframe />', {
+				title: api.l10n.previewIframeTitle,
+				name: 'customize-' + previewFrame.channel()
+			} );
+			previewFrame.iframe.attr( 'onmousewheel', '' ); // Workaround for Safari bug. See WP Trac #38149.
+
+			if ( ! hasPendingChangesetUpdate ) {
+				previewFrame.iframe.attr( 'src', urlParser.href );
+			} else {
+				previewFrame.iframe.attr( 'data-src', urlParser.href ); // For debugging purposes.
+			}
+
+			previewFrame.iframe.appendTo( previewFrame.container );
+			previewFrame.targetWindow( previewFrame.iframe[0].contentWindow );
+
+			/*
+			 * Submit customized data in POST request to preview frame window since
+			 * there are setting value changes not yet written to changeset.
+			 */
+			if ( hasPendingChangesetUpdate ) {
+				form = $( '<form>', {
+					action: urlParser.href,
+					target: previewFrame.iframe.attr( 'name' ),
+					method: 'post',
+					hidden: 'hidden'
 				} );
+				form.append( $( '<input>', {
+					type: 'hidden',
+					name: '_method',
+					value: 'GET'
+				} ) );
+				_.each( previewFrame.query, function( value, key ) {
+					form.append( $( '<input>', {
+						type: 'hidden',
+						name: key,
+						value: value
+					} ) );
+				} );
+				previewFrame.container.append( form );
+				form.submit();
+				form.remove(); // No need to keep the form around after submitted.
+			}
 
-				if ( data.settingValidities ) {
-					api._handleSettingValidities( {
-						settingValidities: data.settingValidities,
-						focusInvalidControl: false
-					} );
-				}
-			} );
-
-			this.request = $.ajax( this.previewUrl(), {
-				type: 'POST',
-				data: this.query,
-				xhrFields: {
-					withCredentials: true
-				}
-			} );
-
-			this.request.fail( function() {
-				deferred.rejectWith( self, [ 'request failure' ] );
-			});
-
-			this.request.done( function( response ) {
-				var location = self.request.getResponseHeader('Location'),
-					signature = self.signature,
-					index;
-
-				// Check if the location response header differs from the current URL.
-				// If so, the request was redirected; try loading the requested page.
-				if ( location && location !== self.previewUrl() ) {
-					deferred.rejectWith( self, [ 'redirect', location ] );
-					return;
-				}
+			previewFrame.bind( 'iframe-loading-error', function( error ) {
+				previewFrame.iframe.remove();
 
 				// Check if the user is not logged in.
-				if ( '0' === response ) {
-					self.login( deferred );
+				if ( 0 === error ) {
+					previewFrame.login( deferred );
 					return;
 				}
 
 				// Check for cheaters.
-				if ( '-1' === response ) {
-					deferred.rejectWith( self, [ 'cheatin' ] );
+				if ( -1 === error ) {
+					deferred.rejectWith( previewFrame, [ 'cheatin' ] );
 					return;
 				}
 
-				// Check for a signature in the request.
-				index = response.lastIndexOf( signature );
-				if ( -1 === index || index < response.lastIndexOf('</html>') ) {
-					deferred.rejectWith( self, [ 'unsigned' ] );
-					return;
+				deferred.rejectWith( previewFrame, [ 'request failure' ] );
+			} );
+
+			previewFrame.iframe.one( 'load', function() {
+				loaded = true;
+
+				if ( ready ) {
+					deferred.resolveWith( previewFrame, [ readyData ] );
+				} else {
+					setTimeout( function() {
+						deferred.rejectWith( previewFrame, [ 'ready timeout' ] );
+					}, previewFrame.sensitivity );
 				}
-
-				// Strip the signature from the request.
-				response = response.slice( 0, index ) + response.slice( index + signature.length );
-
-				// Create the iframe and inject the html content.
-				self.iframe = $( '<iframe />', { 'title': api.l10n.previewIframeTitle } ).appendTo( self.container );
-				self.iframe.attr( 'onmousewheel', '' ); // Workaround for Safari bug. See WP Trac #38149.
-
-				// Bind load event after the iframe has been added to the page;
-				// otherwise it will fire when injected into the DOM.
-				self.iframe.one( 'load', function() {
-					loaded = true;
-
-					if ( ready ) {
-						deferred.resolveWith( self );
-					} else {
-						setTimeout( function() {
-							deferred.rejectWith( self, [ 'ready timeout' ] );
-						}, self.sensitivity );
-					}
-				});
-
-				self.targetWindow( self.iframe[0].contentWindow );
-
-				self.targetWindow().document.open();
-				self.targetWindow().document.write( response );
-				self.targetWindow().document.close();
 			});
 		},
 
@@ -3164,26 +3373,29 @@
 
 		destroy: function() {
 			api.Messenger.prototype.destroy.call( this );
-			this.request.abort();
 
-			if ( this.iframe )
+			if ( this.iframe ) {
 				this.iframe.remove();
+			}
 
-			delete this.request;
 			delete this.iframe;
 			delete this.targetWindow;
 		}
 	});
 
 	(function(){
-		var uuid = 0;
+		var id = 0;
 		/**
-		 * Create a universally unique identifier.
+		 * Return an incremented ID for a preview messenger channel.
 		 *
-		 * @return {int}
+		 * This function is named "uuid" for historical reasons, but it is a
+		 * misnomer as it is not an actual UUID, and it is not universally unique.
+		 * This is not to be confused with `api.settings.changeset.uuid`.
+		 *
+		 * @return {string}
 		 */
 		api.PreviewFrame.uuid = function() {
-			return 'preview-' + uuid++;
+			return 'preview-' + String( id++ );
 		};
 	}());
 
@@ -3209,7 +3421,7 @@
 	 * @mixes wp.customize.Events
 	 */
 	api.Previewer = api.Messenger.extend({
-		refreshBuffer: 250,
+		refreshBuffer: null, // Will get set to api.settings.timeouts.windowRefresh.
 
 		/**
 		 * @param {array}  params.allowedUrls
@@ -3217,64 +3429,50 @@
 		 *                                    frame to be placed.
 		 * @param {string} params.form
 		 * @param {string} params.previewUrl  The URL to preview.
-		 * @param {string} params.signature
 		 * @param {object} options
 		 */
 		initialize: function( params, options ) {
-			var self = this,
-				rscheme = /^https?/;
+			var previewer = this,
+				urlParser = document.createElement( 'a' );
 
-			$.extend( this, options || {} );
-			this.deferred = {
+			$.extend( previewer, options || {} );
+			previewer.deferred = {
 				active: $.Deferred()
 			};
 
-			/*
-			 * Wrap this.refresh to prevent it from hammering the servers:
-			 *
-			 * If refresh is called once and no other refresh requests are
-			 * loading, trigger the request immediately.
-			 *
-			 * If refresh is called while another refresh request is loading,
-			 * debounce the refresh requests:
-			 * 1. Stop the loading request (as it is instantly outdated).
-			 * 2. Trigger the new request once refresh hasn't been called for
-			 *    self.refreshBuffer milliseconds.
-			 */
-			this.refresh = (function( self ) {
-				var refresh  = self.refresh,
-					callback = function() {
-						timeout = null;
-						refresh.call( self );
-					},
-					timeout;
-
-				return function() {
-					if ( typeof timeout !== 'number' ) {
-						if ( self.loading ) {
-							self.abort();
+			// Debounce to prevent hammering server and then wait for any pending update requests.
+			previewer.refresh = _.debounce(
+				( function( originalRefresh ) {
+					return function() {
+						var isProcessingComplete, refreshOnceProcessingComplete;
+						isProcessingComplete = function() {
+							return 0 === api.state( 'processing' ).get();
+						};
+						if ( isProcessingComplete() ) {
+							originalRefresh.call( previewer );
 						} else {
-							return callback();
+							refreshOnceProcessingComplete = function() {
+								if ( isProcessingComplete() ) {
+									originalRefresh.call( previewer );
+									api.state( 'processing' ).unbind( refreshOnceProcessingComplete );
+								}
+							};
+							api.state( 'processing' ).bind( refreshOnceProcessingComplete );
 						}
-					}
+					};
+				}( previewer.refresh ) ),
+				previewer.refreshBuffer
+			);
 
-					clearTimeout( timeout );
-					timeout = setTimeout( callback, self.refreshBuffer );
-				};
-			})( this );
-
-			this.container   = api.ensure( params.container );
-			this.allowedUrls = params.allowedUrls;
-			this.signature   = params.signature;
+			previewer.container   = api.ensure( params.container );
+			previewer.allowedUrls = params.allowedUrls;
 
 			params.url = window.location.href;
 
-			api.Messenger.prototype.initialize.call( this, params );
+			api.Messenger.prototype.initialize.call( previewer, params );
 
-			this.add( 'scheme', this.origin() ).link( this.origin ).setter( function( to ) {
-				var match = to.match( rscheme );
-				return match ? match[0] : '';
-			});
+			urlParser.href = previewer.origin();
+			previewer.add( 'scheme', urlParser.protocol.replace( /:$/, '' ) );
 
 			// Limit the URL to internal, front-end links.
 			//
@@ -3284,8 +3482,8 @@
 			// are on different domains to avoid the case where the front end doesn't have
 			// ssl certs.
 
-			this.add( 'previewUrl', params.previewUrl ).setter( function( to ) {
-				var result, urlParser;
+			previewer.add( 'previewUrl', params.previewUrl ).setter( function( to ) {
+				var result, urlParser, newPreviewUrl, schemeMatchingPreviewUrl, queryParams;
 				urlParser = document.createElement( 'a' );
 				urlParser.href = to;
 
@@ -3294,10 +3492,27 @@
 					return null;
 				}
 
+				// Remove state query params.
+				if ( urlParser.search.length > 1 ) {
+					queryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
+					delete queryParams.customize_changeset_uuid;
+					delete queryParams.customize_theme;
+					delete queryParams.customize_messenger_channel;
+					if ( _.isEmpty( queryParams ) ) {
+						urlParser.search = '';
+					} else {
+						urlParser.search = $.param( queryParams );
+					}
+				}
+
+				newPreviewUrl = urlParser.href;
+				urlParser.protocol = previewer.scheme.get() + ':';
+				schemeMatchingPreviewUrl = urlParser.href;
+
 				// Attempt to match the URL to the control frame's scheme
 				// and check if it's allowed. If not, try the original URL.
-				$.each([ to.replace( rscheme, self.scheme() ), to ], function( i, url ) {
-					$.each( self.allowedUrls, function( i, allowed ) {
+				$.each( [ schemeMatchingPreviewUrl, newPreviewUrl ], function( i, url ) {
+					$.each( previewer.allowedUrls, function( i, allowed ) {
 						var path;
 
 						allowed = allowed.replace( /\/+$/, '' );
@@ -3308,31 +3523,172 @@
 							return false;
 						}
 					});
-					if ( result )
+					if ( result ) {
 						return false;
+					}
 				});
 
 				// If we found a matching result, return it. If not, bail.
 				return result ? result : null;
 			});
 
-			// Refresh the preview when the URL is changed (but not yet).
-			this.previewUrl.bind( this.refresh );
+			previewer.bind( 'ready', previewer.ready );
 
-			this.scroll = 0;
-			this.bind( 'scroll', function( distance ) {
-				this.scroll = distance;
+			// Start listening for keep-alive messages when iframe first loads.
+			previewer.deferred.active.done( _.bind( previewer.keepPreviewAlive, previewer ) );
+
+			previewer.bind( 'synced', function() {
+				previewer.send( 'active' );
+			} );
+
+			// Refresh the preview when the URL is changed (but not yet).
+			previewer.previewUrl.bind( previewer.refresh );
+
+			previewer.scroll = 0;
+			previewer.bind( 'scroll', function( distance ) {
+				previewer.scroll = distance;
 			});
 
-			// Update the URL when the iframe sends a URL message.
-			this.bind( 'url', this.previewUrl );
+			// Update the URL when the iframe sends a URL message, resetting scroll position. If URL is unchanged, then refresh.
+			previewer.bind( 'url', function( url ) {
+				var onUrlChange, urlChanged = false;
+				previewer.scroll = 0;
+				onUrlChange = function() {
+					urlChanged = true;
+				};
+				previewer.previewUrl.bind( onUrlChange );
+				previewer.previewUrl.set( url );
+				previewer.previewUrl.unbind( onUrlChange );
+				if ( ! urlChanged ) {
+					previewer.refresh();
+				}
+			} );
 
 			// Update the document title when the preview changes.
-			this.bind( 'documentTitle', function ( title ) {
+			previewer.bind( 'documentTitle', function ( title ) {
 				api.setDocumentTitle( title );
 			} );
 		},
 
+		/**
+		 * Handle the preview receiving the ready message.
+		 *
+		 * @since 4.7.0
+		 *
+		 * @param {object} data - Data from preview.
+		 * @param {string} data.currentUrl - Current URL.
+		 * @param {object} data.activePanels - Active panels.
+		 * @param {object} data.activeSections Active sections.
+		 * @param {object} data.activeControls Active controls.
+		 * @returns {void}
+		 */
+		ready: function( data ) {
+			var previewer = this, synced = {}, constructs;
+
+			synced.settings = api.get();
+			if ( 'resolved' !== previewer.deferred.active.state() || previewer.loading ) {
+				synced.scroll = previewer.scroll;
+			}
+			previewer.send( 'sync', synced );
+
+			// Set the previewUrl without causing the url to set the iframe.
+			if ( data.currentUrl ) {
+				previewer.previewUrl.unbind( previewer.refresh );
+				previewer.previewUrl.set( data.currentUrl );
+				previewer.previewUrl.bind( previewer.refresh );
+			}
+
+			/*
+			 * Walk over all panels, sections, and controls and set their
+			 * respective active states to true if the preview explicitly
+			 * indicates as such.
+			 */
+			constructs = {
+				panel: data.activePanels,
+				section: data.activeSections,
+				control: data.activeControls
+			};
+			_( constructs ).each( function ( activeConstructs, type ) {
+				api[ type ].each( function ( construct, id ) {
+					var isDynamicallyCreated = _.isUndefined( api.settings[ type + 's' ][ id ] );
+
+					/*
+					 * If the construct was created statically in PHP (not dynamically in JS)
+					 * then consider a missing (undefined) value in the activeConstructs to
+					 * mean it should be deactivated (since it is gone). But if it is
+					 * dynamically created then only toggle activation if the value is defined,
+					 * as this means that the construct was also then correspondingly
+					 * created statically in PHP and the active callback is available.
+					 * Otherwise, dynamically-created constructs should normally have
+					 * their active states toggled in JS rather than from PHP.
+					 */
+					if ( ! isDynamicallyCreated || ! _.isUndefined( activeConstructs[ id ] ) ) {
+						if ( activeConstructs[ id ] ) {
+							construct.activate();
+						} else {
+							construct.deactivate();
+						}
+					}
+				} );
+			} );
+
+			if ( data.settingValidities ) {
+				api._handleSettingValidities( {
+					settingValidities: data.settingValidities,
+					focusInvalidControl: false
+				} );
+			}
+		},
+
+		/**
+		 * Keep the preview alive by listening for ready and keep-alive messages.
+		 *
+		 * If a message is not received in the allotted time then the iframe will be set back to the last known valid URL.
+		 *
+		 * @since 4.7.0
+		 *
+		 * @returns {void}
+		 */
+		keepPreviewAlive: function keepPreviewAlive() {
+			var previewer = this, keepAliveTick, timeoutId, handleMissingKeepAlive, scheduleKeepAliveCheck;
+
+			/**
+			 * Schedule a preview keep-alive check.
+			 *
+			 * Note that if a page load takes longer than keepAliveCheck milliseconds,
+			 * the keep-alive messages will still be getting sent from the previous
+			 * URL.
+			 */
+			scheduleKeepAliveCheck = function() {
+				timeoutId = setTimeout( handleMissingKeepAlive, api.settings.timeouts.keepAliveCheck );
+			};
+
+			/**
+			 * Set the previewerAlive state to true when receiving a message from the preview.
+			 */
+			keepAliveTick = function() {
+				api.state( 'previewerAlive' ).set( true );
+				clearTimeout( timeoutId );
+				scheduleKeepAliveCheck();
+			};
+
+			/**
+			 * Set the previewerAlive state to false if keepAliveCheck milliseconds have transpired without a message.
+			 *
+			 * This is most likely to happen in the case of a connectivity error, or if the theme causes the browser
+			 * to navigate to a non-allowed URL. Setting this state to false will force settings with a postMessage
+			 * transport to use refresh instead, causing the preview frame also to be replaced with the current
+			 * allowed preview URL.
+			 */
+			handleMissingKeepAlive = function() {
+				api.state( 'previewerAlive' ).set( false );
+			};
+			scheduleKeepAliveCheck();
+
+			previewer.bind( 'ready', keepAliveTick );
+			previewer.bind( 'keep-alive', keepAliveTick );
+		},
+
 		/**
 		 * Query string data sent with each preview request.
 		 *
@@ -3348,62 +3704,59 @@
 		},
 
 		/**
-		 * Refresh the preview.
+		 * Refresh the preview seamlessly.
 		 */
 		refresh: function() {
-			var self = this;
+			var previewer = this;
 
 			// Display loading indicator
-			this.send( 'loading-initiated' );
+			previewer.send( 'loading-initiated' );
 
-			this.abort();
+			previewer.abort();
 
-			this.loading = new api.PreviewFrame({
-				url:        this.url(),
-				previewUrl: this.previewUrl(),
-				query:      this.query() || {},
-				container:  this.container,
-				signature:  this.signature
+			previewer.loading = new api.PreviewFrame({
+				url:        previewer.url(),
+				previewUrl: previewer.previewUrl(),
+				query:      previewer.query( { excludeCustomizedSaved: true } ) || {},
+				container:  previewer.container
 			});
 
-			this.loading.done( function() {
-				// 'this' is the loading frame
-				this.bind( 'synced', function() {
-					if ( self.preview )
-						self.preview.destroy();
-					self.preview = this;
-					delete self.loading;
+			previewer.loading.done( function( readyData ) {
+				var loadingFrame = this, previousPreview, onceSynced;
 
-					self.targetWindow( this.targetWindow() );
-					self.channel( this.channel() );
+				previousPreview = previewer.preview;
+				previewer.preview = loadingFrame;
+				previewer.targetWindow( loadingFrame.targetWindow() );
+				previewer.channel( loadingFrame.channel() );
 
-					self.deferred.active.resolve();
-					self.send( 'active' );
-				});
+				onceSynced = function() {
+					loadingFrame.unbind( 'synced', onceSynced );
+					if ( previousPreview ) {
+						previousPreview.destroy();
+					}
+					previewer.deferred.active.resolve();
+					delete previewer.loading;
+				};
+				loadingFrame.bind( 'synced', onceSynced );
 
-				this.send( 'sync', {
-					scroll:   self.scroll,
-					settings: api.get()
-				});
+				// This event will be received directly by the previewer in normal navigation; this is only needed for seamless refresh.
+				previewer.trigger( 'ready', readyData );
 			});
 
-			this.loading.fail( function( reason, location ) {
-				self.send( 'loading-failed' );
-				if ( 'redirect' === reason && location ) {
-					self.previewUrl( location );
-				}
+			previewer.loading.fail( function( reason ) {
+				previewer.send( 'loading-failed' );
 
 				if ( 'logged out' === reason ) {
-					if ( self.preview ) {
-						self.preview.destroy();
-						delete self.preview;
+					if ( previewer.preview ) {
+						previewer.preview.destroy();
+						delete previewer.preview;
 					}
 
-					self.login().done( self.refresh );
+					previewer.login().done( previewer.refresh );
 				}
 
 				if ( 'cheatin' === reason ) {
-					self.cheatin();
+					previewer.cheatin();
 				}
 			});
 		},
@@ -3463,7 +3816,7 @@
 
 			request = wp.ajax.post( 'customize_refresh_nonces', {
 				wp_customize: 'on',
-				theme: api.settings.theme.stylesheet
+				customize_theme: api.settings.theme.stylesheet
 			});
 
 			request.done( function( response ) {
@@ -3679,6 +4032,13 @@
 			return;
 		}
 
+		if ( null === api.PreviewFrame.prototype.sensitivity ) {
+			api.PreviewFrame.prototype.sensitivity = api.settings.timeouts.previewFrameSensitivity;
+		}
+		if ( null === api.Previewer.prototype.refreshBuffer ) {
+			api.Previewer.prototype.refreshBuffer = api.settings.timeouts.windowRefresh;
+		}
+
 		var parent,
 			body = $( document.body ),
 			overlay = body.children( '.wp-full-overlay' ),
@@ -3722,8 +4082,7 @@
 			container:   '#customize-preview',
 			form:        '#customize-controls',
 			previewUrl:  api.settings.url.preview,
-			allowedUrls: api.settings.url.allowed,
-			signature:   'WP_CUSTOMIZER_SIGNATURE'
+			allowedUrls: api.settings.url.allowed
 		}, {
 
 			nonce: api.settings.nonce,
@@ -3731,26 +4090,51 @@
 			/**
 			 * Build the query to send along with the Preview request.
 			 *
-			 * @return {object}
+			 * @since 4.7.0 Added options param.
+			 *
+			 * @param {object}  [options] Options.
+			 * @param {boolean} [options.excludeCustomizedSaved=false] Exclude saved settings in customized response (values pending writing to changeset).
+			 * @return {object} Query vars.
 			 */
-			query: function() {
-				var dirtyCustomized = {};
-				api.each( function ( value, key ) {
-					if ( value._dirty ) {
-						dirtyCustomized[ key ] = value();
-					}
-				} );
-
-				return {
+			query: function( options ) {
+				var queryVars = {
 					wp_customize: 'on',
-					theme:      api.settings.theme.stylesheet,
-					customized: JSON.stringify( dirtyCustomized ),
-					nonce:      this.nonce.preview
+					customize_theme: api.settings.theme.stylesheet,
+					nonce: this.nonce.preview,
+					customize_changeset_uuid: api.settings.changeset.uuid
 				};
+
+				/*
+				 * Exclude customized data if requested especially for calls to requestChangesetUpdate.
+				 * Changeset updates are differential and so it is a performance waste to send all of
+				 * the dirty settings with each update.
+				 */
+				queryVars.customized = JSON.stringify( api.dirtyValues( {
+					unsaved: options && options.excludeCustomizedSaved
+				} ) );
+
+				return queryVars;
 			},
 
-			save: function() {
-				var self = this,
+			/**
+			 * Save (and publish) the customizer changeset.
+			 *
+			 * Updates to the changeset are transactional. If any of the settings
+			 * are invalid then none of them will be written into the changeset.
+			 * A revision will be made for the changeset post if revisions support
+			 * has been added to the post type.
+			 *
+			 * @param {object} [args] Args.
+			 * @param {string} [args.status=publish] Status.
+			 * @param {string} [args.date] Date, in local time in MySQL format.
+			 * @param {string} [args.title] Title
+			 *
+			 * @returns {jQuery.promise}
+			 */
+			save: function( args ) {
+				var previewer = this,
+					deferred = $.Deferred(),
+					changesetStatus = 'publish',
 					processing = api.state( 'processing' ),
 					submitWhenDoneProcessing,
 					submit,
@@ -3758,7 +4142,16 @@
 					invalidSettings = [],
 					invalidControls;
 
-				body.addClass( 'saving' );
+				if ( args && args.status ) {
+					changesetStatus = args.status;
+				}
+
+				if ( api.state( 'saving' ).get() ) {
+					deferred.reject( 'already_saving' );
+					deferred.promise();
+				}
+
+				api.state( 'saving' ).set( true );
 
 				function captureSettingModifiedDuringSave( setting ) {
 					modifiedWhileSaving[ setting.id ] = true;
@@ -3766,7 +4159,7 @@
 				api.bind( 'change', captureSettingModifiedDuringSave );
 
 				submit = function () {
-					var request, query;
+					var request, query, settingInvalidities = {};
 
 					/*
 					 * Block saving if there are any settings that are marked as
@@ -3777,20 +4170,50 @@
 						setting.notifications.each( function( notification ) {
 							if ( 'error' === notification.type && ! notification.fromServer ) {
 								invalidSettings.push( setting.id );
+								if ( ! settingInvalidities[ setting.id ] ) {
+									settingInvalidities[ setting.id ] = {};
+								}
+								settingInvalidities[ setting.id ][ notification.code ] = notification;
 							}
 						} );
 					} );
 					invalidControls = api.findControlsForSettings( invalidSettings );
 					if ( ! _.isEmpty( invalidControls ) ) {
 						_.values( invalidControls )[0][0].focus();
-						body.removeClass( 'saving' );
 						api.unbind( 'change', captureSettingModifiedDuringSave );
-						return;
+						deferred.rejectWith( previewer, [
+							{ setting_invalidities: settingInvalidities }
+						] );
+						api.state( 'saving' ).set( false );
+						return deferred.promise();
 					}
 
-					query = $.extend( self.query(), {
-						nonce:  self.nonce.save
+					/*
+					 * Note that excludeCustomizedSaved is intentionally false so that the entire
+					 * set of customized data will be included if bypassed changeset update.
+					 */
+					query = $.extend( previewer.query( { excludeCustomizedSaved: false } ), {
+						nonce: previewer.nonce.save,
+						customize_changeset_status: changesetStatus
 					} );
+					if ( args && args.date ) {
+						query.customize_changeset_date = args.date;
+					}
+					if ( args && args.title ) {
+						query.customize_changeset_title = args.title;
+					}
+
+					/*
+					 * Note that the dirty customized values will have already been set in the
+					 * changeset and so technically query.customized could be deleted. However,
+					 * it is remaining here to make sure that any settings that got updated
+					 * quietly which may have not triggered an update request will also get
+					 * included in the values that get saved to the changeset. This will ensure
+					 * that values that get injected via the saved event will be included in
+					 * the changeset. This also ensures that setting values that were invalid
+					 * will get re-validated, perhaps in the case of settings that are invalid
+					 * due to dependencies on other settings.
+					 */
 					request = wp.ajax.post( 'customize_save', query );
 
 					// Disable save button during the save request.
@@ -3799,12 +4222,13 @@
 					api.trigger( 'save', request );
 
 					request.always( function () {
-						body.removeClass( 'saving' );
+						api.state( 'saving' ).set( false );
 						saveBtn.prop( 'disabled', false );
 						api.unbind( 'change', captureSettingModifiedDuringSave );
 					} );
 
 					request.fail( function ( response ) {
+
 						if ( '0' === response ) {
 							response = 'not_logged_in';
 						} else if ( '-1' === response ) {
@@ -3813,12 +4237,12 @@
 						}
 
 						if ( 'invalid_nonce' === response ) {
-							self.cheatin();
+							previewer.cheatin();
 						} else if ( 'not_logged_in' === response ) {
-							self.preview.iframe.hide();
-							self.login().done( function() {
-								self.save();
-								self.preview.iframe.show();
+							previewer.preview.iframe.hide();
+							previewer.login().done( function() {
+								previewer.save();
+								previewer.preview.iframe.show();
 							} );
 						}
 
@@ -3829,19 +4253,20 @@
 							} );
 						}
 
+						deferred.rejectWith( previewer, [ response ] );
 						api.trigger( 'error', response );
 					} );
 
 					request.done( function( response ) {
 
-						// Clear setting dirty states, if setting wasn't modified while saving.
-						api.each( function( setting ) {
-							if ( ! modifiedWhileSaving[ setting.id ] ) {
-								setting._dirty = false;
-							}
-						} );
+						previewer.send( 'saved', response );
 
-						api.previewer.send( 'saved', response );
+						api.state( 'changesetStatus' ).set( response.changeset_status );
+						if ( 'publish' === response.changeset_status ) {
+							api.state( 'changesetStatus' ).set( '' );
+							api.settings.changeset.uuid = response.next_changeset_uuid;
+							parent.send( 'changeset-uuid', api.settings.changeset.uuid );
+						}
 
 						if ( response.setting_validities ) {
 							api._handleSettingValidities( {
@@ -3850,6 +4275,7 @@
 							} );
 						}
 
+						deferred.resolveWith( previewer, [ response ] );
 						api.trigger( 'saved', response );
 
 						// Restore the global dirty state if any settings were modified during save.
@@ -3871,6 +4297,7 @@
 					api.state.bind( 'change', submitWhenDoneProcessing );
 				}
 
+				return deferred.promise();
 			}
 		});
 
@@ -3957,55 +4384,71 @@
 
 		api.bind( 'ready', api.reflowPaneContents );
 		$( [ api.panel, api.section, api.control ] ).each( function ( i, values ) {
-			var debouncedReflowPaneContents = _.debounce( api.reflowPaneContents, 100 );
+			var debouncedReflowPaneContents = _.debounce( api.reflowPaneContents, api.settings.timeouts.reflowPaneContents );
 			values.bind( 'add', debouncedReflowPaneContents );
 			values.bind( 'change', debouncedReflowPaneContents );
 			values.bind( 'remove', debouncedReflowPaneContents );
 		} );
 
-		// Check if preview url is valid and load the preview frame.
-		if ( api.previewer.previewUrl() ) {
-			api.previewer.refresh();
-		} else {
-			api.previewer.previewUrl( api.settings.url.home );
-		}
-
 		// Save and activated states
 		(function() {
 			var state = new api.Values(),
 				saved = state.create( 'saved' ),
+				saving = state.create( 'saving' ),
 				activated = state.create( 'activated' ),
 				processing = state.create( 'processing' ),
-				paneVisible = state.create( 'paneVisible' );
+				paneVisible = state.create( 'paneVisible' ),
+				changesetStatus = state.create( 'changesetStatus' ),
+				previewerAlive = state.create( 'previewerAlive' ),
+				populateChangesetUuidParam;
 
 			state.bind( 'change', function() {
+				var canSave;
+
 				if ( ! activated() ) {
-					saveBtn.val( api.l10n.activate ).prop( 'disabled', false );
+					saveBtn.val( api.l10n.activate );
 					closeBtn.find( '.screen-reader-text' ).text( api.l10n.cancel );
 
-				} else if ( saved() ) {
-					saveBtn.val( api.l10n.saved ).prop( 'disabled', true );
+				} else if ( '' === changesetStatus.get() && saved() ) {
+					saveBtn.val( api.l10n.saved );
 					closeBtn.find( '.screen-reader-text' ).text( api.l10n.close );
 
 				} else {
-					saveBtn.val( api.l10n.save ).prop( 'disabled', false );
+					saveBtn.val( api.l10n.save );
 					closeBtn.find( '.screen-reader-text' ).text( api.l10n.cancel );
 				}
+
+				/*
+				 * Save (publish) button should be enabled if saving is not currently happening,
+				 * and if the theme is not active or the changeset exists but is not published.
+				 */
+				canSave = ! saving() && ( ! activated() || ! saved() || ( '' !== changesetStatus() && 'publish' !== changesetStatus() ) );
+
+				saveBtn.prop( 'disabled', ! canSave );
 			});
 
 			// Set default states.
 			saved( true );
+			saving( false );
 			activated( api.settings.theme.active );
 			processing( 0 );
 			paneVisible( true );
+			previewerAlive( true );
+			changesetStatus( api.settings.changeset.status );
 
 			api.bind( 'change', function() {
 				state('saved').set( false );
 			});
 
-			api.bind( 'saved', function() {
+			saving.bind( function( isSaving ) {
+				body.toggleClass( 'saving', isSaving );
+			} );
+
+			api.bind( 'saved', function( response ) {
 				state('saved').set( true );
-				state('activated').set( true );
+				if ( 'publish' === response.changeset_status ) {
+					state( 'activated' ).set( true );
+				}
 			});
 
 			activated.bind( function( to ) {
@@ -4014,10 +4457,48 @@
 				}
 			});
 
+			populateChangesetUuidParam = function( isIncluded ) {
+				var urlParser, queryParams;
+				urlParser = document.createElement( 'a' );
+				urlParser.href = location.href;
+				queryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
+				if ( isIncluded ) {
+					if ( queryParams.changeset_uuid === api.settings.changeset.uuid ) {
+						return;
+					}
+					queryParams.changeset_uuid = api.settings.changeset.uuid;
+				} else {
+					if ( ! queryParams.changeset_uuid ) {
+						return;
+					}
+					delete queryParams.changeset_uuid;
+				}
+				urlParser.search = $.param( queryParams );
+				history.replaceState( {}, document.title, urlParser.href );
+			};
+
+			if ( history.replaceState ) {
+				saved.bind( function( isSaved ) {
+					if ( ! isSaved ) {
+						populateChangesetUuidParam( true );
+					}
+				} );
+				changesetStatus.bind( function( newStatus ) {
+					populateChangesetUuidParam( '' !== newStatus );
+				} );
+			}
+
 			// Expose states to the API.
 			api.state = state;
 		}());
 
+		// Check if preview url is valid and load the preview frame.
+		if ( api.previewer.previewUrl() ) {
+			api.previewer.refresh();
+		} else {
+			api.previewer.previewUrl( api.settings.url.home );
+		}
+
 		// Button bindings.
 		saveBtn.click( function( event ) {
 			api.previewer.save();
@@ -4169,7 +4650,7 @@
 		});
 
 		// Prompt user with AYS dialog if leaving the Customizer with unsaved changes
-		$( window ).on( 'beforeunload', function () {
+		$( window ).on( 'beforeunload.customize-confirm', function () {
 			if ( ! api.state( 'saved' )() ) {
 				setTimeout( function() {
 					overlay.removeClass( 'customize-loading' );
@@ -4190,6 +4671,8 @@
 			parent.send( 'title', newTitle );
 		});
 
+		parent.send( 'changeset-uuid', api.settings.changeset.uuid );
+
 		// Initialize the connection with the parent frame.
 		parent.send( 'ready' );
 
@@ -4292,6 +4775,51 @@
 			api.previewer.refresh();
 		});
 
+		// Autosave changeset.
+		( function() {
+			var timeoutId, updateChangesetWithReschedule, scheduleChangesetUpdate, updatePending = false;
+
+			/**
+			 * Request changeset update and then re-schedule the next changeset update time.
+			 *
+			 * @private
+			 */
+			updateChangesetWithReschedule = function() {
+				if ( ! updatePending ) {
+					updatePending = true;
+					api.requestChangesetUpdate().always( function() {
+						updatePending = false;
+					} );
+				}
+				scheduleChangesetUpdate();
+			};
+
+			/**
+			 * Schedule changeset update.
+			 *
+			 * @private
+			 */
+			scheduleChangesetUpdate = function() {
+				clearTimeout( timeoutId );
+				timeoutId = setTimeout( function() {
+					updateChangesetWithReschedule();
+				}, api.settings.timeouts.changesetAutoSave );
+			};
+
+			// Start auto-save interval for updating changeset.
+			scheduleChangesetUpdate();
+
+			// Save changeset when focus removed from window.
+			$( window ).on( 'blur.wp-customize-changeset-update', function() {
+				updateChangesetWithReschedule();
+			} );
+
+			// Save changeset before unloading window.
+			$( window ).on( 'beforeunload.wp-customize-changeset-update', function() {
+				updateChangesetWithReschedule();
+			} );
+		} ());
+
 		api.trigger( 'ready' );
 	});
 
diff --git a/src/wp-admin/js/customize-widgets.js b/src/wp-admin/js/customize-widgets.js
index 2799b82616..25c1eb5b7a 100644
--- a/src/wp-admin/js/customize-widgets.js
+++ b/src/wp-admin/js/customize-widgets.js
@@ -1154,7 +1154,7 @@
 			params.action = 'update-widget';
 			params.wp_customize = 'on';
 			params.nonce = api.settings.nonce['update-widget'];
-			params.theme = api.settings.theme.stylesheet;
+			params.customize_theme = api.settings.theme.stylesheet;
 			params.customized = wp.customize.previewer.query().customized;
 
 			data = $.param( params );
diff --git a/src/wp-includes/admin-bar.php b/src/wp-includes/admin-bar.php
index e87ac141f2..e95cc4d81b 100644
--- a/src/wp-includes/admin-bar.php
+++ b/src/wp-includes/admin-bar.php
@@ -366,15 +366,30 @@ function wp_admin_bar_site_menu( $wp_admin_bar ) {
  * @since 4.3.0
  *
  * @param WP_Admin_Bar $wp_admin_bar WP_Admin_Bar instance.
+ * @global WP_Customize_Manager $wp_customize
  */
 function wp_admin_bar_customize_menu( $wp_admin_bar ) {
+	global $wp_customize;
+
 	// Don't show for users who can't access the customizer or when in the admin.
 	if ( ! current_user_can( 'customize' ) || is_admin() ) {
 		return;
 	}
 
+	// Don't show if the user cannot edit a given customize_changeset post currently being previewed.
+	if ( is_customize_preview() && $wp_customize->changeset_post_id() && ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->edit_post, $wp_customize->changeset_post_id() ) ) {
+		return;
+	}
+
 	$current_url = ( is_ssl() ? 'https://' : 'http://' ) . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
+	if ( is_customize_preview() && $wp_customize->changeset_uuid() ) {
+		$current_url = remove_query_arg( 'customize_changeset_uuid', $current_url );
+	}
+
 	$customize_url = add_query_arg( 'url', urlencode( $current_url ), wp_customize_url() );
+	if ( is_customize_preview() ) {
+		$customize_url = add_query_arg( array( 'changeset_uuid' => $wp_customize->changeset_uuid() ), $customize_url );
+	}
 
 	$wp_admin_bar->add_menu( array(
 		'id'     => 'customize',
diff --git a/src/wp-includes/class-wp-customize-manager.php b/src/wp-includes/class-wp-customize-manager.php
index 23e319167e..54efcd534b 100644
--- a/src/wp-includes/class-wp-customize-manager.php
+++ b/src/wp-includes/class-wp-customize-manager.php
@@ -129,15 +129,6 @@ final class WP_Customize_Manager {
 	 */
 	protected $controls = array();
 
-	/**
-	 * Return value of check_ajax_referer() in customize_preview_init() method.
-	 *
-	 * @since 3.5.0
-	 * @access protected
-	 * @var false|int
-	 */
-	protected $nonce_tick;
-
 	/**
 	 * Panel types that may be rendered from JS templates.
 	 *
@@ -192,6 +183,15 @@ final class WP_Customize_Manager {
 	 */
 	protected $autofocus = array();
 
+	/**
+	 * Messenger channel.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 * @var string
+	 */
+	protected $messenger_channel;
+
 	/**
 	 * Unsanitized values for Customize Settings parsed from $_POST['customized'].
 	 *
@@ -199,12 +199,76 @@ final class WP_Customize_Manager {
 	 */
 	private $_post_values;
 
+	/**
+	 * Changeset UUID.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 * @var string
+	 */
+	private $_changeset_uuid;
+
+	/**
+	 * Changeset post ID.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 * @var int|false
+	 */
+	private $_changeset_post_id;
+
+	/**
+	 * Changeset data loaded from a customize_changeset post.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 * @var array
+	 */
+	private $_changeset_data;
+
 	/**
 	 * Constructor.
 	 *
 	 * @since 3.4.0
+	 * @since 4.7.0 Added $args param.
+	 *
+	 * @param array $args {
+	 *     Args.
+	 *
+	 *     @type string $changeset_uuid    Changeset UUID, the post_name for the customize_changeset post containing the customized state. Defaults to new UUID.
+	 *     @type string $theme             Theme to be previewed (for theme switch). Defaults to customize_theme or theme query params.
+	 *     @type string $messenger_channel Messenger channel. Defaults to customize_messenger_channel query param.
+	 * }
 	 */
-	public function __construct() {
+	public function __construct( $args = array() ) {
+
+		$args = array_merge(
+			array_fill_keys( array( 'changeset_uuid', 'theme', 'messenger_channel' ), null ),
+			$args
+		);
+
+		// Note that the UUID format will be validated in the setup_theme() method.
+		if ( ! isset( $args['changeset_uuid'] ) ) {
+			$args['changeset_uuid'] = wp_generate_uuid4();
+		}
+
+		// The theme and messenger_channel should be supplied via $args, but they are also looked at in the $_REQUEST global here for back-compat.
+		if ( ! isset( $args['theme'] ) ) {
+			if ( isset( $_REQUEST['customize_theme'] ) ) {
+				$args['theme'] = wp_unslash( $_REQUEST['customize_theme'] );
+			} elseif ( isset( $_REQUEST['theme'] ) ) { // Deprecated.
+				$args['theme'] = wp_unslash( $_REQUEST['theme'] );
+			}
+		}
+		if ( ! isset( $args['messenger_channel'] ) && isset( $_REQUEST['customize_messenger_channel'] ) ) {
+			$args['messenger_channel'] = sanitize_key( wp_unslash( $_REQUEST['customize_messenger_channel'] ) );
+		}
+
+		$this->original_stylesheet = get_stylesheet();
+		$this->theme = wp_get_theme( $args['theme'] );
+		$this->messenger_channel = $args['messenger_channel'];
+		$this->_changeset_uuid = $args['changeset_uuid'];
+
 		require_once( ABSPATH . WPINC . '/class-wp-customize-setting.php' );
 		require_once( ABSPATH . WPINC . '/class-wp-customize-panel.php' );
 		require_once( ABSPATH . WPINC . '/class-wp-customize-section.php' );
@@ -271,14 +335,9 @@ final class WP_Customize_Manager {
 			$this->nav_menus = new WP_Customize_Nav_Menus( $this );
 		}
 
-		add_filter( 'wp_die_handler', array( $this, 'wp_die_handler' ) );
-
 		add_action( 'setup_theme', array( $this, 'setup_theme' ) );
 		add_action( 'wp_loaded',   array( $this, 'wp_loaded' ) );
 
-		// Run wp_redirect_status late to make sure we override the status last.
-		add_action( 'wp_redirect_status', array( $this, 'wp_redirect_status' ), 1000 );
-
 		// Do not spawn cron (especially the alternate cron) while running the Customizer.
 		remove_action( 'init', 'wp_cron' );
 
@@ -340,7 +399,7 @@ final class WP_Customize_Manager {
 	 * @param mixed $message UI message
 	 */
 	protected function wp_die( $ajax_message, $message = null ) {
-		if ( $this->doing_ajax() || isset( $_POST['customized'] ) ) {
+		if ( $this->doing_ajax() ) {
 			wp_die( $ajax_message );
 		}
 
@@ -348,6 +407,29 @@ final class WP_Customize_Manager {
 			$message = __( 'Cheatin&#8217; uh?' );
 		}
 
+		if ( $this->messenger_channel ) {
+			ob_start();
+			wp_enqueue_scripts();
+			wp_print_scripts( array( 'customize-base' ) );
+
+			$settings = array(
+				'messengerArgs' => array(
+					'channel' => $this->messenger_channel,
+					'url' => wp_customize_url(),
+				),
+				'error' => $ajax_message,
+			);
+			?>
+			<script>
+			( function( api, settings ) {
+				var preview = new api.Messenger( settings.messengerArgs );
+				preview.send( 'iframe-loading-error', settings.error );
+			} )( wp.customize, <?php echo wp_json_encode( $settings ) ?> );
+			</script>
+			<?php
+			$message .= ob_get_clean();
+		}
+
 		wp_die( $message );
 	}
 
@@ -355,10 +437,13 @@ final class WP_Customize_Manager {
 	 * Return the Ajax wp_die() handler if it's a customized request.
 	 *
 	 * @since 3.4.0
+	 * @deprecated 4.7.0
 	 *
-	 * @return string
+	 * @return callable Die handler.
 	 */
 	public function wp_die_handler() {
+		_deprecated_function( __METHOD__, '4.7.0' );
+
 		if ( $this->doing_ajax() || isset( $_POST['customized'] ) ) {
 			return '_ajax_wp_die_handler';
 		}
@@ -374,24 +459,43 @@ final class WP_Customize_Manager {
 	 * @since 3.4.0
 	 */
 	public function setup_theme() {
-		send_origin_headers();
+		global $pagenow;
 
-		$doing_ajax_or_is_customized = ( $this->doing_ajax() || isset( $_POST['customized'] ) );
-		if ( is_admin() && ! $doing_ajax_or_is_customized ) {
-			auth_redirect();
-		} elseif ( $doing_ajax_or_is_customized && ! is_user_logged_in() ) {
-			$this->wp_die( 0, __( 'You must be logged in to complete this action.' ) );
+		// Check permissions for customize.php access since this method is called before customize.php can run any code,
+		if ( 'customize.php' === $pagenow && ! current_user_can( 'customize' ) ) {
+			if ( ! is_user_logged_in() ) {
+				auth_redirect();
+			} else {
+				wp_die(
+					'<h1>' . __( 'Cheatin&#8217; uh?' ) . '</h1>' .
+					'<p>' . __( 'Sorry, you are not allowed to customize this site.' ) . '</p>',
+					403
+				);
+			}
+			return;
 		}
 
-		show_admin_bar( false );
-
-		if ( ! current_user_can( 'customize' ) ) {
-			$this->wp_die( -1, __( 'Sorry, you are not allowed to customize this site.' ) );
+		if ( ! preg_match( '/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/', $this->_changeset_uuid ) ) {
+			$this->wp_die( -1, __( 'Invalid changeset UUID' ) );
 		}
 
-		$this->original_stylesheet = get_stylesheet();
+		/*
+		 * If unauthenticated then require a valid changeset UUID to load the preview.
+		 * In this way, the UUID serves as a secret key. If the messenger channel is present,
+		 * then send unauthenticated code to prompt re-auth.
+		 */
+		if ( ! current_user_can( 'customize' ) && ! $this->changeset_post_id() ) {
+			$this->wp_die( $this->messenger_channel ? 0 : -1, __( 'Non-existent changeset UUID.' ) );
+		}
 
-		$this->theme = wp_get_theme( isset( $_REQUEST['theme'] ) ? $_REQUEST['theme'] : null );
+		if ( ! headers_sent() ) {
+			send_origin_headers();
+		}
+
+		// Hide the admin bar if we're embedded in the customizer iframe.
+		if ( $this->messenger_channel ) {
+			show_admin_bar( false );
+		}
 
 		if ( $this->is_theme_active() ) {
 			// Once the theme is loaded, we'll validate it.
@@ -506,6 +610,18 @@ final class WP_Customize_Manager {
 		do_action( 'stop_previewing_theme', $this );
 	}
 
+	/**
+	 * Get the changeset UUID.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @return string UUID.
+	 */
+	public function changeset_uuid() {
+		return $this->_changeset_uuid;
+	}
+
 	/**
 	 * Get the theme being customized.
 	 *
@@ -603,8 +719,23 @@ final class WP_Customize_Manager {
 		 */
 		do_action( 'customize_register', $this );
 
-		if ( $this->is_preview() && ! is_admin() )
+		/*
+		 * Note that settings must be previewed here even outside the customizer preview
+		 * and also in the customizer pane itself. This is to enable loading an existing
+		 * changeset into the customizer. Previewing the settings only has to be prevented
+		 * in the case of a customize_save action because then update_option()
+		 * may short-circuit because it will detect that there are no changes to
+		 * make.
+		 */
+		if ( ! $this->doing_ajax( 'customize_save' ) ) {
+			foreach ( $this->settings as $setting ) {
+				$setting->preview();
+			}
+		}
+
+		if ( $this->is_preview() && ! is_admin() ) {
 			$this->customize_preview_init();
+		}
 	}
 
 	/**
@@ -614,43 +745,224 @@ final class WP_Customize_Manager {
 	 * Instead, the JS will sniff out the location header.
 	 *
 	 * @since 3.4.0
+	 * @deprecated 4.7.0
 	 *
-	 * @param $status
+	 * @param int $status Status.
 	 * @return int
 	 */
 	public function wp_redirect_status( $status ) {
-		if ( $this->is_preview() && ! is_admin() )
+		_deprecated_function( __FUNCTION__, '4.7.0' );
+
+		if ( $this->is_preview() && ! is_admin() ) {
 			return 200;
+		}
 
 		return $status;
 	}
 
 	/**
-	 * Parse the incoming $_POST['customized'] JSON data and store the unsanitized
-	 * settings for subsequent post_value() lookups.
+	 * Find the changeset post ID for a given changeset UUID.
 	 *
-	 * @since 4.1.1
+	 * @since 4.7.0
+	 * @access public
 	 *
-	 * @return array
+	 * @param string $uuid Changeset UUID.
+	 * @return int|null Returns post ID on success and null on failure.
 	 */
-	public function unsanitized_post_values() {
-		if ( ! isset( $this->_post_values ) ) {
-			if ( isset( $_POST['customized'] ) ) {
-				$this->_post_values = json_decode( wp_unslash( $_POST['customized'] ), true );
-			}
-			if ( empty( $this->_post_values ) ) { // if not isset or if JSON error
-				$this->_post_values = array();
-			}
+	public function find_changeset_post_id( $uuid ) {
+		$cache_group = 'customize_changeset_post';
+		$changeset_post_id = wp_cache_get( $uuid, $cache_group );
+		if ( $changeset_post_id && 'customize_changeset' === get_post_type( $changeset_post_id ) ) {
+			return $changeset_post_id;
 		}
-		if ( empty( $this->_post_values ) ) {
-			return array();
-		} else {
-			return $this->_post_values;
+
+		$changeset_post_query = new WP_Query( array(
+			'post_type' => 'customize_changeset',
+			'post_status' => get_post_stati(),
+			'name' => $uuid,
+			'number' => 1,
+			'no_found_rows' => true,
+			'cache_results' => true,
+			'update_post_meta_cache' => false,
+			'update_term_meta_cache' => false,
+		) );
+		if ( ! empty( $changeset_post_query->posts ) ) {
+			// Note: 'fields'=>'ids' is not being used in order to cache the post object as it will be needed.
+			$changeset_post_id = $changeset_post_query->posts[0]->ID;
+			wp_cache_set( $this->_changeset_uuid, $changeset_post_id, $cache_group );
+			return $changeset_post_id;
 		}
+
+		return null;
 	}
 
 	/**
-	 * Returns the sanitized value for a given setting from the request's POST data.
+	 * Get the changeset post id for the loaded changeset.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @return int|null Post ID on success or null if there is no post yet saved.
+	 */
+	public function changeset_post_id() {
+		if ( ! isset( $this->_changeset_post_id ) ) {
+			$post_id = $this->find_changeset_post_id( $this->_changeset_uuid );
+			if ( ! $post_id ) {
+				$post_id = false;
+			}
+			$this->_changeset_post_id = $post_id;
+		}
+		if ( false === $this->_changeset_post_id ) {
+			return null;
+		}
+		return $this->_changeset_post_id;
+	}
+
+	/**
+	 * Get the data stored in a changeset post.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @param int $post_id Changeset post ID.
+	 * @return array|WP_Error Changeset data or WP_Error on error.
+	 */
+	protected function get_changeset_post_data( $post_id ) {
+		if ( ! $post_id ) {
+			return new WP_Error( 'empty_post_id' );
+		}
+		$changeset_post = get_post( $post_id );
+		if ( ! $changeset_post ) {
+			return new WP_Error( 'missing_post' );
+		}
+		if ( 'customize_changeset' !== $changeset_post->post_type ) {
+			return new WP_Error( 'wrong_post_type' );
+		}
+		$changeset_data = json_decode( $changeset_post->post_content, true );
+		if ( function_exists( 'json_last_error' ) && json_last_error() ) {
+			return new WP_Error( 'json_parse_error', '', json_last_error() );
+		}
+		if ( ! is_array( $changeset_data ) ) {
+			return new WP_Error( 'expected_array' );
+		}
+		return $changeset_data;
+	}
+
+	/**
+	 * Get changeset data.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @return array Changeset data.
+	 */
+	public function changeset_data() {
+		if ( isset( $this->_changeset_data ) ) {
+			return $this->_changeset_data;
+		}
+		$changeset_post_id = $this->changeset_post_id();
+		if ( ! $changeset_post_id ) {
+			$this->_changeset_data = array();
+		} else {
+			$data = $this->get_changeset_post_data( $changeset_post_id );
+			if ( ! is_wp_error( $data ) ) {
+				$this->_changeset_data = $data;
+			} else {
+				$this->_changeset_data = array();
+			}
+		}
+		return $this->_changeset_data;
+	}
+
+	/**
+	 * Get dirty pre-sanitized setting values in the current customized state.
+	 *
+	 * The returned array consists of a merge of three sources:
+	 * 1. If the theme is not currently active, then the base array is any stashed
+	 *    theme mods that were modified previously but never published.
+	 * 2. The values from the current changeset, if it exists.
+	 * 3. If the user can customize, the values parsed from the incoming
+	 *    `$_POST['customized']` JSON data.
+	 * 4. Any programmatically-set post values via `WP_Customize_Manager::set_post_value()`.
+	 *
+	 * The name "unsanitized_post_values" is a carry-over from when the customized
+	 * state was exclusively sourced from `$_POST['customized']`. Nevertheless,
+	 * the value returned will come from the current changeset post and from the
+	 * incoming post data.
+	 *
+	 * @since 4.1.1
+	 * @since 4.7.0 Added $args param and merging with changeset values and stashed theme mods.
+	 *
+	 * @param array $args {
+	 *     Args.
+	 *
+	 *     @type bool $exclude_changeset Whether the changeset values should also be excluded. Defaults to false.
+	 *     @type bool $exclude_post_data Whether the post input values should also be excluded. Defaults to false when lacking the customize capability.
+	 * }
+	 * @return array
+	 */
+	public function unsanitized_post_values( $args = array() ) {
+		$args = array_merge(
+			array(
+				'exclude_changeset' => false,
+				'exclude_post_data' => ! current_user_can( 'customize' ),
+			),
+			$args
+		);
+
+		$values = array();
+
+		// Let default values be from the stashed theme mods if doing a theme switch and if no changeset is present.
+		if ( ! $this->is_theme_active() ) {
+			$stashed_theme_mods = get_option( 'customize_stashed_theme_mods' );
+			$stylesheet = $this->get_stylesheet();
+			if ( isset( $stashed_theme_mods[ $stylesheet ] ) ) {
+				$values = array_merge( $values, wp_list_pluck( $stashed_theme_mods[ $stylesheet ], 'value' ) );
+			}
+		}
+
+		if ( ! $args['exclude_changeset'] ) {
+			foreach ( $this->changeset_data() as $setting_id => $setting_params ) {
+				if ( ! array_key_exists( 'value', $setting_params ) ) {
+					continue;
+				}
+				if ( isset( $setting_params['type'] ) && 'theme_mod' === $setting_params['type'] ) {
+
+					// Ensure that theme mods values are only used if they were saved under the current theme.
+					$namespace_pattern = '/^(?P<stylesheet>.+?)::(?P<setting_id>.+)$/';
+					if ( preg_match( $namespace_pattern, $setting_id, $matches ) && $this->get_stylesheet() === $matches['stylesheet'] ) {
+						$values[ $matches['setting_id'] ] = $setting_params['value'];
+					}
+				} else {
+					$values[ $setting_id ] = $setting_params['value'];
+				}
+			}
+		}
+
+		if ( ! $args['exclude_post_data'] ) {
+			if ( ! isset( $this->_post_values ) ) {
+				if ( isset( $_POST['customized'] ) ) {
+					$post_values = json_decode( wp_unslash( $_POST['customized'] ), true );
+				} else {
+					$post_values = array();
+				}
+				if ( is_array( $post_values ) ) {
+					$this->_post_values = $post_values;
+				} else {
+					$this->_post_values = array();
+				}
+			}
+			$values = array_merge( $values, $this->_post_values );
+		}
+		return $values;
+	}
+
+	/**
+	 * Returns the sanitized value for a given setting from the current customized state.
+	 *
+	 * The name "post_value" is a carry-over from when the customized state was exclusively
+	 * sourced from `$_POST['customized']`. Nevertheless, the value returned will come
+	 * from the current changeset post and from the incoming post data.
 	 *
 	 * @since 3.4.0
 	 * @since 4.1.1 Introduced the `$default` parameter.
@@ -684,7 +996,10 @@ final class WP_Customize_Manager {
 	}
 
 	/**
-	 * Override a setting's (unsanitized) value as found in any incoming $_POST['customized'].
+	 * Override a setting's value in the current customized state.
+	 *
+	 * The name "post_value" is a carry-over from when the customized state was
+	 * exclusively sourced from `$_POST['customized']`.
 	 *
 	 * @since 4.2.0
 	 * @access public
@@ -693,7 +1008,7 @@ final class WP_Customize_Manager {
 	 * @param mixed  $value      Post value.
 	 */
 	public function set_post_value( $setting_id, $value ) {
-		$this->unsanitized_post_values();
+		$this->unsanitized_post_values(); // Populate _post_values from $_POST['customized'].
 		$this->_post_values[ $setting_id ] = $value;
 
 		/**
@@ -733,21 +1048,39 @@ final class WP_Customize_Manager {
 	 * @since 3.4.0
 	 */
 	public function customize_preview_init() {
-		$this->nonce_tick = check_ajax_referer( 'preview-customize_' . $this->get_stylesheet(), 'nonce' );
+
+		/*
+		 * Now that Customizer previews are loaded into iframes via GET requests
+		 * and natural URLs with transaction UUIDs added, we need to ensure that
+		 * the responses are never cached by proxies. In practice, this will not
+		 * be needed if the user is logged-in anyway. But if anonymous access is
+		 * allowed then the auth cookies would not be sent and WordPress would
+		 * not send no-cache headers by default.
+		 */
+		if ( ! headers_sent() ) {
+			nocache_headers();
+			header( 'X-Robots: noindex, nofollow, noarchive' );
+		}
+		add_action( 'wp_head', 'wp_no_robots' );
+		add_filter( 'wp_headers', array( $this, 'filter_iframe_security_headers' ) );
+
+		/*
+		 * If preview is being served inside the customizer preview iframe, and
+		 * if the user doesn't have customize capability, then it is assumed
+		 * that the user's session has expired and they need to re-authenticate.
+		 */
+		if ( $this->messenger_channel && ! current_user_can( 'customize' ) ) {
+			$this->wp_die( -1, __( 'Unauthorized. You may remove the customize_messenger_channel param to preview as frontend.' ) );
+			return;
+		}
 
 		$this->prepare_controls();
 
+		add_filter( 'wp_redirect', array( $this, 'add_state_query_params' ) );
+
 		wp_enqueue_script( 'customize-preview' );
-		add_action( 'wp', array( $this, 'customize_preview_override_404_status' ) );
-		add_action( 'wp_head', array( $this, 'customize_preview_base' ) );
 		add_action( 'wp_head', array( $this, 'customize_preview_loading_style' ) );
 		add_action( 'wp_footer', array( $this, 'customize_preview_settings' ), 20 );
-		add_action( 'shutdown', array( $this, 'customize_preview_signature' ), 1000 );
-		add_filter( 'wp_die_handler', array( $this, 'remove_preview_signature' ) );
-
-		foreach ( $this->settings as $setting ) {
-			$setting->preview();
-		}
 
 		/**
 		 * Fires once the Customizer preview has initialized and JavaScript
@@ -760,26 +1093,86 @@ final class WP_Customize_Manager {
 		do_action( 'customize_preview_init', $this );
 	}
 
+	/**
+	 * Filter the X-Frame-Options and Content-Security-Policy headers to ensure frontend can load in customizer.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @param array $headers Headers.
+	 * @return array Headers.
+	 */
+	public function filter_iframe_security_headers( $headers ) {
+		$customize_url = admin_url( 'customize.php' );
+		$headers['X-Frame-Options'] = 'ALLOW-FROM ' . $customize_url;
+		$headers['Content-Security-Policy'] = 'frame-ancestors ' . preg_replace( '#^(\w+://[^/]+).+?$#', '$1', $customize_url );
+		return $headers;
+	}
+
+	/**
+	 * Add customize state query params to a given URL if preview is allowed.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 * @see wp_redirect()
+	 * @see WP_Customize_Manager::get_allowed_url()
+	 *
+	 * @param string $url URL.
+	 * @return string URL.
+	 */
+	public function add_state_query_params( $url ) {
+		$parsed_original_url = wp_parse_url( $url );
+		$is_allowed = false;
+		foreach ( $this->get_allowed_urls() as $allowed_url ) {
+			$parsed_allowed_url = wp_parse_url( $allowed_url );
+			$is_allowed = (
+				$parsed_allowed_url['scheme'] === $parsed_original_url['scheme']
+				&&
+				$parsed_allowed_url['host'] === $parsed_original_url['host']
+				&&
+				0 === strpos( $parsed_original_url['path'], $parsed_allowed_url['path'] )
+			);
+			if ( $is_allowed ) {
+				break;
+			}
+		}
+
+		if ( $is_allowed ) {
+			$query_params = array(
+				'customize_changeset_uuid' => $this->changeset_uuid(),
+			);
+			if ( ! $this->is_theme_active() ) {
+				$query_params['customize_theme'] = $this->get_stylesheet();
+			}
+			if ( $this->messenger_channel ) {
+				$query_params['customize_messenger_channel'] = $this->messenger_channel;
+			}
+			$url = add_query_arg( $query_params, $url );
+		}
+
+		return $url;
+	}
+
 	/**
 	 * Prevent sending a 404 status when returning the response for the customize
 	 * preview, since it causes the jQuery Ajax to fail. Send 200 instead.
 	 *
 	 * @since 4.0.0
+	 * @deprecated 4.7.0
 	 * @access public
 	 */
 	public function customize_preview_override_404_status() {
-		if ( is_404() ) {
-			status_header( 200 );
-		}
+		_deprecated_function( __METHOD__, '4.7.0' );
 	}
 
 	/**
 	 * Print base element for preview frame.
 	 *
 	 * @since 3.4.0
+	 * @deprecated 4.7.0
 	 */
 	public function customize_preview_base() {
-		?><base href="<?php echo home_url( '/' ); ?>" /><?php
+		_deprecated_function( __METHOD__, '4.7.0' );
 	}
 
 	/**
@@ -809,6 +1202,14 @@ final class WP_Customize_Manager {
 			body.wp-customizer-unloading * {
 				pointer-events: none !important;
 			}
+			form.customize-unpreviewable,
+			form.customize-unpreviewable input,
+			form.customize-unpreviewable select,
+			form.customize-unpreviewable button,
+			a.customize-unpreviewable,
+			area.customize-unpreviewable {
+				cursor: not-allowed !important;
+			}
 		</style><?php
 	}
 
@@ -818,27 +1219,62 @@ final class WP_Customize_Manager {
 	 * @since 3.4.0
 	 */
 	public function customize_preview_settings() {
-		$setting_validities = $this->validate_setting_values( $this->unsanitized_post_values() );
+		$post_values = $this->unsanitized_post_values( array( 'exclude_changeset' => true ) );
+		$setting_validities = $this->validate_setting_values( $post_values );
 		$exported_setting_validities = array_map( array( $this, 'prepare_setting_validity_for_js' ), $setting_validities );
 
+		// Note that the REQUEST_URI is not passed into home_url() since this breaks subdirectory installs.
+		$self_url = empty( $_SERVER['REQUEST_URI'] ) ? home_url( '/' ) : esc_url_raw( wp_unslash( $_SERVER['REQUEST_URI'] ) );
+		$state_query_params = array(
+			'customize_theme',
+			'customize_changeset_uuid',
+			'customize_messenger_channel',
+		);
+		$self_url = remove_query_arg( $state_query_params, $self_url );
+
+		$allowed_urls = $this->get_allowed_urls();
+		$allowed_hosts = array();
+		foreach ( $allowed_urls as $allowed_url ) {
+			$parsed = wp_parse_url( $allowed_url );
+			if ( empty( $parsed['host'] ) ) {
+				continue;
+			}
+			$host = $parsed['host'];
+			if ( ! empty( $parsed['port'] ) ) {
+				$host .= ':' . $parsed['port'];
+			}
+			$allowed_hosts[] = $host;
+		}
 		$settings = array(
+			'changeset' => array(
+				'uuid' => $this->_changeset_uuid,
+			),
+			'timeouts' => array(
+				'selectiveRefresh' => 250,
+				'keepAliveSend' => 1000,
+			),
 			'theme' => array(
 				'stylesheet' => $this->get_stylesheet(),
 				'active'     => $this->is_theme_active(),
 			),
 			'url' => array(
-				'self' => empty( $_SERVER['REQUEST_URI'] ) ? home_url( '/' ) : esc_url_raw( wp_unslash( $_SERVER['REQUEST_URI'] ) ),
+				'self' => $self_url,
+				'allowed' => array_map( 'esc_url_raw', $this->get_allowed_urls() ),
+				'allowedHosts' => array_unique( $allowed_hosts ),
+				'isCrossDomain' => $this->is_cross_domain(),
 			),
-			'channel' => wp_unslash( $_POST['customize_messenger_channel'] ),
+			'channel' => $this->messenger_channel,
 			'activePanels' => array(),
 			'activeSections' => array(),
 			'activeControls' => array(),
 			'settingValidities' => $exported_setting_validities,
-			'nonce' => $this->get_nonces(),
+			'nonce' => current_user_can( 'customize' ) ? $this->get_nonces() : array(),
 			'l10n' => array(
 				'shiftClickToEdit' => __( 'Shift-click to edit this element.' ),
+				'linkUnpreviewable' => __( 'This link is not live-previewable.' ),
+				'formUnpreviewable' => __( 'This form is not live-previewable.' ),
 			),
-			'_dirty' => array_keys( $this->unsanitized_post_values() ),
+			'_dirty' => array_keys( $post_values ),
 		);
 
 		foreach ( $this->panels as $panel_id => $panel ) {
@@ -892,21 +1328,23 @@ final class WP_Customize_Manager {
 	 * Prints a signature so we can ensure the Customizer was properly executed.
 	 *
 	 * @since 3.4.0
+	 * @deprecated 4.7.0
 	 */
 	public function customize_preview_signature() {
-		echo 'WP_CUSTOMIZER_SIGNATURE';
+		_deprecated_function( __METHOD__, '4.7.0' );
 	}
 
 	/**
 	 * Removes the signature in case we experience a case where the Customizer was not properly executed.
 	 *
 	 * @since 3.4.0
+	 * @deprecated 4.7.0
 	 *
 	 * @param mixed $return Value passed through for {@see 'wp_die_handler'} filter.
 	 * @return mixed Value passed through for {@see 'wp_die_handler'} filter.
 	 */
 	public function remove_preview_signature( $return = null ) {
-		remove_action( 'shutdown', array( $this, 'customize_preview_signature' ), 1000 );
+		_deprecated_function( __METHOD__, '4.7.0' );
 
 		return $return;
 	}
@@ -993,16 +1431,37 @@ final class WP_Customize_Manager {
 	 * @see WP_Customize_Setting::validate()
 	 *
 	 * @param array $setting_values Mapping of setting IDs to values to validate and sanitize.
+	 * @param array $options {
+	 *     Options.
+	 *
+	 *     @type bool $validate_existence  Whether a setting's existence will be checked.
+	 *     @type bool $validate_capability Whether the setting capability will be checked.
+	 * }
 	 * @return array Mapping of setting IDs to return value of validate method calls, either `true` or `WP_Error`.
 	 */
-	public function validate_setting_values( $setting_values ) {
+	public function validate_setting_values( $setting_values, $options = array() ) {
+		$options = wp_parse_args( $options, array(
+			'validate_capability' => false,
+			'validate_existence' => false,
+		) );
+
 		$validities = array();
 		foreach ( $setting_values as $setting_id => $unsanitized_value ) {
 			$setting = $this->get_setting( $setting_id );
-			if ( ! $setting || is_null( $unsanitized_value ) ) {
+			if ( ! $setting ) {
+				if ( $options['validate_existence'] ) {
+					$validities[ $setting_id ] = new WP_Error( 'unrecognized', __( 'Setting does not exist or is unrecognized.' ) );
+				}
 				continue;
 			}
-			$validity = $setting->validate( $unsanitized_value );
+			if ( is_null( $unsanitized_value ) ) {
+				continue;
+			}
+			if ( $options['validate_capability'] && ! current_user_can( $setting->capability ) ) {
+				$validity = new WP_Error( 'unauthorized', __( 'Unauthorized to modify setting due to capability.' ) );
+			} else {
+				$validity = $setting->validate( $unsanitized_value );
+			}
 			if ( ! is_wp_error( $validity ) ) {
 				/** This filter is documented in wp-includes/class-wp-customize-setting.php */
 				$late_validity = apply_filters( "customize_validate_{$setting->id}", new WP_Error(), $unsanitized_value, $setting );
@@ -1056,11 +1515,16 @@ final class WP_Customize_Manager {
 	}
 
 	/**
-	 * Switch the theme and trigger the save() method on each setting.
+	 * Handle customize_save WP Ajax request to save/update a changeset.
 	 *
 	 * @since 3.4.0
+	 * @since 4.7.0 The semantics of this method have changed to update a changeset, optionally to also change the status and other attributes.
 	 */
 	public function save() {
+		if ( ! is_user_logged_in() ) {
+			wp_send_json_error( 'unauthenticated' );
+		}
+
 		if ( ! $this->is_preview() ) {
 			wp_send_json_error( 'not_preview' );
 		}
@@ -1070,6 +1534,191 @@ final class WP_Customize_Manager {
 			wp_send_json_error( 'invalid_nonce' );
 		}
 
+		$changeset_post_id = $this->changeset_post_id();
+		if ( $changeset_post_id && in_array( get_post_status( $changeset_post_id ), array( 'publish', 'trash' ) ) ) {
+			wp_send_json_error( 'changeset_already_published' );
+		}
+
+		if ( empty( $changeset_post_id ) ) {
+			if ( ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->create_posts ) ) {
+				wp_send_json_error( 'cannot_create_changeset_post' );
+			}
+		} else {
+			if ( ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->edit_post, $changeset_post_id ) ) {
+				wp_send_json_error( 'cannot_edit_changeset_post' );
+			}
+		}
+
+		if ( ! empty( $_POST['customize_changeset_data'] ) ) {
+			$input_changeset_data = json_decode( wp_unslash( $_POST['customize_changeset_data'] ), true );
+			if ( ! is_array( $input_changeset_data ) ) {
+				wp_send_json_error( 'invalid_customize_changeset_data' );
+			}
+		} else {
+			$input_changeset_data = array();
+		}
+
+		// Validate title.
+		$changeset_title = null;
+		if ( isset( $_POST['customize_changeset_title'] ) ) {
+			$changeset_title = sanitize_text_field( wp_unslash( $_POST['customize_changeset_title'] ) );
+		}
+
+		// Validate changeset status param.
+		$is_publish = null;
+		$changeset_status = null;
+		if ( isset( $_POST['customize_changeset_status'] ) ) {
+			$changeset_status = wp_unslash( $_POST['customize_changeset_status'] );
+			if ( ! get_post_status_object( $changeset_status ) || ! in_array( $changeset_status, array( 'draft', 'pending', 'publish', 'future' ), true ) ) {
+				wp_send_json_error( 'bad_customize_changeset_status', 400 );
+			}
+			$is_publish = ( 'publish' === $changeset_status || 'future' === $changeset_status );
+			if ( $is_publish ) {
+				if ( ! current_user_can( get_post_type_object( 'customize_changeset' )->cap->publish_posts ) ) {
+					wp_send_json_error( 'changeset_publish_unauthorized', 403 );
+				}
+				if ( false === has_action( 'transition_post_status', '_wp_customize_publish_changeset' ) ) {
+					wp_send_json_error( 'missing_publish_callback', 500 );
+				}
+			}
+		}
+
+		/*
+		 * Validate changeset date param. Date is assumed to be in local time for
+		 * the WP if in MySQL format (YYYY-MM-DD HH:MM:SS). Otherwise, the date
+		 * is parsed with strtotime() so that ISO date format may be supplied
+		 * or a string like "+10 minutes".
+		 */
+		$changeset_date_gmt = null;
+		if ( isset( $_POST['customize_changeset_date'] ) ) {
+			$changeset_date = wp_unslash( $_POST['customize_changeset_date'] );
+			if ( preg_match( '/^\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d$/', $changeset_date ) ) {
+				$mm = substr( $changeset_date, 5, 2 );
+				$jj = substr( $changeset_date, 8, 2 );
+				$aa = substr( $changeset_date, 0, 4 );
+				$valid_date = wp_checkdate( $mm, $jj, $aa, $changeset_date );
+				if ( ! $valid_date ) {
+					wp_send_json_error( 'bad_customize_changeset_date', 400 );
+				}
+				$changeset_date_gmt = get_gmt_from_date( $changeset_date );
+			} else {
+				$timestamp = strtotime( $changeset_date );
+				if ( ! $timestamp ) {
+					wp_send_json_error( 'bad_customize_changeset_date', 400 );
+				}
+				$changeset_date_gmt = gmdate( 'Y-m-d H:i:s', $timestamp );
+			}
+			$now = gmdate( 'Y-m-d H:i:59' );
+
+			$is_future_dated = ( mysql2date( 'U', $changeset_date_gmt, false ) > mysql2date( 'U', $now, false ) );
+			if ( ! $is_future_dated ) {
+				wp_send_json_error( 'not_future_date', 400 ); // Only future dates are allowed.
+			}
+
+			if ( ! $this->is_theme_active() && ( 'future' === $changeset_status || $is_future_dated ) ) {
+				wp_send_json_error( 'cannot_schedule_theme_switches', 400 ); // This should be allowed in the future, when theme is a regular setting.
+			}
+			$will_remain_auto_draft = ( ! $changeset_status && ( ! $changeset_post_id || 'auto-draft' === get_post_status( $changeset_post_id ) ) );
+			if ( $changeset_date && $will_remain_auto_draft ) {
+				wp_send_json_error( 'cannot_supply_date_for_auto_draft_changeset', 400 );
+			}
+		}
+
+		$r = $this->save_changeset_post( array(
+			'status' => $changeset_status,
+			'title' => $changeset_title,
+			'date_gmt' => $changeset_date_gmt,
+			'data' => $input_changeset_data,
+		) );
+		if ( is_wp_error( $r ) ) {
+			$response = $r->get_error_data();
+		} else {
+			$response = $r;
+
+			// Note that if the changeset status was publish, then it will get set to trash if revisions are not supported.
+			$response['changeset_status'] = get_post_status( $this->changeset_post_id() );
+			if ( $is_publish && 'trash' === $response['changeset_status'] ) {
+				$response['changeset_status'] = 'publish';
+			}
+
+			if ( 'publish' === $response['changeset_status'] ) {
+				$response['next_changeset_uuid'] = wp_generate_uuid4();
+			}
+		}
+
+		if ( isset( $response['setting_validities'] ) ) {
+			$response['setting_validities'] = array_map( array( $this, 'prepare_setting_validity_for_js' ), $response['setting_validities'] );
+		}
+
+		/**
+		 * Filters response data for a successful customize_save Ajax request.
+		 *
+		 * This filter does not apply if there was a nonce or authentication failure.
+		 *
+		 * @since 4.2.0
+		 *
+		 * @param array                $response Additional information passed back to the 'saved'
+		 *                                       event on `wp.customize`.
+		 * @param WP_Customize_Manager $this     WP_Customize_Manager instance.
+		 */
+		$response = apply_filters( 'customize_save_response', $response, $this );
+
+		if ( is_wp_error( $r ) ) {
+			wp_send_json_error( $response );
+		} else {
+			wp_send_json_success( $response );
+		}
+	}
+
+	/**
+	 * Save the post for the loaded changeset.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @param array $args {
+	 *     Args for changeset post.
+	 *
+	 *     @type array  $data     Optional additional changeset data. Values will be merged on top of any existing post values.
+	 *     @type string $status   Post status. Optional. If supplied, the save will be transactional and a post revision will be allowed.
+	 *     @type string $title    Post title. Optional.
+	 *     @type string $date_gmt Date in GMT. Optional.
+	 * }
+	 *
+	 * @return array|WP_Error Returns array on success and WP_Error with array data on error.
+	 */
+	function save_changeset_post( $args = array() ) {
+
+		$args = array_merge(
+			array(
+				'status' => null,
+				'title' => null,
+				'data' => array(),
+				'date_gmt' => null,
+			),
+			$args
+		);
+
+		$changeset_post_id = $this->changeset_post_id();
+
+		// The request was made via wp.customize.previewer.save().
+		$update_transactionally = (bool) $args['status'];
+		$allow_revision = (bool) $args['status'];
+
+		// Amend post values with any supplied data.
+		foreach ( $args['data'] as $setting_id => $setting_params ) {
+			if ( array_key_exists( 'value', $setting_params ) ) {
+				$this->set_post_value( $setting_id, $setting_params['value'] ); // Add to post values so that they can be validated and sanitized.
+			}
+		}
+
+		// Note that in addition to post data, this will include any stashed theme mods.
+		$post_values = $this->unsanitized_post_values( array(
+			'exclude_changeset' => true,
+			'exclude_post_data' => false,
+		) );
+		$this->add_dynamic_settings( array_keys( $post_values ) ); // Ensure settings get created even if they lack an input value.
+
 		/**
 		 * Fires before save validation happens.
 		 *
@@ -1084,42 +1733,318 @@ final class WP_Customize_Manager {
 		do_action( 'customize_save_validation_before', $this );
 
 		// Validate settings.
-		$setting_validities = $this->validate_setting_values( $this->unsanitized_post_values() );
+		$setting_validities = $this->validate_setting_values( $post_values, array(
+			'validate_capability' => true,
+			'validate_existence' => true,
+		) );
 		$invalid_setting_count = count( array_filter( $setting_validities, 'is_wp_error' ) );
-		$exported_setting_validities = array_map( array( $this, 'prepare_setting_validity_for_js' ), $setting_validities );
-		if ( $invalid_setting_count > 0 ) {
+
+		/*
+		 * Short-circuit if there are invalid settings the update is transactional.
+		 * A changeset update is transactional when a status is supplied in the request.
+		 */
+		if ( $update_transactionally && $invalid_setting_count > 0 ) {
 			$response = array(
-				'setting_validities' => $exported_setting_validities,
+				'setting_validities' => $setting_validities,
 				'message' => sprintf( _n( 'There is %s invalid setting.', 'There are %s invalid settings.', $invalid_setting_count ), number_format_i18n( $invalid_setting_count ) ),
 			);
-
-			/** This filter is documented in wp-includes/class-wp-customize-manager.php */
-			$response = apply_filters( 'customize_save_response', $response, $this );
-			wp_send_json_error( $response );
+			return new WP_Error( 'transaction_fail', '', $response );
 		}
 
-		// Do we have to switch themes?
-		if ( ! $this->is_theme_active() ) {
-			// Temporarily stop previewing the theme to allow switch_themes()
-			// to operate properly.
+		$response = array(
+			'setting_validities' => $setting_validities,
+		);
+
+		// Obtain/merge data for changeset.
+		$original_changeset_data = $this->get_changeset_post_data( $changeset_post_id );
+		$data = $original_changeset_data;
+		if ( is_wp_error( $data ) ) {
+			$data = array();
+		}
+
+		// Ensure that all post values are included in the changeset data.
+		foreach ( $post_values as $setting_id => $post_value ) {
+			if ( ! isset( $args['data'][ $setting_id ] ) ) {
+				$args['data'][ $setting_id ] = array();
+			}
+			if ( ! isset( $args['data'][ $setting_id ]['value'] ) ) {
+				$args['data'][ $setting_id ]['value'] = $post_value;
+			}
+		}
+
+		foreach ( $args['data'] as $setting_id => $setting_params ) {
+			$setting = $this->get_setting( $setting_id );
+			if ( ! $setting || ! $setting->check_capabilities() ) {
+				continue;
+			}
+
+			// Skip updating changeset for invalid setting values.
+			if ( isset( $setting_validities[ $setting_id ] ) && is_wp_error( $setting_validities[ $setting_id ] ) ) {
+				continue;
+			}
+
+			$changeset_setting_id = $setting_id;
+			if ( 'theme_mod' === $setting->type ) {
+				$changeset_setting_id = sprintf( '%s::%s', $this->get_stylesheet(), $setting_id );
+			}
+
+			if ( null === $setting_params ) {
+				// Remove setting from changeset entirely.
+				unset( $data[ $changeset_setting_id ] );
+			} else {
+				// Merge any additional setting params that have been supplied with the existing params.
+				if ( ! isset( $data[ $changeset_setting_id ] ) ) {
+					$data[ $changeset_setting_id ] = array();
+				}
+				$data[ $changeset_setting_id ] = array_merge(
+					$data[ $changeset_setting_id ],
+					$setting_params,
+					array( 'type' => $setting->type )
+				);
+			}
+		}
+
+		$filter_context = array(
+			'uuid' => $this->changeset_uuid(),
+			'title' => $args['title'],
+			'status' => $args['status'],
+			'date_gmt' => $args['date_gmt'],
+			'post_id' => $changeset_post_id,
+			'previous_data' => is_wp_error( $original_changeset_data ) ? array() : $original_changeset_data,
+			'manager' => $this,
+		);
+
+		/**
+		 * Filters the settings' data that will be persisted into the changeset.
+		 *
+		 * Plugins may amend additional data (such as additional meta for settings) into the changeset with this filter.
+		 *
+		 * @since 4.7.0
+		 *
+		 * @param array $data Updated changeset data, mapping setting IDs to arrays containing a $value item and optionally other metadata.
+		 * @param array $context {
+		 *     Filter context.
+		 *
+		 *     @type string               $uuid          Changeset UUID.
+		 *     @type string               $title         Requested title for the changeset post.
+		 *     @type string               $status        Requested status for the changeset post.
+		 *     @type string               $date_gmt      Requested date for the changeset post in MySQL format and GMT timezone.
+		 *     @type int|false            $post_id       Post ID for the changeset, or false if it doesn't exist yet.
+		 *     @type array                $previous_data Previous data contained in the changeset.
+		 *     @type WP_Customize_Manager $manager       Manager instance.
+		 * }
+		 */
+		$data = apply_filters( 'customize_changeset_save_data', $data, $filter_context );
+
+		// Switch theme if publishing changes now.
+		if ( 'publish' === $args['status'] && ! $this->is_theme_active() ) {
+			// Temporarily stop previewing the theme to allow switch_themes() to operate properly.
 			$this->stop_previewing_theme();
 			switch_theme( $this->get_stylesheet() );
 			update_option( 'theme_switched_via_customizer', true );
 			$this->start_previewing_theme();
 		}
 
+		// Gather the data for wp_insert_post()/wp_update_post().
+		$json_options = 0;
+		if ( defined( 'JSON_UNESCAPED_SLASHES' ) ) {
+			$json_options |= JSON_UNESCAPED_SLASHES; // Introduced in PHP 5.4. This is only to improve readability as slashes needn't be escaped in storage.
+		}
+		$json_options |= JSON_PRETTY_PRINT; // Also introduced in PHP 5.4, but WP defines constant for back compat. See WP Trac #30139.
+		$post_array = array(
+			'post_content' => wp_json_encode( $data, $json_options ),
+		);
+		if ( $args['title'] ) {
+			$post_array['post_title'] = $args['title'];
+		}
+		if ( $changeset_post_id ) {
+			$post_array['ID'] = $changeset_post_id;
+		} else {
+			$post_array['post_type'] = 'customize_changeset';
+			$post_array['post_name'] = $this->changeset_uuid();
+			$post_array['post_status'] = 'auto-draft';
+		}
+		if ( $args['status'] ) {
+			$post_array['post_status'] = $args['status'];
+		}
+		if ( $args['date_gmt'] ) {
+			$post_array['post_date_gmt'] = $args['date_gmt'];
+			$post_array['post_date'] = get_date_from_gmt( $args['date_gmt'] );
+		}
+
+		$this->store_changeset_revision = $allow_revision;
+		add_filter( 'wp_save_post_revision_post_has_changed', array( $this, '_filter_revision_post_has_changed' ), 5, 3 );
+
+		// Update the changeset post. The publish_customize_changeset action will cause the settings in the changeset to be saved via WP_Customize_Setting::save().
+		$has_kses = ( false !== has_filter( 'content_save_pre', 'wp_filter_post_kses' ) );
+		if ( $has_kses ) {
+			kses_remove_filters(); // Prevent KSES from corrupting JSON in post_content.
+		}
+
+		// Note that updating a post with publish status will trigger WP_Customize_Manager::publish_changeset_values().
+		if ( $changeset_post_id ) {
+			$post_array['edit_date'] = true; // Prevent date clearing.
+			$r = wp_update_post( wp_slash( $post_array ), true );
+		} else {
+			$r = wp_insert_post( wp_slash( $post_array ), true );
+			if ( ! is_wp_error( $r ) ) {
+				$this->_changeset_post_id = $r; // Update cached post ID for the loaded changeset.
+			}
+		}
+		if ( $has_kses ) {
+			kses_init_filters();
+		}
+		$this->_changeset_data = null; // Reset so WP_Customize_Manager::changeset_data() will re-populate with updated contents.
+
+		remove_filter( 'wp_save_post_revision_post_has_changed', array( $this, '_filter_revision_post_has_changed' ) );
+
+		if ( is_wp_error( $r ) ) {
+			$response['changeset_post_save_failure'] = $r->get_error_code();
+			return new WP_Error( 'changeset_post_save_failure', '', $response );
+		}
+
+		return $response;
+	}
+
+	/**
+	 * Whether a changeset revision should be made.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 * @var bool
+	 */
+	protected $store_changeset_revision;
+
+	/**
+	 * Filters whether a changeset has changed to create a new revision.
+	 *
+	 * Note that this will not be called while a changeset post remains in auto-draft status.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 *
+	 * @param bool    $post_has_changed Whether the post has changed.
+	 * @param WP_Post $last_revision    The last revision post object.
+	 * @param WP_Post $post             The post object.
+	 *
+	 * @return bool Whether a revision should be made.
+	 */
+	public function _filter_revision_post_has_changed( $post_has_changed, $last_revision, $post ) {
+		unset( $last_revision );
+		if ( 'customize_changeset' === $post->post_type ) {
+			$post_has_changed = $this->store_changeset_revision;
+		}
+		return $post_has_changed;
+	}
+
+	/**
+	 * Publish changeset values.
+	 *
+	 * This will the values contained in a changeset, even changesets that do not
+	 * correspond to current manager instance. This is called by
+	 * `_wp_customize_publish_changeset()` when a customize_changeset post is
+	 * transitioned to the `publish` status. As such, this method should not be
+	 * called directly and instead `wp_publish_post()` should be used.
+	 *
+	 * Please note that if the settings in the changeset are for a non-activated
+	 * theme, the theme must first be switched to (via `switch_theme()`) before
+	 * invoking this method.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 * @see _wp_customize_publish_changeset()
+	 *
+	 * @param int $changeset_post_id ID for customize_changeset post. Defaults to the changeset for the current manager instance.
+	 * @return true|WP_Error True or error info.
+	 */
+	public function _publish_changeset_values( $changeset_post_id ) {
+		$publishing_changeset_data = $this->get_changeset_post_data( $changeset_post_id );
+		if ( is_wp_error( $publishing_changeset_data ) ) {
+			return $publishing_changeset_data;
+		}
+
+		$changeset_post = get_post( $changeset_post_id );
+
+		/*
+		 * Temporarily override the changeset context so that it will be read
+		 * in calls to unsanitized_post_values() and so that it will be available
+		 * on the $wp_customize object passed to hooks during the save logic.
+		 */
+		$previous_changeset_post_id = $this->_changeset_post_id;
+		$this->_changeset_post_id   = $changeset_post_id;
+		$previous_changeset_uuid    = $this->_changeset_uuid;
+		$this->_changeset_uuid      = $changeset_post->post_name;
+		$previous_changeset_data    = $this->_changeset_data;
+		$this->_changeset_data      = $publishing_changeset_data;
+
+		// Ensure that other theme mods are stashed.
+		$other_theme_mod_settings = array();
+		if ( did_action( 'switch_theme' ) ) {
+			$namespace_pattern = '/^(?P<stylesheet>.+?)::(?P<setting_id>.+)$/';
+			$matches = array();
+			foreach ( $this->_changeset_data as $raw_setting_id => $setting_params ) {
+				$is_other_theme_mod = (
+					isset( $setting_params['value'] )
+					&&
+					isset( $setting_params['type'] )
+					&&
+					'theme_mod' === $setting_params['type']
+					&&
+					preg_match( $namespace_pattern, $raw_setting_id, $matches )
+					&&
+					$this->get_stylesheet() !== $matches['stylesheet']
+				);
+				if ( $is_other_theme_mod ) {
+					if ( ! isset( $other_theme_mod_settings[ $matches['stylesheet'] ] ) ) {
+						$other_theme_mod_settings[ $matches['stylesheet'] ] = array();
+					}
+					$other_theme_mod_settings[ $matches['stylesheet'] ][ $matches['setting_id'] ] = $setting_params;
+				}
+			}
+		}
+
+		$changeset_setting_values = $this->unsanitized_post_values( array(
+			'exclude_post_data' => true,
+			'exclude_changeset' => false,
+		) );
+		$changeset_setting_ids = array_keys( $changeset_setting_values );
+		$this->add_dynamic_settings( $changeset_setting_ids );
+
 		/**
 		 * Fires once the theme has switched in the Customizer, but before settings
 		 * have been saved.
 		 *
 		 * @since 3.4.0
 		 *
-		 * @param WP_Customize_Manager $this WP_Customize_Manager instance.
+		 * @param WP_Customize_Manager $manager WP_Customize_Manager instance.
 		 */
 		do_action( 'customize_save', $this );
 
-		foreach ( $this->settings as $setting ) {
-			$setting->save();
+		/*
+		 * Ensure that all settings will allow themselves to be saved. Note that
+		 * this is safe because the setting would have checked the capability
+		 * when the setting value was written into the changeset. So this is why
+		 * an additional capability check is not required here.
+		 */
+		$original_setting_capabilities = array();
+		foreach ( $changeset_setting_ids as $setting_id ) {
+			$setting = $this->get_setting( $setting_id );
+			if ( $setting ) {
+				$original_setting_capabilities[ $setting->id ] = $setting->capability;
+				$setting->capability = 'exist';
+			}
+		}
+
+		foreach ( $changeset_setting_ids as $setting_id ) {
+			$setting = $this->get_setting( $setting_id );
+			if ( $setting ) {
+				$setting->save();
+			}
+		}
+
+		// Update the stashed theme mod settings, removing the active theme's stashed settings, if activated.
+		if ( did_action( 'switch_theme' ) ) {
+			$this->update_stashed_theme_mod_settings( $other_theme_mod_settings );
 		}
 
 		/**
@@ -1127,27 +2052,62 @@ final class WP_Customize_Manager {
 		 *
 		 * @since 3.6.0
 		 *
-		 * @param WP_Customize_Manager $this WP_Customize_Manager instance.
+		 * @param WP_Customize_Manager $manager WP_Customize_Manager instance.
 		 */
 		do_action( 'customize_save_after', $this );
 
-		$data = array(
-			'setting_validities' => $exported_setting_validities,
-		);
+		// Restore original capabilities.
+		foreach ( $original_setting_capabilities as $setting_id => $capability ) {
+			$setting = $this->get_setting( $setting_id );
+			if ( $setting ) {
+				$setting->capability = $capability;
+			}
+		}
 
-		/**
-		 * Filters response data for a successful customize_save Ajax request.
-		 *
-		 * This filter does not apply if there was a nonce or authentication failure.
-		 *
-		 * @since 4.2.0
-		 *
-		 * @param array                $data Additional information passed back to the 'saved'
-		 *                                   event on `wp.customize`.
-		 * @param WP_Customize_Manager $this WP_Customize_Manager instance.
-		 */
-		$response = apply_filters( 'customize_save_response', $data, $this );
-		wp_send_json_success( $response );
+		// Restore original changeset data.
+		$this->_changeset_data    = $previous_changeset_data;
+		$this->_changeset_post_id = $previous_changeset_post_id;
+		$this->_changeset_uuid    = $previous_changeset_uuid;
+
+		return true;
+	}
+
+	/**
+	 * Update stashed theme mod settings.
+	 *
+	 * @since 4.7.0
+	 * @access private
+	 *
+	 * @param array $inactive_theme_mod_settings Mapping of stylesheet to arrays of theme mod settings.
+	 * @return array|false Returns array of updated stashed theme mods or false if the update failed or there were no changes.
+	 */
+	protected function update_stashed_theme_mod_settings( $inactive_theme_mod_settings ) {
+		$stashed_theme_mod_settings = get_option( 'customize_stashed_theme_mods' );
+		if ( empty( $stashed_theme_mod_settings ) ) {
+			$stashed_theme_mod_settings = array();
+		}
+
+		// Delete any stashed theme mods for the active theme since since they would have been loaded and saved upon activation.
+		unset( $stashed_theme_mod_settings[ $this->get_stylesheet() ] );
+
+		// Merge inactive theme mods with the stashed theme mod settings.
+		foreach ( $inactive_theme_mod_settings as $stylesheet => $theme_mod_settings ) {
+			if ( ! isset( $stashed_theme_mod_settings[ $stylesheet ] ) ) {
+				$stashed_theme_mod_settings[ $stylesheet ] = array();
+			}
+
+			$stashed_theme_mod_settings[ $stylesheet ] = array_merge(
+				$stashed_theme_mod_settings[ $stylesheet ],
+				$theme_mod_settings
+			);
+		}
+
+		$autoload = false;
+		$result = update_option( 'customize_stashed_theme_mods', $stashed_theme_mod_settings, $autoload );
+		if ( ! $result ) {
+			return false;
+		}
+		return $stashed_theme_mod_settings;
 	}
 
 	/**
@@ -1690,6 +2650,67 @@ final class WP_Customize_Manager {
 		return $preview_url;
 	}
 
+	/**
+	 * Determines whether the admin and the frontend are on different domains.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @return bool Whether cross-domain.
+	 */
+	public function is_cross_domain() {
+		$admin_origin = wp_parse_url( admin_url() );
+		$home_origin = wp_parse_url( home_url() );
+		$cross_domain = ( strtolower( $admin_origin['host'] ) !== strtolower( $home_origin['host'] ) );
+		return $cross_domain;
+	}
+
+	/**
+	 * Get URLs allowed to be previewed.
+	 *
+	 * If the front end and the admin are served from the same domain, load the
+	 * preview over ssl if the Customizer is being loaded over ssl. This avoids
+	 * insecure content warnings. This is not attempted if the admin and front end
+	 * are on different domains to avoid the case where the front end doesn't have
+	 * ssl certs. Domain mapping plugins can allow other urls in these conditions
+	 * using the customize_allowed_urls filter.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @returns array Allowed URLs.
+	 */
+	public function get_allowed_urls() {
+		$allowed_urls = array( home_url( '/' ) );
+
+		if ( is_ssl() && ! $this->is_cross_domain() ) {
+			$allowed_urls[] = home_url( '/', 'https' );
+		}
+
+		/**
+		 * Filters the list of URLs allowed to be clicked and followed in the Customizer preview.
+		 *
+		 * @since 3.4.0
+		 *
+		 * @param array $allowed_urls An array of allowed URLs.
+		 */
+		$allowed_urls = array_unique( apply_filters( 'customize_allowed_urls', $allowed_urls ) );
+
+		return $allowed_urls;
+	}
+
+	/**
+	 * Get messenger channel.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @return string Messenger channel.
+	 */
+	public function get_messenger_channel() {
+		return $this->messenger_channel;
+	}
+
 	/**
 	 * Set URL to link the user to when closing the Customizer.
 	 *
@@ -1799,40 +2820,33 @@ final class WP_Customize_Manager {
 	 * @since 4.4.0
 	 */
 	public function customize_pane_settings() {
-		/*
-		 * If the front end and the admin are served from the same domain, load the
-		 * preview over ssl if the Customizer is being loaded over ssl. This avoids
-		 * insecure content warnings. This is not attempted if the admin and front end
-		 * are on different domains to avoid the case where the front end doesn't have
-		 * ssl certs. Domain mapping plugins can allow other urls in these conditions
-		 * using the customize_allowed_urls filter.
-		 */
-
-		$allowed_urls = array( home_url( '/' ) );
-		$admin_origin = parse_url( admin_url() );
-		$home_origin  = parse_url( home_url() );
-		$cross_domain = ( strtolower( $admin_origin['host'] ) !== strtolower( $home_origin['host'] ) );
-
-		if ( is_ssl() && ! $cross_domain ) {
-			$allowed_urls[] = home_url( '/', 'https' );
-		}
-
-		/**
-		 * Filters the list of URLs allowed to be clicked and followed in the Customizer preview.
-		 *
-		 * @since 3.4.0
-		 *
-		 * @param array $allowed_urls An array of allowed URLs.
-		 */
-		$allowed_urls = array_unique( apply_filters( 'customize_allowed_urls', $allowed_urls ) );
 
 		$login_url = add_query_arg( array(
 			'interim-login' => 1,
 			'customize-login' => 1,
 		), wp_login_url() );
 
+		// Ensure dirty flags are set for modified settings.
+		foreach ( array_keys( $this->unsanitized_post_values() ) as $setting_id ) {
+			$setting = $this->get_setting( $setting_id );
+			if ( $setting ) {
+				$setting->dirty = true;
+			}
+		}
+
 		// Prepare Customizer settings to pass to JavaScript.
 		$settings = array(
+			'changeset' => array(
+				'uuid' => $this->changeset_uuid(),
+				'status' => $this->changeset_post_id() ? get_post_status( $this->changeset_post_id() ) : '',
+			),
+			'timeouts' => array(
+				'windowRefresh' => 250,
+				'changesetAutoSave' => AUTOSAVE_INTERVAL * 1000,
+				'keepAliveCheck' => 2500,
+				'reflowPaneContents' => 100,
+				'previewFrameSensitivity' => 2000,
+			),
 			'theme'    => array(
 				'stylesheet' => $this->get_stylesheet(),
 				'active'     => $this->is_theme_active(),
@@ -1842,8 +2856,8 @@ final class WP_Customize_Manager {
 				'parent'        => esc_url_raw( admin_url() ),
 				'activated'     => esc_url_raw( home_url( '/' ) ),
 				'ajax'          => esc_url_raw( admin_url( 'admin-ajax.php', 'relative' ) ),
-				'allowed'       => array_map( 'esc_url_raw', $allowed_urls ),
-				'isCrossDomain' => $cross_domain,
+				'allowed'       => array_map( 'esc_url_raw', $this->get_allowed_urls() ),
+				'isCrossDomain' => $this->is_cross_domain(),
 				'home'          => esc_url_raw( home_url( '/' ) ),
 				'login'         => esc_url_raw( $login_url ),
 			),
@@ -2337,7 +3351,8 @@ final class WP_Customize_Manager {
 	 * @see add_dynamic_settings()
 	 */
 	public function register_dynamic_settings() {
-		$this->add_dynamic_settings( array_keys( $this->unsanitized_post_values() ) );
+		$setting_ids = array_keys( $this->unsanitized_post_values() );
+		$this->add_dynamic_settings( $setting_ids );
 	}
 
 	/**
diff --git a/src/wp-includes/class-wp-customize-nav-menus.php b/src/wp-includes/class-wp-customize-nav-menus.php
index a4e494d5b3..2d9c13a40e 100644
--- a/src/wp-includes/class-wp-customize-nav-menus.php
+++ b/src/wp-includes/class-wp-customize-nav-menus.php
@@ -48,7 +48,12 @@ final class WP_Customize_Nav_Menus {
 		$this->previewed_menus = array();
 		$this->manager         = $manager;
 
-		// Skip useless hooks when the user can't manage nav menus anyway.
+		// See https://github.com/xwp/wp-customize-snapshots/blob/962586659688a5b1fd9ae93618b7ce2d4e7a421c/php/class-customize-snapshot-manager.php#L469-L499
+		add_action( 'customize_register', array( $this, 'customize_register' ), 11 );
+		add_filter( 'customize_dynamic_setting_args', array( $this, 'filter_dynamic_setting_args' ), 10, 2 );
+		add_filter( 'customize_dynamic_setting_class', array( $this, 'filter_dynamic_setting_class' ), 10, 3 );
+
+		// Skip remaining hooks when the user can't manage nav menus anyway.
 		if ( ! current_user_can( 'edit_theme_options' ) ) {
 			return;
 		}
@@ -58,9 +63,6 @@ final class WP_Customize_Nav_Menus {
 		add_action( 'wp_ajax_search-available-menu-items-customizer', array( $this, 'ajax_search_available_items' ) );
 		add_action( 'wp_ajax_customize-nav-menus-insert-auto-draft', array( $this, 'ajax_insert_auto_draft_post' ) );
 		add_action( 'customize_controls_enqueue_scripts', array( $this, 'enqueue_scripts' ) );
-		add_action( 'customize_register', array( $this, 'customize_register' ), 11 );
-		add_filter( 'customize_dynamic_setting_args', array( $this, 'filter_dynamic_setting_args' ), 10, 2 );
-		add_filter( 'customize_dynamic_setting_class', array( $this, 'filter_dynamic_setting_class' ), 10, 3 );
 		add_action( 'customize_controls_print_footer_scripts', array( $this, 'print_templates' ) );
 		add_action( 'customize_controls_print_footer_scripts', array( $this, 'available_items_template' ) );
 		add_action( 'customize_preview_init', array( $this, 'customize_preview_init' ) );
@@ -486,6 +488,23 @@ final class WP_Customize_Nav_Menus {
 	 */
 	public function customize_register() {
 
+		/*
+		 * Preview settings for nav menus early so that the sections and controls will be added properly.
+		 * See https://github.com/xwp/wp-customize-snapshots/blob/962586659688a5b1fd9ae93618b7ce2d4e7a421c/php/class-customize-snapshot-manager.php#L506-L543
+		 */
+		$nav_menus_setting_ids = array();
+		foreach ( array_keys( $this->manager->unsanitized_post_values() ) as $setting_id ) {
+			if ( preg_match( '/^(nav_menu_locations|nav_menu|nav_menu_item)\[/', $setting_id ) ) {
+				$nav_menus_setting_ids[] = $setting_id;
+			}
+		}
+		foreach ( $nav_menus_setting_ids as $setting_id ) {
+			$setting = $this->manager->get_setting( $setting_id );
+			if ( $setting ) {
+				$setting->preview();
+			}
+		}
+
 		// Require JS-rendered control types.
 		$this->manager->register_panel_type( 'WP_Customize_Nav_Menus_Panel' );
 		$this->manager->register_control_type( 'WP_Customize_Nav_Menu_Control' );
diff --git a/src/wp-includes/class-wp-customize-widgets.php b/src/wp-includes/class-wp-customize-widgets.php
index 973fa137e6..74031194fd 100644
--- a/src/wp-includes/class-wp-customize-widgets.php
+++ b/src/wp-includes/class-wp-customize-widgets.php
@@ -93,16 +93,18 @@ final class WP_Customize_Widgets {
 	public function __construct( $manager ) {
 		$this->manager = $manager;
 
-		// Skip useless hooks when the user can't manage widgets anyway.
+		// See https://github.com/xwp/wp-customize-snapshots/blob/962586659688a5b1fd9ae93618b7ce2d4e7a421c/php/class-customize-snapshot-manager.php#L420-L449
+		add_filter( 'customize_dynamic_setting_args',          array( $this, 'filter_customize_dynamic_setting_args' ), 10, 2 );
+		add_action( 'widgets_init',                            array( $this, 'register_settings' ), 95 );
+		add_action( 'customize_register',                      array( $this, 'schedule_customize_register' ), 1 );
+
+		// Skip remaining hooks when the user can't manage widgets anyway.
 		if ( ! current_user_can( 'edit_theme_options' ) ) {
 			return;
 		}
 
-		add_filter( 'customize_dynamic_setting_args',          array( $this, 'filter_customize_dynamic_setting_args' ), 10, 2 );
-		add_action( 'widgets_init',                            array( $this, 'register_settings' ), 95 );
 		add_action( 'wp_loaded',                               array( $this, 'override_sidebars_widgets_for_theme_switch' ) );
 		add_action( 'customize_controls_init',                 array( $this, 'customize_controls_init' ) );
-		add_action( 'customize_register',                      array( $this, 'schedule_customize_register' ), 1 );
 		add_action( 'customize_controls_enqueue_scripts',      array( $this, 'enqueue_scripts' ) );
 		add_action( 'customize_controls_print_styles',         array( $this, 'print_styles' ) );
 		add_action( 'customize_controls_print_scripts',        array( $this, 'print_scripts' ) );
@@ -276,6 +278,7 @@ final class WP_Customize_Widgets {
 
 		$this->old_sidebars_widgets = wp_get_sidebars_widgets();
 		add_filter( 'customize_value_old_sidebars_widgets_data', array( $this, 'filter_customize_value_old_sidebars_widgets_data' ) );
+		$this->manager->set_post_value( 'old_sidebars_widgets_data', $this->old_sidebars_widgets ); // Override any value cached in changeset.
 
 		// retrieve_widgets() looks at the global $sidebars_widgets
 		$sidebars_widgets = $this->old_sidebars_widgets;
diff --git a/src/wp-includes/customize/class-wp-customize-selective-refresh.php b/src/wp-includes/customize/class-wp-customize-selective-refresh.php
index 95c1934d38..6864eba63d 100644
--- a/src/wp-includes/customize/class-wp-customize-selective-refresh.php
+++ b/src/wp-includes/customize/class-wp-customize-selective-refresh.php
@@ -307,8 +307,6 @@ final class WP_Customize_Selective_Refresh {
 			return;
 		}
 
-		$this->manager->remove_preview_signature();
-
 		/*
 		 * Note that is_customize_preview() returning true will entail that the
 		 * user passed the 'customize' capability check and the nonce check, since
diff --git a/src/wp-includes/customize/class-wp-customize-theme-control.php b/src/wp-includes/customize/class-wp-customize-theme-control.php
index e696687298..fdd8f131da 100644
--- a/src/wp-includes/customize/class-wp-customize-theme-control.php
+++ b/src/wp-includes/customize/class-wp-customize-theme-control.php
@@ -63,8 +63,8 @@ class WP_Customize_Theme_Control extends WP_Customize_Control {
 	 */
 	public function content_template() {
 		$current_url = set_url_scheme( 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] );
-		$active_url  = esc_url( remove_query_arg( 'theme', $current_url ) );
-		$preview_url = esc_url( add_query_arg( 'theme', '__THEME__', $current_url ) ); // Token because esc_url() strips curly braces.
+		$active_url  = esc_url( remove_query_arg( 'customize_theme', $current_url ) );
+		$preview_url = esc_url( add_query_arg( 'customize_theme', '__THEME__', $current_url ) ); // Token because esc_url() strips curly braces.
 		$preview_url = str_replace( '__THEME__', '{{ data.theme.id }}', $preview_url );
 		?>
 		<# if ( data.theme.isActiveTheme ) { #>
diff --git a/src/wp-includes/default-filters.php b/src/wp-includes/default-filters.php
index dba691ab66..6301f732c9 100644
--- a/src/wp-includes/default-filters.php
+++ b/src/wp-includes/default-filters.php
@@ -75,6 +75,7 @@ foreach ( array( 'user_url', 'link_url', 'link_image', 'link_rss', 'comment_url'
 
 // Slugs
 add_filter( 'pre_term_slug', 'sanitize_title' );
+add_filter( 'wp_insert_post_data', '_wp_customize_changeset_filter_insert_post_data', 10, 2 );
 
 // Keys
 foreach ( array( 'pre_post_type', 'pre_post_status', 'pre_post_comment_status', 'pre_post_ping_status' ) as $filter ) {
@@ -382,6 +383,7 @@ add_action( 'parse_request', 'rest_api_loaded' );
 add_action( 'wp_loaded', '_custom_header_background_just_in_time' );
 add_action( 'wp_head', '_custom_logo_header_styles' );
 add_action( 'plugins_loaded', '_wp_customize_include' );
+add_action( 'transition_post_status', '_wp_customize_publish_changeset', 10, 3 );
 add_action( 'admin_enqueue_scripts', '_wp_customize_loader_settings' );
 add_action( 'delete_attachment', '_delete_attachment_theme_mod' );
 
diff --git a/src/wp-includes/functions.php b/src/wp-includes/functions.php
index 989772e765..40d4a300e1 100644
--- a/src/wp-includes/functions.php
+++ b/src/wp-includes/functions.php
@@ -5523,3 +5523,20 @@ function wp_raise_memory_limit( $context = 'admin' ) {
 
 	return false;
 }
+
+/**
+ * Generate a random UUID (version 4).
+ *
+ * @since 4.7.0
+ *
+ * @return string UUID.
+ */
+function wp_generate_uuid4() {
+	return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
+		mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
+		mt_rand( 0, 0xffff ),
+		mt_rand( 0, 0x0fff ) | 0x4000,
+		mt_rand( 0, 0x3fff ) | 0x8000,
+		mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff )
+	);
+}
diff --git a/src/wp-includes/functions.wp-scripts.php b/src/wp-includes/functions.wp-scripts.php
index cec5ca9d65..dccaaf262a 100644
--- a/src/wp-includes/functions.wp-scripts.php
+++ b/src/wp-includes/functions.wp-scripts.php
@@ -34,7 +34,7 @@ function wp_scripts() {
  * @param string $function Function name.
  */
 function _wp_scripts_maybe_doing_it_wrong( $function ) {
-	if ( did_action( 'init' ) ) {
+	if ( did_action( 'init' ) || did_action( 'admin_enqueue_scripts' ) || did_action( 'wp_enqueue_scripts' ) || did_action( 'login_enqueue_scripts' ) ) {
 		return;
 	}
 
diff --git a/src/wp-includes/js/customize-base.js b/src/wp-includes/js/customize-base.js
index 20bb74a199..11b868c85e 100644
--- a/src/wp-includes/js/customize-base.js
+++ b/src/wp-includes/js/customize-base.js
@@ -637,22 +637,24 @@ window.wp = window.wp || {};
 		/**
 		 * Initialize Messenger.
 		 *
-		 * @param  {object} params        Parameters to configure the messenger.
-		 *         {string} .url          The URL to communicate with.
-		 *         {window} .targetWindow The window instance to communicate with. Default window.parent.
-		 *         {string} .channel      If provided, will send the channel with each message and only accept messages a matching channel.
-		 * @param  {object} options       Extend any instance parameter or method with this object.
+		 * @param  {object} params - Parameters to configure the messenger.
+		 *         {string} params.url - The URL to communicate with.
+		 *         {window} params.targetWindow - The window instance to communicate with. Default window.parent.
+		 *         {string} params.channel - If provided, will send the channel with each message and only accept messages a matching channel.
+		 * @param  {object} options - Extend any instance parameter or method with this object.
 		 */
 		initialize: function( params, options ) {
 			// Target the parent frame by default, but only if a parent frame exists.
-			var defaultTarget = window.parent == window ? null : window.parent;
+			var defaultTarget = window.parent === window ? null : window.parent;
 
 			$.extend( this, options || {} );
 
 			this.add( 'channel', params.channel );
 			this.add( 'url', params.url || '' );
 			this.add( 'origin', this.url() ).link( this.url ).setter( function( to ) {
-				return to.replace( /([^:]+:\/\/[^\/]+).*/, '$1' );
+				var urlParser = document.createElement( 'a' );
+				urlParser.href = to;
+				return urlParser.protocol + '//' + urlParser.hostname;
 			});
 
 			// first add with no value
@@ -807,6 +809,40 @@ window.wp = window.wp || {};
 		return result;
 	};
 
+	/**
+	 * Utility function namespace
+	 */
+	api.utils = {};
+
+	/**
+	 * Parse query string.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @param {string} queryString Query string.
+	 * @returns {object} Parsed query string.
+	 */
+	api.utils.parseQueryString = function parseQueryString( queryString ) {
+		var queryParams = {};
+		_.each( queryString.split( '&' ), function( pair ) {
+			var parts, key, value;
+			parts = pair.split( '=', 2 );
+			if ( ! parts[0] ) {
+				return;
+			}
+			key = decodeURIComponent( parts[0].replace( /\+/g, ' ' ) );
+			key = key.replace( / /g, '_' ); // What PHP does.
+			if ( _.isUndefined( parts[1] ) ) {
+				value = null;
+			} else {
+				value = decodeURIComponent( parts[1].replace( /\+/g, ' ' ) );
+			}
+			queryParams[ key ] = value;
+		} );
+		return queryParams;
+	};
+
 	// Expose the API publicly on window.wp.customize
 	exports.customize = api;
 })( wp, jQuery );
diff --git a/src/wp-includes/js/customize-loader.js b/src/wp-includes/js/customize-loader.js
index 85ad7455be..1990d1a24d 100644
--- a/src/wp-includes/js/customize-loader.js
+++ b/src/wp-includes/js/customize-loader.js
@@ -132,6 +132,19 @@ window.wp = window.wp || {};
 				targetWindow: this.iframe[0].contentWindow
 			});
 
+			// Expose the changeset UUID on the parent window's URL so that the customized state can survive a refresh.
+			if ( history.replaceState ) {
+				this.messenger.bind( 'changeset-uuid', function( changesetUuid ) {
+					var urlParser = document.createElement( 'a' );
+					urlParser.href = location.href;
+					urlParser.search = $.param( _.extend(
+						api.utils.parseQueryString( urlParser.search.substr( 1 ) ),
+						{ changeset_uuid: changesetUuid }
+					) );
+					history.replaceState( { customize: urlParser.href }, '', urlParser.href );
+				} );
+			}
+
 			// Wait for the connection from the iframe before sending any postMessage events.
 			this.messenger.bind( 'ready', function() {
 				Loader.messenger.send( 'back' );
diff --git a/src/wp-includes/js/customize-preview-nav-menus.js b/src/wp-includes/js/customize-preview-nav-menus.js
index bd42f5e081..6b241cd72d 100644
--- a/src/wp-includes/js/customize-preview-nav-menus.js
+++ b/src/wp-includes/js/customize-preview-nav-menus.js
@@ -106,7 +106,7 @@ wp.customize.navMenusPreview = wp.customize.MenusCustomizerPreview = ( function(
 			 * @returns {boolean}
 			 */
 			isRelatedSetting: function( setting, newValue, oldValue ) {
-				var partial = this, navMenuLocationSetting, navMenuId, isNavMenuItemSetting;
+				var partial = this, navMenuLocationSetting, navMenuId, isNavMenuItemSetting, _newValue, _oldValue, urlParser;
 				if ( _.isString( setting ) ) {
 					setting = api( setting );
 				}
@@ -123,9 +123,23 @@ wp.customize.navMenusPreview = wp.customize.MenusCustomizerPreview = ( function(
 				 */
 				isNavMenuItemSetting = /^nav_menu_item\[/.test( setting.id );
 				if ( isNavMenuItemSetting && _.isObject( newValue ) && _.isObject( oldValue ) ) {
-					delete newValue.type_label;
-					delete oldValue.type_label;
-					if ( _.isEqual( oldValue, newValue ) ) {
+					_newValue = _.clone( newValue );
+					_oldValue = _.clone( oldValue );
+					delete _newValue.type_label;
+					delete _oldValue.type_label;
+
+					// Normalize URL scheme when parent frame is HTTPS to prevent selective refresh upon initial page load.
+					if ( 'https' === api.preview.scheme.get() ) {
+						urlParser = document.createElement( 'a' );
+						urlParser.href = _newValue.url;
+						urlParser.protocol = 'https:';
+						_newValue.url = urlParser.href;
+						urlParser.href = _oldValue.url;
+						urlParser.protocol = 'https:';
+						_oldValue.url = urlParser.href;
+					}
+
+					if ( _.isEqual( _oldValue, _newValue ) ) {
 						return false;
 					}
 				}
@@ -365,6 +379,11 @@ wp.customize.navMenusPreview = wp.customize.MenusCustomizerPreview = ( function(
 	self.highlightControls = function() {
 		var selector = '.menu-item';
 
+		// Skip adding highlights if not in the customizer preview iframe.
+		if ( ! api.settings.channel ) {
+			return;
+		}
+
 		// Focus on the menu item control when shift+clicking the menu item.
 		$( document ).on( 'click', selector, function( e ) {
 			var navMenuItemParts;
diff --git a/src/wp-includes/js/customize-preview-widgets.js b/src/wp-includes/js/customize-preview-widgets.js
index 5adaf05373..967d56af8e 100644
--- a/src/wp-includes/js/customize-preview-widgets.js
+++ b/src/wp-includes/js/customize-preview-widgets.js
@@ -572,6 +572,11 @@ wp.customize.widgetsPreview = wp.customize.WidgetCustomizerPreview = (function(
 		var self = this,
 			selector = this.widgetSelectors.join( ',' );
 
+		// Skip adding highlights if not in the customizer preview iframe.
+		if ( ! api.settings.channel ) {
+			return;
+		}
+
 		$( selector ).attr( 'title', this.l10n.widgetTooltip );
 
 		$( document ).on( 'mouseenter', selector, function() {
diff --git a/src/wp-includes/js/customize-preview.js b/src/wp-includes/js/customize-preview.js
index 1d61ba33e3..22a9e4ec1f 100644
--- a/src/wp-includes/js/customize-preview.js
+++ b/src/wp-includes/js/customize-preview.js
@@ -3,7 +3,67 @@
  */
 (function( exports, $ ){
 	var api = wp.customize,
-		debounce;
+		debounce,
+		currentHistoryState = {};
+
+	/*
+	 * Capture the state that is passed into history.replaceState() and history.pushState()
+	 * and also which is returned in the popstate event so that when the changeset_uuid
+	 * gets updated when transitioning to a new changeset there the current state will
+	 * be supplied in the call to history.replaceState().
+	 */
+	( function( history ) {
+		var injectUrlWithState;
+
+		if ( ! history.replaceState ) {
+			return;
+		}
+
+		/**
+		 * Amend the supplied URL with the customized state.
+		 *
+		 * @since 4.7.0
+		 * @access private
+		 *
+		 * @param {string} url URL.
+		 * @returns {string} URL with customized state.
+		 */
+		injectUrlWithState = function( url ) {
+			var urlParser, queryParams;
+			urlParser = document.createElement( 'a' );
+			urlParser.href = url;
+			queryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
+
+			queryParams.customize_changeset_uuid = api.settings.changeset.uuid;
+			if ( ! api.settings.theme.active ) {
+				queryParams.customize_theme = api.settings.theme.stylesheet;
+			}
+			if ( api.settings.theme.channel ) {
+				queryParams.customize_messenger_channel = api.settings.channel;
+			}
+			urlParser.search = $.param( queryParams );
+			return url;
+		};
+
+		history.replaceState = ( function( nativeReplaceState ) {
+			return function historyReplaceState( data, title, url ) {
+				currentHistoryState = data;
+				return nativeReplaceState.call( history, data, title, injectUrlWithState( url ) );
+			};
+		} )( history.replaceState );
+
+		history.pushState = ( function( nativePushState ) {
+			return function historyPushState( data, title, url ) {
+				currentHistoryState = data;
+				return nativePushState.call( history, data, title, injectUrlWithState( url ) );
+			};
+		} )( history.pushState );
+
+		window.addEventListener( 'popstate', function( event ) {
+			currentHistoryState = event.state;
+		} );
+
+	}( history ) );
 
 	/**
 	 * Returns a debounced version of the function.
@@ -37,38 +97,73 @@
 		 * @param {object} options - Extend any instance parameter or method with this object.
 		 */
 		initialize: function( params, options ) {
-			var self = this;
+			var preview = this, urlParser = document.createElement( 'a' );
 
-			api.Messenger.prototype.initialize.call( this, params, options );
+			api.Messenger.prototype.initialize.call( preview, params, options );
 
-			this.body = $( document.body );
-			this.body.on( 'click.preview', 'a', function( event ) {
+			urlParser.href = preview.origin();
+			preview.add( 'scheme', urlParser.protocol.replace( /:$/, '' ) );
+
+			preview.body = $( document.body );
+			preview.body.on( 'click.preview', 'a', function( event ) {
 				var link, isInternalJumpLink;
 				link = $( this );
-				isInternalJumpLink = ( '#' === link.attr( 'href' ).substr( 0, 1 ) );
-				event.preventDefault();
 
-				if ( isInternalJumpLink && '#' !== link.attr( 'href' ) ) {
-					$( link.attr( 'href' ) ).each( function() {
-						this.scrollIntoView();
-					} );
+				// No-op if the anchor is not a link.
+				if ( _.isUndefined( link.attr( 'href' ) ) ) {
+					return;
 				}
 
+				isInternalJumpLink = ( '#' === link.attr( 'href' ).substr( 0, 1 ) );
+
+				// Allow internal jump links to behave normally without preventing default.
+				if ( isInternalJumpLink ) {
+					return;
+				}
+
+				// If the link is not previewable, prevent the browser from navigating to it.
+				if ( ! api.isLinkPreviewable( link[0] ) ) {
+					wp.a11y.speak( api.settings.l10n.linkUnpreviewable );
+					event.preventDefault();
+					return;
+				}
+
+				// If not in an iframe, then allow the link click to proceed normally since the state query params are added.
+				if ( ! api.settings.channel ) {
+					return;
+				}
+
+				// Prevent initiating navigating from click and instead rely on sending url message to pane.
+				event.preventDefault();
+
 				/*
 				 * Note the shift key is checked so shift+click on widgets or
 				 * nav menu items can just result on focusing on the corresponding
 				 * control instead of also navigating to the URL linked to.
 				 */
-				if ( event.shiftKey || isInternalJumpLink ) {
+				if ( event.shiftKey ) {
 					return;
 				}
-				self.send( 'scroll', 0 );
-				self.send( 'url', link.prop( 'href' ) );
-			});
 
-			// You cannot submit forms.
-			this.body.on( 'submit.preview', 'form', function( event ) {
-				var urlParser;
+				// Note: It's not relevant to send scroll because sending url message will have the same effect.
+				preview.send( 'url', link.prop( 'href' ) );
+			} );
+
+			preview.body.on( 'submit.preview', 'form', function( event ) {
+				var urlParser = document.createElement( 'a' );
+				urlParser.href = this.action;
+
+				// If the link is not previewable, prevent the browser from navigating to it.
+				if ( 'GET' !== this.method.toUpperCase() || ! api.isLinkPreviewable( urlParser ) ) {
+					wp.a11y.speak( api.settings.l10n.formUnpreviewable );
+					event.preventDefault();
+					return;
+				}
+
+				// If not in an iframe, then allow the form submission to proceed normally with the state inputs injected.
+				if ( ! api.settings.channel ) {
+					return;
+				}
 
 				/*
 				 * If the default wasn't prevented already (in which case the form
@@ -81,30 +176,399 @@
 				 * a no-op, which is the same behavior as when clicking a link to an
 				 * external site in the preview.
 				 */
-				if ( ! event.isDefaultPrevented() && 'GET' === this.method.toUpperCase() ) {
-					urlParser = document.createElement( 'a' );
-					urlParser.href = this.action;
-					if ( urlParser.search.substr( 1 ).length > 1 ) {
+				if ( ! event.isDefaultPrevented() ) {
+					if ( urlParser.search.length > 1 ) {
 						urlParser.search += '&';
 					}
 					urlParser.search += $( this ).serialize();
 					api.preview.send( 'url', urlParser.href );
 				}
 
+				// Prevent default since navigation should be done via sending url message or via JS submit handler.
 				event.preventDefault();
 			});
 
-			this.window = $( window );
-			this.window.on( 'scroll.preview', debounce( function() {
-				self.send( 'scroll', self.window.scrollTop() );
-			}, 200 ));
+			preview.window = $( window );
 
-			this.bind( 'scroll', function( distance ) {
-				self.window.scrollTop( distance );
-			});
+			if ( api.settings.channel ) {
+				preview.window.on( 'scroll.preview', debounce( function() {
+					preview.send( 'scroll', preview.window.scrollTop() );
+				}, 200 ) );
+
+				preview.bind( 'scroll', function( distance ) {
+					preview.window.scrollTop( distance );
+				});
+			}
 		}
 	});
 
+	/**
+	 * Inject the changeset UUID into links in the document.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @access private
+	 * @returns {void}
+	 */
+	api.addLinkPreviewing = function addLinkPreviewing() {
+		var linkSelectors = 'a[href], area';
+
+		// Inject links into initial document.
+		$( document.body ).find( linkSelectors ).each( function() {
+			api.prepareLinkPreview( this );
+		} );
+
+		// Inject links for new elements added to the page.
+		if ( 'undefined' !== typeof MutationObserver ) {
+			api.mutationObserver = new MutationObserver( function( mutations ) {
+				_.each( mutations, function( mutation ) {
+					$( mutation.target ).find( linkSelectors ).each( function() {
+						api.prepareLinkPreview( this );
+					} );
+				} );
+			} );
+			api.mutationObserver.observe( document.documentElement, {
+				childList: true,
+				subtree: true
+			} );
+		} else {
+
+			// If mutation observers aren't available, fallback to just-in-time injection.
+			$( document.documentElement ).on( 'click focus mouseover', linkSelectors, function() {
+				api.prepareLinkPreview( this );
+			} );
+		}
+	};
+
+	/**
+	 * Should the supplied link is previewable.
+	 *
+	 * @since 4.7.0
+	 * @access public
+	 *
+	 * @param {HTMLAnchorElement|HTMLAreaElement} element Link element.
+	 * @param {string} element.search Query string.
+	 * @param {string} element.pathname Path.
+	 * @param {string} element.hostname Hostname.
+	 * @param {object} [options]
+	 * @param {object} [options.allowAdminAjax=false] Allow admin-ajax.php requests.
+	 * @returns {boolean} Is appropriate for changeset link.
+	 */
+	api.isLinkPreviewable = function isLinkPreviewable( element, options ) {
+		var hasMatchingHost, urlParser, args;
+
+		args = _.extend( {}, { allowAdminAjax: false }, options || {} );
+
+		if ( 'javascript:' === element.protocol ) { // jshint ignore:line
+			return true;
+		}
+
+		// Only web URLs can be previewed.
+		if ( 'https:' !== element.protocol && 'http:' !== element.protocol ) {
+			return false;
+		}
+
+		urlParser = document.createElement( 'a' );
+		hasMatchingHost = ! _.isUndefined( _.find( api.settings.url.allowed, function( allowedUrl ) {
+			urlParser.href = allowedUrl;
+			if ( urlParser.hostname === element.hostname && urlParser.protocol === element.protocol ) {
+				return true;
+			}
+			return false;
+		} ) );
+		if ( ! hasMatchingHost ) {
+			return false;
+		}
+
+		// Skip wp login and signup pages.
+		if ( /\/wp-(login|signup)\.php$/.test( element.pathname ) ) {
+			return false;
+		}
+
+		// Allow links to admin ajax as faux frontend URLs.
+		if ( /\/wp-admin\/admin-ajax\.php$/.test( element.pathname ) ) {
+			return args.allowAdminAjax;
+		}
+
+		// Disallow links to admin, includes, and content.
+		if ( /\/wp-(admin|includes|content)(\/|$)/.test( element.pathname ) ) {
+			return false;
+		}
+
+		return true;
+	};
+
+	/**
+	 * Inject the customize_changeset_uuid query param into links on the frontend.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @param {HTMLAnchorElement|HTMLAreaElement} element Link element.
+	 * @param {object} element.search Query string.
+	 * @returns {void}
+	 */
+	api.prepareLinkPreview = function prepareLinkPreview( element ) {
+		var queryParams;
+
+		// Skip links in admin bar.
+		if ( $( element ).closest( '#wpadminbar' ).length ) {
+			return;
+		}
+
+		// Ignore links with href="#" or href="#id".
+		if ( '#' === $( element ).attr( 'href' ).substr( 0, 1 ) ) {
+			return;
+		}
+
+		// Make sure links in preview use HTTPS if parent frame uses HTTPS.
+		if ( 'https' === api.preview.scheme.get() && 'http:' === element.protocol && -1 !== api.settings.url.allowedHosts.indexOf( element.hostname ) ) {
+			element.protocol = 'https:';
+		}
+
+		if ( ! api.isLinkPreviewable( element ) ) {
+			$( element ).addClass( 'customize-unpreviewable' );
+			return;
+		}
+		$( element ).removeClass( 'customize-unpreviewable' );
+
+		queryParams = api.utils.parseQueryString( element.search.substring( 1 ) );
+		queryParams.customize_changeset_uuid = api.settings.changeset.uuid;
+		if ( ! api.settings.theme.active ) {
+			queryParams.customize_theme = api.settings.theme.stylesheet;
+		}
+		if ( api.settings.channel ) {
+			queryParams.customize_messenger_channel = api.settings.channel;
+		}
+		element.search = $.param( queryParams );
+
+		// Prevent links from breaking out of preview iframe.
+		if ( api.settings.channel ) {
+			element.target = '_self';
+		}
+	};
+
+	/**
+	 * Inject the changeset UUID into Ajax requests.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @return {void}
+	 */
+	api.addRequestPreviewing = function addRequestPreviewing() {
+
+		/**
+		 * Rewrite Ajax requests to inject customizer state.
+		 *
+		 * @param {object} options Options.
+		 * @param {string} options.type Type.
+		 * @param {string} options.url URL.
+		 * @param {object} originalOptions Original options.
+		 * @param {XMLHttpRequest} xhr XHR.
+		 * @returns {void}
+		 */
+		var prefilterAjax = function( options, originalOptions, xhr ) {
+			var urlParser, queryParams, requestMethod, dirtyValues = {};
+			urlParser = document.createElement( 'a' );
+			urlParser.href = options.url;
+
+			// Abort if the request is not for this site.
+			if ( ! api.isLinkPreviewable( urlParser, { allowAdminAjax: true } ) ) {
+				return;
+			}
+			queryParams = api.utils.parseQueryString( urlParser.search.substring( 1 ) );
+
+			// Note that _dirty flag will be cleared with changeset updates.
+			api.each( function( setting ) {
+				if ( setting._dirty ) {
+					dirtyValues[ setting.id ] = setting.get();
+				}
+			} );
+
+			if ( ! _.isEmpty( dirtyValues ) ) {
+				requestMethod = options.type.toUpperCase();
+
+				// Override underlying request method to ensure unsaved changes to changeset can be included (force Backbone.emulateHTTP).
+				if ( 'POST' !== requestMethod ) {
+					xhr.setRequestHeader( 'X-HTTP-Method-Override', requestMethod );
+					queryParams._method = requestMethod;
+					options.type = 'POST';
+				}
+
+				// Amend the post data with the customized values.
+				if ( options.data ) {
+					options.data += '&';
+				} else {
+					options.data = '';
+				}
+				options.data += $.param( {
+					customized: JSON.stringify( dirtyValues )
+				} );
+			}
+
+			// Include customized state query params in URL.
+			queryParams.customize_changeset_uuid = api.settings.changeset.uuid;
+			if ( ! api.settings.theme.active ) {
+				queryParams.customize_theme = api.settings.theme.stylesheet;
+			}
+			urlParser.search = $.param( queryParams );
+			options.url = urlParser.href;
+		};
+
+		$.ajaxPrefilter( prefilterAjax );
+	};
+
+	/**
+	 * Inject changeset UUID into forms, allowing preview to persist through submissions.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @returns {void}
+	 */
+	api.addFormPreviewing = function addFormPreviewing() {
+
+		// Inject inputs for forms in initial document.
+		$( document.body ).find( 'form' ).each( function() {
+			api.prepareFormPreview( this );
+		} );
+
+		// Inject inputs for new forms added to the page.
+		if ( 'undefined' !== typeof MutationObserver ) {
+			api.mutationObserver = new MutationObserver( function( mutations ) {
+				_.each( mutations, function( mutation ) {
+					$( mutation.target ).find( 'form' ).each( function() {
+						api.prepareFormPreview( this );
+					} );
+				} );
+			} );
+			api.mutationObserver.observe( document.documentElement, {
+				childList: true,
+				subtree: true
+			} );
+		}
+	};
+
+	/**
+	 * Inject changeset into form inputs.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 *
+	 * @param {HTMLFormElement} form Form.
+	 * @returns {void}
+	 */
+	api.prepareFormPreview = function prepareFormPreview( form ) {
+		var urlParser, stateParams = {};
+
+		if ( ! form.action ) {
+			form.action = location.href;
+		}
+
+		urlParser = document.createElement( 'a' );
+		urlParser.href = form.action;
+
+		// Make sure forms in preview use HTTPS if parent frame uses HTTPS.
+		if ( 'https' === api.preview.scheme.get() && 'http:' === urlParser.protocol && -1 !== api.settings.url.allowedHosts.indexOf( urlParser.hostname ) ) {
+			urlParser.protocol = 'https:';
+			form.action = urlParser.href;
+		}
+
+		if ( 'GET' !== form.method.toUpperCase() || ! api.isLinkPreviewable( urlParser ) ) {
+			$( form ).addClass( 'customize-unpreviewable' );
+			return;
+		}
+		$( form ).removeClass( 'customize-unpreviewable' );
+
+		stateParams.customize_changeset_uuid = api.settings.changeset.uuid;
+		if ( ! api.settings.theme.active ) {
+			stateParams.customize_theme = api.settings.theme.stylesheet;
+		}
+		if ( api.settings.channel ) {
+			stateParams.customize_messenger_channel = api.settings.channel;
+		}
+
+		_.each( stateParams, function( value, name ) {
+			var input = $( form ).find( 'input[name="' + name + '"]' );
+			if ( input.length ) {
+				input.val( value );
+			} else {
+				$( form ).prepend( $( '<input>', {
+					type: 'hidden',
+					name: name,
+					value: value
+				} ) );
+			}
+		} );
+
+		// Prevent links from breaking out of preview iframe.
+		if ( api.settings.channel ) {
+			form.target = '_self';
+		}
+	};
+
+	/**
+	 * Watch current URL and send keep-alive (heartbeat) messages to the parent.
+	 *
+	 * Keep the customizer pane notified that the preview is still alive
+	 * and that the user hasn't navigated to a non-customized URL.
+	 *
+	 * @since 4.7.0
+	 * @access protected
+	 */
+	api.keepAliveCurrentUrl = ( function() {
+		var previousPathName = location.pathname,
+			previousQueryString = location.search.substr( 1 ),
+			previousQueryParams = null,
+			stateQueryParams = [ 'customize_theme', 'customize_changeset_uuid', 'customize_messenger_channel' ];
+
+		return function keepAliveCurrentUrl() {
+			var urlParser, currentQueryParams;
+
+			// Short-circuit with keep-alive if previous URL is identical (as is normal case).
+			if ( previousQueryString === location.search.substr( 1 ) && previousPathName === location.pathname ) {
+				api.preview.send( 'keep-alive' );
+				return;
+			}
+
+			urlParser = document.createElement( 'a' );
+			if ( null === previousQueryParams ) {
+				urlParser.search = previousQueryString;
+				previousQueryParams = api.utils.parseQueryString( previousQueryString );
+				_.each( stateQueryParams, function( name ) {
+					delete previousQueryParams[ name ];
+				} );
+			}
+
+			// Determine if current URL minus customized state params and URL hash.
+			urlParser.href = location.href;
+			currentQueryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
+			_.each( stateQueryParams, function( name ) {
+				delete currentQueryParams[ name ];
+			} );
+
+			if ( previousPathName !== location.pathname || ! _.isEqual( previousQueryParams, currentQueryParams ) ) {
+				urlParser.search = $.param( currentQueryParams );
+				urlParser.hash = '';
+				api.settings.url.self = urlParser.href;
+				api.preview.send( 'ready', {
+					currentUrl: api.settings.url.self,
+					activePanels: api.settings.activePanels,
+					activeSections: api.settings.activeSections,
+					activeControls: api.settings.activeControls,
+					settingValidities: api.settings.settingValidities
+				} );
+			} else {
+				api.preview.send( 'keep-alive' );
+			}
+			previousQueryParams = currentQueryParams;
+			previousQueryString = location.search.substr( 1 );
+			previousPathName = location.pathname;
+		};
+	} )();
+
 	$( function() {
 		var bg, setValue;
 
@@ -118,6 +582,10 @@
 			channel: api.settings.channel
 		});
 
+		api.addLinkPreviewing();
+		api.addRequestPreviewing();
+		api.addFormPreviewing();
+
 		/**
 		 * Create/update a setting value.
 		 *
@@ -171,15 +639,47 @@
 			api.preview.send( 'nonce', api.settings.nonce );
 
 			api.preview.send( 'documentTitle', document.title );
+
+			// Send scroll in case of loading via non-refresh.
+			api.preview.send( 'scroll', $( window ).scrollTop() );
 		});
 
 		api.preview.bind( 'saved', function( response ) {
+
+			if ( response.next_changeset_uuid ) {
+				api.settings.changeset.uuid = response.next_changeset_uuid;
+
+				// Update UUIDs in links and forms.
+				$( document.body ).find( 'a[href], area' ).each( function() {
+					api.prepareLinkPreview( this );
+				} );
+				$( document.body ).find( 'form' ).each( function() {
+					api.prepareFormPreview( this );
+				} );
+
+				/*
+				 * Replace the UUID in the URL. Note that the wrapped history.replaceState()
+				 * will handle injecting the current api.settings.changeset.uuid into the URL,
+				 * so this is merely to trigger that logic.
+				 */
+				if ( history.replaceState ) {
+					history.replaceState( currentHistoryState, '', location.href );
+				}
+			}
+
 			api.trigger( 'saved', response );
 		} );
 
-		api.bind( 'saved', function() {
-			api.each( function( setting ) {
-				setting._dirty = false;
+		/*
+		 * Clear dirty flag for settings when saved to changeset so that they
+		 * won't be needlessly included in selective refresh or ajax requests.
+		 */
+		api.preview.bind( 'changeset-saved', function( data ) {
+			_.each( data.saved_changeset_values, function( value, settingId ) {
+				var setting = api( settingId );
+				if ( setting && _.isEqual( setting.get(), value ) ) {
+					setting._dirty = false;
+				}
 			} );
 		} );
 
@@ -192,12 +692,16 @@
 		 * containers and controls are active.
 		 */
 		api.preview.send( 'ready', {
+			currentUrl: api.settings.url.self,
 			activePanels: api.settings.activePanels,
 			activeSections: api.settings.activeSections,
 			activeControls: api.settings.activeControls,
 			settingValidities: api.settings.settingValidities
 		} );
 
+		// Send ready when URL changes via JS.
+		setInterval( api.keepAliveCurrentUrl, api.settings.timeouts.keepAliveSend );
+
 		// Display a loading indicator when preview is reloading, and remove on failure.
 		api.preview.bind( 'loading-initiated', function () {
 			$( 'body' ).addClass( 'wp-customizer-unloading' );
diff --git a/src/wp-includes/js/customize-selective-refresh.js b/src/wp-includes/js/customize-selective-refresh.js
index 6bab103ff9..427a7c3c9b 100644
--- a/src/wp-includes/js/customize-selective-refresh.js
+++ b/src/wp-includes/js/customize-selective-refresh.js
@@ -11,8 +11,7 @@ wp.customize.selectiveRefresh = ( function( $, api ) {
 			renderQueryVar: '',
 			l10n: {
 				shiftClickToEdit: ''
-			},
-			refreshBuffer: 250
+			}
 		},
 		currentRequest: null
 	};
@@ -485,8 +484,9 @@ wp.customize.selectiveRefresh = ( function( $, api ) {
 		return {
 			wp_customize: 'on',
 			nonce: api.settings.nonce.preview,
-			theme: api.settings.theme.stylesheet,
-			customized: JSON.stringify( dirtyCustomized )
+			customize_theme: api.settings.theme.stylesheet,
+			customized: JSON.stringify( dirtyCustomized ),
+			customize_changeset_uuid: api.settings.changeset.uuid
 		};
 	};
 
@@ -668,7 +668,7 @@ wp.customize.selectiveRefresh = ( function( $, api ) {
 					self._pendingPartialRequests = {};
 				} );
 			},
-			self.data.refreshBuffer
+			api.settings.timeouts.selectiveRefresh
 		);
 
 		return partialRequest.deferred.promise();
diff --git a/src/wp-includes/post.php b/src/wp-includes/post.php
index 405a183119..463c874767 100644
--- a/src/wp-includes/post.php
+++ b/src/wp-includes/post.php
@@ -111,6 +111,51 @@ function create_initial_post_types() {
 		'query_var' => false,
 	) );
 
+	register_post_type( 'customize_changeset', array(
+		'labels' => array(
+			'name'               => _x( 'Changesets', 'post type general name' ),
+			'singular_name'      => _x( 'Changeset', 'post type singular name' ),
+			'menu_name'          => _x( 'Changesets', 'admin menu' ),
+			'name_admin_bar'     => _x( 'Changeset', 'add new on admin bar' ),
+			'add_new'            => _x( 'Add New', 'Customize Changeset' ),
+			'add_new_item'       => __( 'Add New Changeset' ),
+			'new_item'           => __( 'New Changeset' ),
+			'edit_item'          => __( 'Edit Changeset' ),
+			'view_item'          => __( 'View Changeset' ),
+			'all_items'          => __( 'All Changesets' ),
+			'search_items'       => __( 'Search Changesets' ),
+			'not_found'          => __( 'No changesets found.' ),
+			'not_found_in_trash' => __( 'No changesets found in Trash.' ),
+		),
+		'public' => false,
+		'_builtin' => true, /* internal use only. don't use this when registering your own post type. */
+		'map_meta_cap' => true,
+		'hierarchical' => false,
+		'rewrite' => false,
+		'query_var' => false,
+		'can_export' => false,
+		'delete_with_user' => false,
+		'supports' => array( 'title', 'author' ),
+		'capability_type' => 'customize_changeset',
+		'capabilities' => array(
+			'create_posts' => 'customize',
+			'delete_others_posts' => 'customize',
+			'delete_post' => 'customize',
+			'delete_posts' => 'customize',
+			'delete_private_posts' => 'customize',
+			'delete_published_posts' => 'customize',
+			'edit_others_posts' => 'customize',
+			'edit_post' => 'customize',
+			'edit_posts' => 'customize',
+			'edit_private_posts' => 'customize',
+			'edit_published_posts' => 'do_not_allow',
+			'publish_posts' => 'customize',
+			'read' => 'read',
+			'read_post' => 'customize',
+			'read_private_posts' => 'customize',
+		),
+	) );
+
 	register_post_status( 'publish', array(
 		'label'       => _x( 'Published', 'post status' ),
 		'public'      => true,
diff --git a/src/wp-includes/script-loader.php b/src/wp-includes/script-loader.php
index e67997a994..c8ec2c5938 100644
--- a/src/wp-includes/script-loader.php
+++ b/src/wp-includes/script-loader.php
@@ -450,7 +450,7 @@ function wp_default_scripts( &$scripts ) {
 
 	$scripts->add( 'customize-base',     "/wp-includes/js/customize-base$suffix.js",     array( 'jquery', 'json2', 'underscore' ), false, 1 );
 	$scripts->add( 'customize-loader',   "/wp-includes/js/customize-loader$suffix.js",   array( 'customize-base' ), false, 1 );
-	$scripts->add( 'customize-preview',  "/wp-includes/js/customize-preview$suffix.js",  array( 'customize-base' ), false, 1 );
+	$scripts->add( 'customize-preview',  "/wp-includes/js/customize-preview$suffix.js",  array( 'wp-a11y', 'customize-base' ), false, 1 );
 	$scripts->add( 'customize-models',   "/wp-includes/js/customize-models.js", array( 'underscore', 'backbone' ), false, 1 );
 	$scripts->add( 'customize-views',    "/wp-includes/js/customize-views.js",  array( 'jquery', 'underscore', 'imgareaselect', 'customize-models', 'media-editor', 'media-views' ), false, 1 );
 	$scripts->add( 'customize-controls', "/wp-admin/js/customize-controls$suffix.js", array( 'customize-base', 'wp-a11y', 'wp-util' ), false, 1 );
diff --git a/src/wp-includes/theme.php b/src/wp-includes/theme.php
index c8cf03fe6a..b5b8541a1e 100644
--- a/src/wp-includes/theme.php
+++ b/src/wp-includes/theme.php
@@ -2066,9 +2066,9 @@ function check_theme_switched() {
  * Includes and instantiates the WP_Customize_Manager class.
  *
  * Loads the Customizer at plugins_loaded when accessing the customize.php admin
- * page or when any request includes a wp_customize=on param, either as a GET
- * query var or as POST data. This param is a signal for whether to bootstrap
- * the Customizer when WordPress is loading, especially in the Customizer preview
+ * page or when any request includes a wp_customize=on param or a customize_changeset
+ * param (a UUID). This param is a signal for whether to bootstrap the Customizer when
+ * WordPress is loading, especially in the Customizer preview
  * or when making Customizer Ajax requests for widgets or menus.
  *
  * @since 3.4.0
@@ -2076,14 +2076,140 @@ function check_theme_switched() {
  * @global WP_Customize_Manager $wp_customize
  */
 function _wp_customize_include() {
-	if ( ! ( ( isset( $_REQUEST['wp_customize'] ) && 'on' == $_REQUEST['wp_customize'] )
-		|| ( is_admin() && 'customize.php' == basename( $_SERVER['PHP_SELF'] ) )
-	) ) {
+
+	$is_customize_admin_page = ( is_admin() && 'customize.php' == basename( $_SERVER['PHP_SELF'] ) );
+	$should_include = (
+		$is_customize_admin_page
+		||
+		( isset( $_REQUEST['wp_customize'] ) && 'on' == $_REQUEST['wp_customize'] )
+		||
+		( ! empty( $_GET['customize_changeset_uuid'] ) || ! empty( $_POST['customize_changeset_uuid'] ) )
+	);
+
+	if ( ! $should_include ) {
 		return;
 	}
 
-	require_once ABSPATH . WPINC . '/class-wp-customize-manager.php'; 
-	$GLOBALS['wp_customize'] = new WP_Customize_Manager();
+	/*
+	 * Note that wp_unslash() is not being used on the input vars because it is
+	 * called before wp_magic_quotes() gets called. Besides this fact, none of
+	 * the values should contain any characters needing slashes anyway.
+	 */
+	$keys = array( 'changeset_uuid', 'customize_changeset_uuid', 'customize_theme', 'theme', 'customize_messenger_channel' );
+	$input_vars = array_merge(
+		wp_array_slice_assoc( $_GET, $keys ),
+		wp_array_slice_assoc( $_POST, $keys )
+	);
+
+	$theme = null;
+	$changeset_uuid = null;
+	$messenger_channel = null;
+
+	if ( $is_customize_admin_page && isset( $input_vars['changeset_uuid'] ) ) {
+		$changeset_uuid = sanitize_key( $input_vars['changeset_uuid'] );
+	} elseif ( ! empty( $input_vars['customize_changeset_uuid'] ) ) {
+		$changeset_uuid = sanitize_key( $input_vars['customize_changeset_uuid'] );
+	}
+
+	// Note that theme will be sanitized via WP_Theme.
+	if ( $is_customize_admin_page && isset( $input_vars['theme'] ) ) {
+		$theme = $input_vars['theme'];
+	} elseif ( isset( $input_vars['customize_theme'] ) ) {
+		$theme = $input_vars['customize_theme'];
+	}
+	if ( isset( $input_vars['customize_messenger_channel'] ) ) {
+		$messenger_channel = sanitize_key( $input_vars['customize_messenger_channel'] );
+	}
+
+	require_once ABSPATH . WPINC . '/class-wp-customize-manager.php';
+	$GLOBALS['wp_customize'] = new WP_Customize_Manager( compact( 'changeset_uuid', 'theme', 'messenger_channel' ) );
+}
+
+/**
+ * Publish a snapshot's changes.
+ *
+ * @param string  $new_status     New post status.
+ * @param string  $old_status     Old post status.
+ * @param WP_Post $changeset_post Changeset post object.
+ */
+function _wp_customize_publish_changeset( $new_status, $old_status, $changeset_post ) {
+	global $wp_customize;
+
+	$is_publishing_changeset = (
+		'customize_changeset' === $changeset_post->post_type
+		&&
+		'publish' === $new_status
+		&&
+		'publish' !== $old_status
+	);
+	if ( ! $is_publishing_changeset ) {
+		return;
+	}
+
+	if ( empty( $wp_customize ) ) {
+		require_once ABSPATH . WPINC . '/class-wp-customize-manager.php';
+		$wp_customize = new WP_Customize_Manager( $changeset_post->post_name );
+	}
+
+	if ( ! did_action( 'customize_register' ) ) {
+		/*
+		 * When running from CLI or Cron, the customize_register action will need
+		 * to be triggered in order for core, themes, and plugins to register their
+		 * settings. Normally core will add_action( 'customize_register' ) at
+		 * priority 10 to register the core settings, and if any themes/plugins
+		 * also add_action( 'customize_register' ) at the same priority, they
+		 * will have a $wp_customize with those settings registered since they
+		 * call add_action() afterward, normally. However, when manually doing
+		 * the customize_register action after the setup_theme, then the order
+		 * will be reversed for two actions added at priority 10, resulting in
+		 * the core settings no longer being available as expected to themes/plugins.
+		 * So the following manually calls the method that registers the core
+		 * settings up front before doing the action.
+		 */
+		remove_action( 'customize_register', array( $wp_customize, 'register_controls' ) );
+		$wp_customize->register_controls();
+
+		/** This filter is documented in /wp-includes/class-wp-customize-manager.php */
+		do_action( 'customize_register', $wp_customize );
+	}
+	$wp_customize->_publish_changeset_values( $changeset_post->ID ) ;
+
+	/*
+	 * Trash the changeset post if revisions are not enabled. Unpublished
+	 * changesets by default get garbage collected due to the auto-draft status.
+	 * When a changeset post is published, however, it would no longer get cleaned
+	 * out. Ths is a problem when the changeset posts are never displayed anywhere,
+	 * since they would just be endlessly piling up. So here we use the revisions
+	 * feature to indicate whether or not a published changeset should get trashed
+	 * and thus garbage collected.
+	 */
+	if ( ! wp_revisions_enabled( $changeset_post ) ) {
+		wp_trash_post( $changeset_post->ID );
+	}
+}
+
+/**
+ * Filters changeset post data upon insert to ensure post_name is intact.
+ *
+ * This is needed to prevent the post_name from being dropped when the post is
+ * transitioned into pending status by a contributor.
+ *
+ * @since 4.7.0
+ * @see wp_insert_post()
+ *
+ * @param array $post_data          An array of slashed post data.
+ * @param array $supplied_post_data An array of sanitized, but otherwise unmodified post data.
+ * @returns array Filtered data.
+ */
+function _wp_customize_changeset_filter_insert_post_data( $post_data, $supplied_post_data ) {
+	if ( isset( $post_data['post_type'] ) && 'customize_changeset' === $post_data['post_type'] ) {
+
+		// Prevent post_name from being dropped, such as when contributor saves a changeset post as pending.
+		if ( empty( $post_data['post_name'] ) && ! empty( $supplied_post_data['post_name'] ) ) {
+			$post_data['post_name'] = $supplied_post_data['post_name'];
+		}
+	}
+	return $post_data;
 }
 
 /**
diff --git a/tests/phpunit/tests/adminbar.php b/tests/phpunit/tests/adminbar.php
index 176b83c00a..11880a0526 100644
--- a/tests/phpunit/tests/adminbar.php
+++ b/tests/phpunit/tests/adminbar.php
@@ -550,4 +550,37 @@ class Tests_AdminBar extends WP_UnitTestCase {
 
 		$this->assertNull( $node );
 	}
+
+	/**
+	 * @ticket 30937
+	 * @covers wp_admin_bar_customize_menu()
+	 */
+	public function test_customize_link() {
+		global $wp_customize;
+		require_once ABSPATH . WPINC . '/class-wp-customize-manager.php';
+		$uuid = wp_generate_uuid4();
+		$this->go_to( home_url( "/?customize_changeset_uuid=$uuid" ) );
+		wp_set_current_user( self::$admin_id );
+
+		$this->factory()->post->create( array(
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_name' => $uuid,
+		) );
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+		) );
+		$wp_customize->start_previewing_theme();
+
+		set_current_screen( 'front' );
+		$wp_admin_bar = $this->get_standard_admin_bar();
+		$node = $wp_admin_bar->get_node( 'customize' );
+		$this->assertNotEmpty( $node );
+
+		$parsed_url = wp_parse_url( $node->href );
+		$query_params = array();
+		wp_parse_str( $parsed_url['query'], $query_params );
+		$this->assertEquals( $uuid, $query_params['changeset_uuid'] );
+		$this->assertNotContains( 'changeset_uuid', $query_params['url'] );
+	}
 }
diff --git a/tests/phpunit/tests/ajax/CustomizeManager.php b/tests/phpunit/tests/ajax/CustomizeManager.php
new file mode 100644
index 0000000000..a2b2b9f2e9
--- /dev/null
+++ b/tests/phpunit/tests/ajax/CustomizeManager.php
@@ -0,0 +1,310 @@
+<?php
+/**
+ * Testing ajax customize manager functionality
+ *
+ * @package    WordPress
+ * @subpackage UnitTests
+ * @since      4.3.0
+ * @group      ajax
+ */
+class Tests_Ajax_CustomizeManager extends WP_Ajax_UnitTestCase {
+
+	/**
+	 * Instance of WP_Customize_Manager which is reset for each test.
+	 *
+	 * @var WP_Customize_Manager
+	 */
+	public $wp_customize;
+
+	/**
+	 * Admin user ID.
+	 *
+	 * @var int
+	 */
+	protected static $admin_user_id;
+
+	/**
+	 * Subscriber user ID.
+	 *
+	 * @var int
+	 */
+	protected static $subscriber_user_id;
+
+	/**
+	 * Last response parsed.
+	 *
+	 * @var array|null
+	 */
+	protected $_last_response_parsed;
+
+	/**
+	 * Set up before class.
+	 *
+	 * @param WP_UnitTest_Factory $factory Factory.
+	 */
+	public static function wpSetUpBeforeClass( $factory ) {
+		self::$subscriber_user_id = $factory->user->create( array( 'role' => 'subscriber' ) );
+		self::$admin_user_id = $factory->user->create( array( 'role' => 'administrator' ) );
+	}
+
+	/**
+	 * Set up the test fixture.
+	 */
+	public function setUp() {
+		parent::setUp();
+		require_once ABSPATH . WPINC . '/class-wp-customize-manager.php';
+	}
+
+	/**
+	 * Tear down.
+	 */
+	public function tearDown() {
+		parent::tearDown();
+		$_REQUEST = array();
+	}
+
+	/**
+	 * Helper to keep it DRY
+	 *
+	 * @param string $action Action.
+	 */
+	protected function make_ajax_call( $action ) {
+		$this->_last_response_parsed = null;
+		$this->_last_response = '';
+		try {
+			$this->_handleAjax( $action );
+		} catch ( WPAjaxDieContinueException $e ) {
+			unset( $e );
+		}
+		if ( $this->_last_response ) {
+			$this->_last_response_parsed = json_decode( $this->_last_response, true );
+		}
+	}
+
+	/**
+	 * Overridden caps for user_has_cap.
+	 *
+	 * @var array
+	 */
+	protected $overridden_caps = array();
+
+	/**
+	 * Dynamically filter a user's capabilities.
+	 *
+	 * @param array $allcaps An array of all the user's capabilities.
+	 * @return array All caps.
+	 */
+	function filter_user_has_cap( $allcaps ) {
+		$allcaps = array_merge( $allcaps, $this->overridden_caps );
+		return $allcaps;
+	}
+
+	/**
+	 * Test WP_Customize_Manager::save().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::save()
+	 */
+	function test_save_failures() {
+		global $wp_customize;
+		$wp_customize = new WP_Customize_Manager();
+		$wp_customize->register_controls();
+		add_filter( 'user_has_cap', array( $this, 'filter_user_has_cap' ) );
+
+		// Unauthenticated.
+		wp_set_current_user( 0 );
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'unauthenticated', $this->_last_response_parsed['data'] );
+
+		// Unauthorized.
+		wp_set_current_user( self::$subscriber_user_id );
+		$nonce = wp_create_nonce( 'save-customize_' . $wp_customize->get_stylesheet() );
+		$_POST['nonce'] = $_GET['nonce'] = $_REQUEST['nonce'] = $nonce;
+		$exception = null;
+		try {
+			ob_start();
+			$wp_customize->setup_theme();
+		} catch ( WPAjaxDieContinueException $e ) {
+			$exception = $e;
+		}
+		$this->assertNotEmpty( $e );
+		$this->assertEquals( -1, $e->getMessage() );
+
+		// Not called setup_theme.
+		wp_set_current_user( self::$admin_user_id );
+		$nonce = wp_create_nonce( 'save-customize_' . $wp_customize->get_stylesheet() );
+		$_POST['nonce'] = $_GET['nonce'] = $_REQUEST['nonce'] = $nonce;
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'not_preview', $this->_last_response_parsed['data'] );
+
+		// Bad nonce.
+		$_POST['nonce'] = $_GET['nonce'] = $_REQUEST['nonce'] = 'bad';
+		$wp_customize->setup_theme();
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'invalid_nonce', $this->_last_response_parsed['data'] );
+
+		// User cannot create.
+		$nonce = wp_create_nonce( 'save-customize_' . $wp_customize->get_stylesheet() );
+		$_POST['nonce'] = $_GET['nonce'] = $_REQUEST['nonce'] = $nonce;
+		$post_type_obj = get_post_type_object( 'customize_changeset' );
+		$post_type_obj->cap->create_posts = 'create_customize_changesets';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'cannot_create_changeset_post', $this->_last_response_parsed['data'] );
+		$this->overridden_caps[ $post_type_obj->cap->create_posts ] = true;
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$post_type_obj->cap->create_posts = 'customize'; // Restore.
+
+		// Changeset already published.
+		$wp_customize->set_post_value( 'blogname', 'Hello' );
+		$wp_customize->save_changeset_post( array( 'status' => 'publish' ) );
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'changeset_already_published', $this->_last_response_parsed['data'] );
+		wp_update_post( array( 'ID' => $wp_customize->changeset_post_id(), 'post_status' => 'auto-draft' ) );
+
+		// User cannot edit.
+		$post_type_obj = get_post_type_object( 'customize_changeset' );
+		$post_type_obj->cap->edit_post = 'edit_customize_changesets';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'cannot_edit_changeset_post', $this->_last_response_parsed['data'] );
+		$this->overridden_caps[ $post_type_obj->cap->edit_post ] = true;
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$post_type_obj->cap->edit_post = 'customize'; // Restore.
+
+		// Bad customize_changeset_data.
+		$_POST['customize_changeset_data'] = '[MALFORMED]';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'invalid_customize_changeset_data', $this->_last_response_parsed['data'] );
+
+		// Bad customize_changeset_status.
+		$_POST['customize_changeset_data'] = '{}';
+		$_POST['customize_changeset_status'] = 'unrecognized';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'bad_customize_changeset_status', $this->_last_response_parsed['data'] );
+
+		// Disallowed publish posts if not allowed.
+		$post_type_obj = get_post_type_object( 'customize_changeset' );
+		$post_type_obj->cap->publish_posts = 'publish_customize_changesets';
+		$_POST['customize_changeset_status'] = 'publish';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'changeset_publish_unauthorized', $this->_last_response_parsed['data'] );
+		$_POST['customize_changeset_status'] = 'future';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'changeset_publish_unauthorized', $this->_last_response_parsed['data'] );
+		$post_type_obj->cap->publish_posts = 'customize'; // Restore.
+
+		// Validate date.
+		$_POST['customize_changeset_status'] = 'draft';
+		$_POST['customize_changeset_date'] = 'BAD DATE';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'bad_customize_changeset_date', $this->_last_response_parsed['data'] );
+		$_POST['customize_changeset_date'] = '2010-01-01 00:00:00';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertFalse( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'not_future_date', $this->_last_response_parsed['data'] );
+		$_POST['customize_changeset_date'] = ( gmdate( 'Y' ) + 1 ) . '-01-01 00:00:00';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$_POST['customize_changeset_status'] = 'future';
+		$_POST['customize_changeset_date'] = '+10 minutes';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$this->assertEquals( 'future', get_post_status( $wp_customize->changeset_post_id() ) );
+		wp_update_post( array( 'ID' => $wp_customize->changeset_post_id(), 'post_status' => 'auto-draft' ) );
+
+	}
+
+	/**
+	 * Set up valid user state.
+	 *
+	 * @param string $uuid Changeset UUID.
+	 * @return WP_Customize_Manager
+	 */
+	protected function set_up_valid_state( $uuid = null ) {
+		global $wp_customize;
+		wp_set_current_user( self::$admin_user_id );
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+		) );
+		$wp_customize->register_controls();
+		$nonce = wp_create_nonce( 'save-customize_' . $wp_customize->get_stylesheet() );
+		$_POST['nonce'] = $_GET['nonce'] = $_REQUEST['nonce'] = $nonce;
+		$wp_customize->setup_theme();
+		return $wp_customize;
+	}
+
+	/**
+	 * Test WP_Customize_Manager::save().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::save()
+	 */
+	function test_save_success_publish_create() {
+		$wp_customize = $this->set_up_valid_state();
+
+		// Successful future.
+		$_POST['customize_changeset_status'] = 'publish';
+		$_POST['customize_changeset_title'] = 'Success Changeset';
+		$_POST['customize_changeset_data'] = wp_json_encode( array(
+			'blogname' => array(
+				'value' => 'Successful Site Title',
+			),
+		) );
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$this->assertInternalType( 'array', $this->_last_response_parsed['data'] );
+
+		$this->assertEquals( 'publish', $this->_last_response_parsed['data']['changeset_status'] );
+		$this->assertArrayHasKey( 'next_changeset_uuid', $this->_last_response_parsed['data'] );
+		$this->assertEquals( 'Success Changeset', get_post( $wp_customize->changeset_post_id() )->post_title );
+		$this->assertEquals( 'Successful Site Title', get_option( 'blogname' ) );
+
+	}
+
+	/**
+	 * Test WP_Customize_Manager::save().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::save()
+	 */
+	function test_save_success_publish_edit() {
+		$uuid = wp_generate_uuid4();
+
+		$post_id = $this->factory()->post->create( array(
+			'post_name' => $uuid,
+			'post_title' => 'Original',
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_content' => wp_json_encode( array(
+				'blogname' => array(
+					'value' => 'New Site Title',
+				),
+			) ),
+		) );
+		$wp_customize = $this->set_up_valid_state( $uuid );
+
+		// Successful future.
+		$_POST['customize_changeset_status'] = 'publish';
+		$_POST['customize_changeset_title'] = 'Published';
+		$this->make_ajax_call( 'customize_save' );
+		$this->assertTrue( $this->_last_response_parsed['success'] );
+		$this->assertInternalType( 'array', $this->_last_response_parsed['data'] );
+
+		$this->assertEquals( 'publish', $this->_last_response_parsed['data']['changeset_status'] );
+		$this->assertArrayHasKey( 'next_changeset_uuid', $this->_last_response_parsed['data'] );
+		$this->assertEquals( 'New Site Title', get_option( 'blogname' ) );
+		$this->assertEquals( 'Published', get_post( $post_id )->post_title );
+	}
+}
diff --git a/tests/phpunit/tests/customize/manager.php b/tests/phpunit/tests/customize/manager.php
index f5e7c87a1b..42f3e10c36 100644
--- a/tests/phpunit/tests/customize/manager.php
+++ b/tests/phpunit/tests/customize/manager.php
@@ -26,6 +26,30 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 */
 	public $undefined;
 
+	/**
+	 * Admin user ID.
+	 *
+	 * @var int
+	 */
+	protected static $admin_user_id;
+
+	/**
+	 * Subscriber user ID.
+	 *
+	 * @var int
+	 */
+	protected static $subscriber_user_id;
+
+	/**
+	 * Set up before class.
+	 *
+	 * @param WP_UnitTest_Factory $factory Factory.
+	 */
+	public static function wpSetUpBeforeClass( $factory ) {
+		self::$subscriber_user_id = $factory->user->create( array( 'role' => 'subscriber' ) );
+		self::$admin_user_id = $factory->user->create( array( 'role' => 'administrator' ) );
+	}
+
 	/**
 	 * Set up test.
 	 */
@@ -42,6 +66,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	function tearDown() {
 		$this->manager = null;
 		unset( $GLOBALS['wp_customize'] );
+		$_REQUEST = array();
 		parent::tearDown();
 	}
 
@@ -55,6 +80,608 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		return $GLOBALS['wp_customize'];
 	}
 
+	/**
+	 * Test WP_Customize_Manager::__construct().
+	 *
+	 * @covers WP_Customize_Manager::__construct()
+	 */
+	function test_constructor() {
+		$uuid = wp_generate_uuid4();
+		$theme = 'twentyfifteen';
+		$messenger_channel = 'preview-123';
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'theme' => $theme,
+			'messenger_channel' => $messenger_channel,
+		) );
+		$this->assertEquals( $uuid, $wp_customize->changeset_uuid() );
+		$this->assertEquals( $theme, $wp_customize->get_stylesheet() );
+		$this->assertEquals( $messenger_channel, $wp_customize->get_messenger_channel() );
+
+		$theme = 'twentyfourteen';
+		$messenger_channel = 'preview-456';
+		$_REQUEST['theme'] = $theme;
+		$_REQUEST['customize_messenger_channel'] = $messenger_channel;
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$this->assertEquals( $theme, $wp_customize->get_stylesheet() );
+		$this->assertEquals( $messenger_channel, $wp_customize->get_messenger_channel() );
+
+		$theme = 'twentyfourteen';
+		$_REQUEST['customize_theme'] = $theme;
+		$wp_customize = new WP_Customize_Manager();
+		$this->assertEquals( $theme, $wp_customize->get_stylesheet() );
+		$this->assertNotEmpty( $wp_customize->changeset_uuid() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::setup_theme() for admin screen.
+	 *
+	 * @covers WP_Customize_Manager::setup_theme()
+	 */
+	function test_setup_theme_in_customize_admin() {
+		global $pagenow, $wp_customize;
+		$pagenow = 'customize.php';
+		set_current_screen( 'customize' );
+
+		// Unauthorized.
+		$exception = null;
+		$wp_customize = new WP_Customize_Manager();
+		wp_set_current_user( self::$subscriber_user_id );
+		try {
+			$wp_customize->setup_theme();
+		} catch ( Exception $e ) {
+			$exception = $e;
+		}
+		$this->assertInstanceOf( 'WPDieException', $exception );
+		$this->assertContains( 'you are not allowed to customize this site', $exception->getMessage() );
+
+		// Bad changeset.
+		$exception = null;
+		wp_set_current_user( self::$admin_user_id );
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => 'bad' ) );
+		try {
+			$wp_customize->setup_theme();
+		} catch ( Exception $e ) {
+			$exception = $e;
+		}
+		$this->assertInstanceOf( 'WPDieException', $exception );
+		$this->assertContains( 'Invalid changeset UUID', $exception->getMessage() );
+
+		$wp_customize = new WP_Customize_Manager();
+		$wp_customize->setup_theme();
+	}
+
+	/**
+	 * Test WP_Customize_Manager::setup_theme() for frontend.
+	 *
+	 * @covers WP_Customize_Manager::setup_theme()
+	 */
+	function test_setup_theme_in_frontend() {
+		global $wp_customize, $pagenow, $show_admin_bar;
+		$pagenow = 'front';
+		set_current_screen( 'front' );
+
+		wp_set_current_user( 0 );
+		$exception = null;
+		$wp_customize = new WP_Customize_Manager();
+		wp_set_current_user( self::$subscriber_user_id );
+		try {
+			$wp_customize->setup_theme();
+		} catch ( Exception $e ) {
+			$exception = $e;
+		}
+		$this->assertInstanceOf( 'WPDieException', $exception );
+		$this->assertContains( 'Non-existent changeset UUID', $exception->getMessage() );
+
+		wp_set_current_user( self::$admin_user_id );
+		$wp_customize = new WP_Customize_Manager( array( 'messenger_channel' => 'preview-1' ) );
+		$wp_customize->setup_theme();
+		$this->assertFalse( $show_admin_bar );
+
+		show_admin_bar( true );
+		wp_set_current_user( self::$admin_user_id );
+		$wp_customize = new WP_Customize_Manager( array( 'messenger_channel' => null ) );
+		$wp_customize->setup_theme();
+		$this->assertTrue( $show_admin_bar );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::changeset_uuid().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::changeset_uuid()
+	 */
+	function test_changeset_uuid() {
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$this->assertEquals( $uuid, $wp_customize->changeset_uuid() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::wp_loaded().
+	 *
+	 * Ensure that post values are previewed even without being in preview.
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::wp_loaded()
+	 */
+	function test_wp_loaded() {
+		wp_set_current_user( self::$admin_user_id );
+		$wp_customize = new WP_Customize_Manager();
+		$title = 'Hello World';
+		$wp_customize->set_post_value( 'blogname', $title );
+		$this->assertNotEquals( $title, get_option( 'blogname' ) );
+		$wp_customize->wp_loaded();
+		$this->assertFalse( $wp_customize->is_preview() );
+		$this->assertEquals( $title, $wp_customize->get_setting( 'blogname' )->value() );
+		$this->assertEquals( $title, get_option( 'blogname' ) );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::find_changeset_post_id().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::find_changeset_post_id()
+	 */
+	function test_find_changeset_post_id() {
+		$uuid = wp_generate_uuid4();
+		$post_id = $this->factory()->post->create( array(
+			'post_name' => $uuid,
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_content' => '{}',
+		) );
+
+		$wp_customize = new WP_Customize_Manager();
+		$this->assertNull( $wp_customize->find_changeset_post_id( wp_generate_uuid4() ) );
+		$this->assertEquals( $post_id, $wp_customize->find_changeset_post_id( $uuid ) );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::changeset_post_id().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::changeset_post_id()
+	 */
+	function test_changeset_post_id() {
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$this->assertNull( $wp_customize->changeset_post_id() );
+
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$post_id = $this->factory()->post->create( array(
+			'post_name' => $uuid,
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_content' => '{}',
+		) );
+		$this->assertEquals( $post_id, $wp_customize->changeset_post_id() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::changeset_data().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::changeset_data()
+	 */
+	function test_changeset_data() {
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$this->assertEquals( array(), $wp_customize->changeset_data() );
+
+		$uuid = wp_generate_uuid4();
+		$data = array( 'blogname' => array( 'value' => 'Hello World' ) );
+		$this->factory()->post->create( array(
+			'post_name' => $uuid,
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_content' => wp_json_encode( $data ),
+		) );
+		$wp_customize = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$this->assertEquals( $data, $wp_customize->changeset_data() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::customize_preview_init().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::customize_preview_init()
+	 */
+	function test_customize_preview_init() {
+
+		// Test authorized admin user.
+		wp_set_current_user( self::$admin_user_id );
+		$did_action_customize_preview_init = did_action( 'customize_preview_init' );
+		$wp_customize = new WP_Customize_Manager();
+		$wp_customize->customize_preview_init();
+		$this->assertEquals( $did_action_customize_preview_init + 1, did_action( 'customize_preview_init' ) );
+
+		$this->assertEquals( 10, has_action( 'wp_head', 'wp_no_robots' ) );
+		$this->assertEquals( 10, has_filter( 'wp_headers', array( $wp_customize, 'filter_iframe_security_headers' ) ) );
+		$this->assertEquals( 10, has_filter( 'wp_redirect', array( $wp_customize, 'add_state_query_params' ) ) );
+		$this->assertTrue( wp_script_is( 'customize-preview', 'enqueued' ) );
+		$this->assertEquals( 10, has_action( 'wp_head', array( $wp_customize, 'customize_preview_loading_style' ) ) );
+		$this->assertEquals( 20, has_action( 'wp_footer', array( $wp_customize, 'customize_preview_settings' ) ) );
+
+		// Test unauthorized user outside preview (no messenger_channel).
+		wp_set_current_user( self::$subscriber_user_id );
+		$wp_customize = new WP_Customize_Manager();
+		$wp_customize->register_controls();
+		$this->assertNotEmpty( $wp_customize->controls() );
+		$wp_customize->customize_preview_init();
+		$this->assertEmpty( $wp_customize->controls() );
+
+		// Test unauthorized user inside preview (with messenger_channel).
+		wp_set_current_user( self::$subscriber_user_id );
+		$wp_customize = new WP_Customize_Manager( array( 'messenger_channel' => 'preview-0' ) );
+		$exception = null;
+		try {
+			$wp_customize->customize_preview_init();
+		} catch ( WPDieException $e ) {
+			$exception = $e;
+		}
+		$this->assertNotNull( $exception );
+		$this->assertContains( 'Unauthorized', $exception->getMessage() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::filter_iframe_security_headers().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::filter_iframe_security_headers()
+	 */
+	function test_filter_iframe_security_headers() {
+		$customize_url = admin_url( 'customize.php' );
+		$wp_customize = new WP_Customize_Manager();
+		$headers = $wp_customize->filter_iframe_security_headers( array() );
+		$this->assertArrayHasKey( 'X-Frame-Options', $headers );
+		$this->assertArrayHasKey( 'Content-Security-Policy', $headers );
+		$this->assertEquals( "ALLOW-FROM $customize_url", $headers['X-Frame-Options'] );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::add_state_query_params().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::add_state_query_params()
+	 */
+	function test_add_state_query_params() {
+		$uuid = wp_generate_uuid4();
+		$messenger_channel = 'preview-0';
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'messenger_channel' => $messenger_channel,
+		) );
+		$url = $wp_customize->add_state_query_params( home_url( '/' ) );
+		$parsed_url = wp_parse_url( $url );
+		parse_str( $parsed_url['query'], $query_params );
+		$this->assertArrayHasKey( 'customize_messenger_channel', $query_params );
+		$this->assertArrayHasKey( 'customize_changeset_uuid', $query_params );
+		$this->assertArrayNotHasKey( 'customize_theme', $query_params );
+		$this->assertEquals( $uuid, $query_params['customize_changeset_uuid'] );
+		$this->assertEquals( $messenger_channel, $query_params['customize_messenger_channel'] );
+
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'messenger_channel' => null,
+			'theme' => 'twentyfifteen',
+		) );
+		$url = $wp_customize->add_state_query_params( home_url( '/' ) );
+		$parsed_url = wp_parse_url( $url );
+		parse_str( $parsed_url['query'], $query_params );
+		$this->assertArrayNotHasKey( 'customize_messenger_channel', $query_params );
+		$this->assertArrayHasKey( 'customize_changeset_uuid', $query_params );
+		$this->assertArrayHasKey( 'customize_theme', $query_params );
+		$this->assertEquals( $uuid, $query_params['customize_changeset_uuid'] );
+		$this->assertEquals( 'twentyfifteen', $query_params['customize_theme'] );
+
+		$uuid = wp_generate_uuid4();
+		$wp_customize = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'messenger_channel' => null,
+			'theme' => 'twentyfifteen',
+		) );
+		$url = $wp_customize->add_state_query_params( 'http://not-allowed.example.com/?q=1' );
+		$parsed_url = wp_parse_url( $url );
+		parse_str( $parsed_url['query'], $query_params );
+		$this->assertArrayNotHasKey( 'customize_messenger_channel', $query_params );
+		$this->assertArrayNotHasKey( 'customize_changeset_uuid', $query_params );
+		$this->assertArrayNotHasKey( 'customize_theme', $query_params );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::save_changeset_post().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::save_changeset_post()
+	 */
+	function test_save_changeset_post_without_theme_activation() {
+		wp_set_current_user( self::$admin_user_id );
+
+		$did_action = array(
+			'customize_save_validation_before' => did_action( 'customize_save_validation_before' ),
+			'customize_save' => did_action( 'customize_save' ),
+			'customize_save_after' => did_action( 'customize_save_after' ),
+		);
+		$uuid = wp_generate_uuid4();
+
+		$manager = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+		) );
+		$manager->register_controls();
+		$manager->set_post_value( 'blogname', 'Changeset Title' );
+		$manager->set_post_value( 'blogdescription', 'Changeset Tagline' );
+
+		$r = $manager->save_changeset_post( array(
+			'status' => 'auto-draft',
+			'title' => 'Auto Draft',
+			'date_gmt' => '2010-01-01 00:00:00',
+			'data' => array(
+				'blogname' => array(
+					'value' => 'Overridden Changeset Title',
+				),
+				'blogdescription' => array(
+					'custom' => 'something',
+				),
+			),
+		) );
+		$this->assertInternalType( 'array', $r );
+
+		$this->assertEquals( $did_action['customize_save_validation_before'] + 1, did_action( 'customize_save_validation_before' ) );
+
+		$post_id = $manager->find_changeset_post_id( $uuid );
+		$this->assertNotNull( $post_id );
+		$saved_data = json_decode( get_post( $post_id )->post_content, true );
+		$this->assertEquals( $manager->unsanitized_post_values(), wp_list_pluck( $saved_data, 'value' ) );
+		$this->assertEquals( 'Overridden Changeset Title', $saved_data['blogname']['value'] );
+		$this->assertEquals( 'something', $saved_data['blogdescription']['custom'] );
+		$this->assertEquals( 'Auto Draft', get_post( $post_id )->post_title );
+		$this->assertEquals( 'auto-draft', get_post( $post_id )->post_status );
+		$this->assertEquals( '2010-01-01 00:00:00', get_post( $post_id )->post_date_gmt );
+		$this->assertNotEquals( 'Changeset Title', get_option( 'blogname' ) );
+		$this->assertArrayHasKey( 'setting_validities', $r );
+
+		// Test saving with invalid settings, ensuring transaction blocked.
+		$previous_saved_data = $saved_data;
+		$manager->add_setting( 'foo_unauthorized', array(
+			'capability' => 'do_not_allow',
+		) );
+		$manager->add_setting( 'baz_illegal', array(
+			'validate_callback' => array( $this, 'return_illegal_error' ),
+		) );
+		$r = $manager->save_changeset_post( array(
+			'status' => 'auto-draft',
+			'data' => array(
+				'blogname' => array(
+					'value' => 'OK',
+				),
+				'foo_unauthorized' => array(
+					'value' => 'No',
+				),
+				'bar_unknown' => array(
+					'value' => 'No',
+				),
+				'baz_illegal' => array(
+					'value' => 'No',
+				),
+			),
+		) );
+		$this->assertInstanceOf( 'WP_Error', $r );
+		$this->assertEquals( 'transaction_fail', $r->get_error_code() );
+		$this->assertInternalType( 'array', $r->get_error_data() );
+		$this->assertArrayHasKey( 'setting_validities', $r->get_error_data() );
+		$error_data = $r->get_error_data();
+		$this->assertArrayHasKey( 'blogname', $error_data['setting_validities'] );
+		$this->assertTrue( $error_data['setting_validities']['blogname'] );
+		$this->assertArrayHasKey( 'foo_unauthorized', $error_data['setting_validities'] );
+		$this->assertInstanceOf( 'WP_Error', $error_data['setting_validities']['foo_unauthorized'] );
+		$this->assertEquals( 'unauthorized', $error_data['setting_validities']['foo_unauthorized']->get_error_code() );
+		$this->assertArrayHasKey( 'bar_unknown', $error_data['setting_validities'] );
+		$this->assertInstanceOf( 'WP_Error', $error_data['setting_validities']['bar_unknown'] );
+		$this->assertEquals( 'unrecognized', $error_data['setting_validities']['bar_unknown']->get_error_code() );
+		$this->assertArrayHasKey( 'baz_illegal', $error_data['setting_validities'] );
+		$this->assertInstanceOf( 'WP_Error', $error_data['setting_validities']['baz_illegal'] );
+		$this->assertEquals( 'illegal', $error_data['setting_validities']['baz_illegal']->get_error_code() );
+
+		// Since transactional, ensure no changes have been made.
+		$this->assertEquals( $previous_saved_data, json_decode( get_post( $post_id )->post_content, true ) );
+
+		// Attempt a non-transactional/incremental update.
+		$manager = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+		) );
+		$manager->register_controls(); // That is, register settings.
+		$r = $manager->save_changeset_post( array(
+			'status' => null,
+			'data' => array(
+				'blogname' => array(
+					'value' => 'Non-Transactional \o/ <script>unsanitized</script>',
+				),
+				'bar_unknown' => array(
+					'value' => 'No',
+				),
+			),
+		) );
+		$this->assertInternalType( 'array', $r );
+		$this->assertArrayHasKey( 'setting_validities', $r );
+		$this->assertTrue( $r['setting_validities']['blogname'] );
+		$this->assertInstanceOf( 'WP_Error', $r['setting_validities']['bar_unknown'] );
+		$saved_data = json_decode( get_post( $post_id )->post_content, true );
+		$this->assertNotEquals( $previous_saved_data, $saved_data );
+		$this->assertEquals( 'Non-Transactional \o/ <script>unsanitized</script>', $saved_data['blogname']['value'] );
+
+		// Ensure the filter applies.
+		$customize_changeset_save_data_call_count = $this->customize_changeset_save_data_call_count;
+		add_filter( 'customize_changeset_save_data', array( $this, 'filter_customize_changeset_save_data' ), 10, 2 );
+		$manager->save_changeset_post( array(
+			'status' => null,
+			'data' => array(
+				'blogname' => array(
+					'value' => 'Filtered',
+				),
+			),
+		) );
+		$this->assertEquals( $customize_changeset_save_data_call_count + 1, $this->customize_changeset_save_data_call_count );
+
+		// Publish the changeset.
+		$manager = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$manager->register_controls();
+		$GLOBALS['wp_customize'] = $manager;
+		$r = $manager->save_changeset_post( array(
+			'status' => 'publish',
+			'data' => array(
+				'blogname' => array(
+					'value' => 'Do it live \o/',
+				),
+			),
+		) );
+		$this->assertInternalType( 'array', $r );
+		$this->assertEquals( 'Do it live \o/', get_option( 'blogname' ) );
+		$this->assertEquals( 'trash', get_post_status( $post_id ) ); // Auto-trashed.
+
+		// Test revisions.
+		add_post_type_support( 'customize_changeset', 'revisions' );
+		$uuid = wp_generate_uuid4();
+		$manager = new WP_Customize_Manager( array( 'changeset_uuid' => $uuid ) );
+		$manager->register_controls();
+		$GLOBALS['wp_customize'] = $manager;
+
+		$manager->set_post_value( 'blogname', 'Hello Surface' );
+		$manager->save_changeset_post( array( 'status' => 'auto-draft' ) );
+
+		$manager->set_post_value( 'blogname', 'Hello World' );
+		$manager->save_changeset_post( array( 'status' => 'draft' ) );
+		$this->assertTrue( wp_revisions_enabled( get_post( $manager->changeset_post_id() ) ) );
+
+		$manager->set_post_value( 'blogname', 'Hello Solar System' );
+		$manager->save_changeset_post( array( 'status' => 'draft' ) );
+
+		$manager->set_post_value( 'blogname', 'Hello Galaxy' );
+		$manager->save_changeset_post( array( 'status' => 'draft' ) );
+		$this->assertCount( 3, wp_get_post_revisions( $manager->changeset_post_id() ) );
+	}
+
+	/**
+	 * Call count for customize_changeset_save_data filter.
+	 *
+	 * @var int
+	 */
+	protected $customize_changeset_save_data_call_count = 0;
+
+	/**
+	 * Filter customize_changeset_save_data.
+	 *
+	 * @param array $data    Data.
+	 * @param array $context Context.
+	 * @returns array Data.
+	 */
+	function filter_customize_changeset_save_data( $data, $context ) {
+		$this->customize_changeset_save_data_call_count += 1;
+		$this->assertInternalType( 'array', $data );
+		$this->assertInternalType( 'array', $context );
+		$this->assertArrayHasKey( 'uuid', $context );
+		$this->assertArrayHasKey( 'title', $context );
+		$this->assertArrayHasKey( 'status', $context );
+		$this->assertArrayHasKey( 'date_gmt', $context );
+		$this->assertArrayHasKey( 'post_id', $context );
+		$this->assertArrayHasKey( 'previous_data', $context );
+		$this->assertArrayHasKey( 'manager', $context );
+		return $data;
+	}
+
+	/**
+	 * Return illegal error.
+	 *
+	 * @return WP_Error Error.
+	 */
+	function return_illegal_error() {
+		return new WP_Error( 'illegal' );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::save_changeset_post().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::save_changeset_post()
+	 * @covers WP_Customize_Manager::update_stashed_theme_mod_settings()
+	 */
+	function test_save_changeset_post_with_theme_activation() {
+		wp_set_current_user( self::$admin_user_id );
+
+		$stashed_theme_mods = array(
+			'twentyfifteen' => array(
+				'background_color' => array(
+					'value' => '#123456',
+				),
+			),
+		);
+		update_option( 'customize_stashed_theme_mods', $stashed_theme_mods );
+		$uuid = wp_generate_uuid4();
+		$manager = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'theme' => 'twentyfifteen',
+		) );
+		$manager->register_controls();
+		$GLOBALS['wp_customize'] = $manager;
+
+		$manager->set_post_value( 'blogname', 'Hello 2015' );
+		$post_values = $manager->unsanitized_post_values();
+		$manager->save_changeset_post( array( 'status' => 'publish' ) ); // Activate.
+
+		$this->assertEquals( '#123456', $post_values['background_color'] );
+		$this->assertEquals( 'twentyfifteen', get_stylesheet() );
+		$this->assertEquals( 'Hello 2015', get_option( 'blogname' ) );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::is_cross_domain().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::is_cross_domain()
+	 */
+	function test_is_cross_domain() {
+		$wp_customize = new WP_Customize_Manager();
+
+		update_option( 'home', 'http://example.com' );
+		update_option( 'siteurl', 'http://example.com' );
+		$this->assertFalse( $wp_customize->is_cross_domain() );
+
+		update_option( 'home', 'http://example.com' );
+		update_option( 'siteurl', 'https://admin.example.com' );
+		$this->assertTrue( $wp_customize->is_cross_domain() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::get_allowed_urls().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::get_allowed_urls()
+	 */
+	function test_get_allowed_urls() {
+		$wp_customize = new WP_Customize_Manager();
+		$this->assertFalse( is_ssl() );
+		$this->assertFalse( $wp_customize->is_cross_domain() );
+		$allowed = $wp_customize->get_allowed_urls();
+		$this->assertEquals( $allowed, array( home_url( '/', 'http' ) ) );
+
+		add_filter( 'customize_allowed_urls', array( $this, 'filter_customize_allowed_urls' ) );
+		$allowed = $wp_customize->get_allowed_urls();
+		$this->assertEqualSets( $allowed, array( 'http://headless.example.com/', home_url( '/', 'http' ) ) );
+	}
+
+	/**
+	 * Callback for customize_allowed_urls filter.
+	 *
+	 * @param array $urls URLs.
+	 * @return array URLs.
+	 */
+	function filter_customize_allowed_urls( $urls ) {
+		$urls[] = 'http://headless.example.com/';
+		return $urls;
+	}
+
 	/**
 	 * Test WP_Customize_Manager::doing_ajax().
 	 *
@@ -90,7 +717,8 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 *
 	 * @ticket 30988
 	 */
-	function test_unsanitized_post_values() {
+	function test_unsanitized_post_values_from_input() {
+		wp_set_current_user( self::$admin_user_id );
 		$manager = $this->manager;
 
 		$customized = array(
@@ -100,6 +728,117 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		$_POST['customized'] = wp_slash( wp_json_encode( $customized ) );
 		$post_values = $manager->unsanitized_post_values();
 		$this->assertEquals( $customized, $post_values );
+		$this->assertEmpty( $manager->unsanitized_post_values( array( 'exclude_post_data' => true ) ) );
+
+		$manager->set_post_value( 'foo', 'BAR' );
+		$post_values = $manager->unsanitized_post_values();
+		$this->assertEquals( 'BAR', $post_values['foo'] );
+		$this->assertEmpty( $manager->unsanitized_post_values( array( 'exclude_post_data' => true ) ) );
+
+		// If user is unprivileged, the post data is ignored.
+		wp_set_current_user( 0 );
+		$this->assertEmpty( $manager->unsanitized_post_values() );
+	}
+
+	/**
+	 * Test WP_Customize_Manager::unsanitized_post_values().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::unsanitized_post_values()
+	 */
+	function test_unsanitized_post_values_with_changeset_and_stashed_theme_mods() {
+		wp_set_current_user( self::$admin_user_id );
+
+		$stashed_theme_mods = array(
+			'twentyfifteen' => array(
+				'background_color' => array(
+					'value' => '#000000',
+				),
+			),
+		);
+		$stashed_theme_mods[ get_stylesheet() ] = array(
+			'background_color' => array(
+				'value' => '#FFFFFF',
+			),
+		);
+		update_option( 'customize_stashed_theme_mods', $stashed_theme_mods );
+
+		$post_values = array(
+			'blogdescription' => 'Post Input Tagline',
+		);
+		$_POST['customized'] = wp_slash( wp_json_encode( $post_values ) );
+
+		$uuid = wp_generate_uuid4();
+		$changeset_data = array(
+			'blogname' => array(
+				'value' => 'Changeset Title',
+			),
+			'blogdescription' => array(
+				'value' => 'Changeset Tagline',
+			),
+		);
+		$this->factory()->post->create( array(
+			'post_type' => 'customize_changeset',
+			'post_status' => 'auto-draft',
+			'post_name' => $uuid,
+			'post_content' => wp_json_encode( $changeset_data ),
+		) );
+
+		$manager = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+		) );
+		$this->assertTrue( $manager->is_theme_active() );
+
+		$this->assertArrayNotHasKey( 'background_color', $manager->unsanitized_post_values() );
+
+		$this->assertEquals(
+			array(
+				'blogname' => 'Changeset Title',
+				'blogdescription' => 'Post Input Tagline',
+			),
+			$manager->unsanitized_post_values()
+		);
+		$this->assertEquals(
+			array(
+				'blogdescription' => 'Post Input Tagline',
+			),
+			$manager->unsanitized_post_values( array( 'exclude_changeset' => true ) )
+		);
+
+		$manager->set_post_value( 'blogdescription', 'Post Override Tagline' );
+		$this->assertEquals(
+			array(
+				'blogname' => 'Changeset Title',
+				'blogdescription' => 'Post Override Tagline',
+			),
+			$manager->unsanitized_post_values()
+		);
+
+		$this->assertEquals(
+			array(
+				'blogname' => 'Changeset Title',
+				'blogdescription' => 'Changeset Tagline',
+			),
+			$manager->unsanitized_post_values( array( 'exclude_post_data' => true ) )
+		);
+
+		$this->assertEmpty( $manager->unsanitized_post_values( array( 'exclude_post_data' => true, 'exclude_changeset' => true ) ) );
+
+		// Test unstashing theme mods.
+		$manager = new WP_Customize_Manager( array(
+			'changeset_uuid' => $uuid,
+			'theme' => 'twentyfifteen',
+		) );
+		$this->assertFalse( $manager->is_theme_active() );
+		$values = $manager->unsanitized_post_values( array( 'exclude_post_data' => true, 'exclude_changeset' => true ) );
+		$this->assertNotEmpty( $values );
+		$this->assertArrayHasKey( 'background_color', $values );
+		$this->assertEquals( '#000000', $values['background_color'] );
+
+		$values = $manager->unsanitized_post_values( array( 'exclude_post_data' => false, 'exclude_changeset' => false ) );
+		$this->assertArrayHasKey( 'background_color', $values );
+		$this->assertArrayHasKey( 'blogname', $values );
+		$this->assertArrayHasKey( 'blogdescription', $values );
 	}
 
 	/**
@@ -108,6 +847,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @ticket 30988
 	 */
 	function test_post_value() {
+		wp_set_current_user( self::$admin_user_id );
 		$posted_settings = array(
 			'foo' => 'OOF',
 		);
@@ -131,6 +871,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @ticket 34893
 	 */
 	function test_invalid_post_value() {
+		wp_set_current_user( self::$admin_user_id );
 		$default_value = 'foo_default';
 		$setting = $this->manager->add_setting( 'foo', array(
 			'validate_callback' => array( $this, 'filter_customize_validate_foo' ),
@@ -196,6 +937,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @ticket 37247
 	 */
 	function test_post_value_validation_sanitization_order() {
+		wp_set_current_user( self::$admin_user_id );
 		$default_value = '0';
 		$setting = $this->manager->add_setting( 'numeric', array(
 			'validate_callback' => array( $this, 'filter_customize_validate_numeric' ),
@@ -240,6 +982,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @see WP_Customize_Manager::validate_setting_values()
 	 */
 	function test_validate_setting_values() {
+		wp_set_current_user( self::$admin_user_id );
 		$setting = $this->manager->add_setting( 'foo', array(
 			'validate_callback' => array( $this, 'filter_customize_validate_foo' ),
 			'sanitize_callback' => array( $this, 'filter_customize_sanitize_foo' ),
@@ -304,6 +1047,40 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		$this->assertEquals( 'minlength', $validity->get_error_code() );
 	}
 
+	/**
+	 * Test WP_Customize_Manager::validate_setting_values().
+	 *
+	 * @ticket 30937
+	 * @covers WP_Customize_Manager::validate_setting_values()
+	 */
+	function test_validate_setting_values_args() {
+		wp_set_current_user( self::$admin_user_id );
+		$this->manager->register_controls();
+
+		$validities = $this->manager->validate_setting_values( array( 'unknown' => 'X' ) );
+		$this->assertEmpty( $validities );
+
+		$validities = $this->manager->validate_setting_values( array( 'unknown' => 'X' ), array( 'validate_existence' => false ) );
+		$this->assertEmpty( $validities );
+
+		$validities = $this->manager->validate_setting_values( array( 'unknown' => 'X' ), array( 'validate_existence' => true ) );
+		$this->assertNotEmpty( $validities );
+		$this->assertArrayHasKey( 'unknown', $validities );
+		$error = $validities['unknown'];
+		$this->assertInstanceOf( 'WP_Error', $error );
+		$this->assertEquals( 'unrecognized', $error->get_error_code() );
+
+		$this->manager->get_setting( 'blogname' )->capability = 'do_not_allow';
+		$validities = $this->manager->validate_setting_values( array( 'blogname' => 'X' ), array( 'validate_capability' => false ) );
+		$this->assertArrayHasKey( 'blogname', $validities );
+		$this->assertTrue( $validities['blogname'] );
+		$validities = $this->manager->validate_setting_values( array( 'blogname' => 'X' ), array( 'validate_capability' => true ) );
+		$this->assertArrayHasKey( 'blogname', $validities );
+		$error = $validities['blogname'];
+		$this->assertInstanceOf( 'WP_Error', $error );
+		$this->assertEquals( 'unauthorized', $error->get_error_code() );
+	}
+
 	/**
 	 * Add a length constraint to a setting.
 	 *
@@ -328,6 +1105,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @ticket 37247
 	 */
 	function test_validate_setting_values_validation_sanitization_order() {
+		wp_set_current_user( self::$admin_user_id );
 		$setting = $this->manager->add_setting( 'numeric', array(
 			'validate_callback' => array( $this, 'filter_customize_validate_numeric' ),
 			'sanitize_callback' => array( $this, 'filter_customize_sanitize_numeric' ),
@@ -369,6 +1147,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @see WP_Customize_Manager::set_post_value()
 	 */
 	function test_set_post_value() {
+		wp_set_current_user( self::$admin_user_id );
 		$this->manager->add_setting( 'foo', array(
 			'sanitize_callback' => array( $this, 'sanitize_foo_for_test_set_post_value' ),
 		) );
@@ -473,7 +1252,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		}
 		$this->assertFalse( $this->manager->has_published_pages() );
 
-		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'editor' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$this->manager->nav_menus->customize_register();
 		$setting_id = 'nav_menus_created_posts';
 		$setting = $this->manager->get_setting( $setting_id );
@@ -492,6 +1271,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @ticket 30936
 	 */
 	function test_register_dynamic_settings() {
+		wp_set_current_user( self::$admin_user_id );
 		$posted_settings = array(
 			'foo' => 'OOF',
 			'bar' => 'RAB',
@@ -591,7 +1371,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		wp_set_current_user( self::factory()->user->create( array( 'role' => 'author' ) ) );
 		$this->assertEquals( home_url( '/' ), $this->manager->get_return_url() );
 
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$this->assertTrue( current_user_can( 'edit_theme_options' ) );
 		$this->assertEquals( home_url( '/' ), $this->manager->get_return_url() );
 
@@ -684,7 +1464,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @see WP_Customize_Manager::customize_pane_settings()
 	 */
 	function test_customize_pane_settings() {
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$this->manager->register_controls();
 		$this->manager->prepare_controls();
 		$autofocus = array( 'control' => 'blogname' );
@@ -706,7 +1486,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		$data = json_decode( $json, true );
 		$this->assertNotEmpty( $data );
 
-		$this->assertEqualSets( array( 'theme', 'url', 'browser', 'panels', 'sections', 'nonce', 'autofocus', 'documentTitleTmpl', 'previewableDevices' ), array_keys( $data ) );
+		$this->assertEqualSets( array( 'theme', 'url', 'browser', 'panels', 'sections', 'nonce', 'autofocus', 'documentTitleTmpl', 'previewableDevices', 'changeset', 'timeouts' ), array_keys( $data ) );
 		$this->assertEquals( $autofocus, $data['autofocus'] );
 		$this->assertArrayHasKey( 'save', $data['nonce'] );
 		$this->assertArrayHasKey( 'preview', $data['nonce'] );
@@ -718,7 +1498,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 * @see WP_Customize_Manager::customize_preview_settings()
 	 */
 	function test_customize_preview_settings() {
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$this->manager->register_controls();
 		$this->manager->prepare_controls();
 		$this->manager->set_post_value( 'foo', 'bar' );
@@ -740,9 +1520,10 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		$this->assertArrayHasKey( 'settingValidities', $settings );
 		$this->assertArrayHasKey( 'nonce', $settings );
 		$this->assertArrayHasKey( '_dirty', $settings );
+		$this->assertArrayHasKey( 'timeouts', $settings );
+		$this->assertArrayHasKey( 'changeset', $settings );
 
 		$this->assertArrayHasKey( 'preview', $settings['nonce'] );
-		$this->assertEquals( array( 'foo' ), $settings['_dirty'] );
 	}
 
 	/**
@@ -814,7 +1595,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 		$manager = new WP_Customize_Manager();
 		$manager->register_controls();
 		$section_id = 'foo-section';
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$manager->add_section( $section_id, array(
 			'title'      => 'Section',
 			'priority'   => 1,
@@ -845,7 +1626,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 */
 	function test_add_section_return_instance() {
 		$manager = new WP_Customize_Manager();
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 
 		$section_id = 'foo-section';
 		$result_section = $manager->add_section( $section_id, array(
@@ -872,7 +1653,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 */
 	function test_add_setting_return_instance() {
 		$manager = new WP_Customize_Manager();
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 
 		$setting_id = 'foo-setting';
 		$result_setting = $manager->add_setting( $setting_id );
@@ -943,7 +1724,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	 */
 	function test_add_panel_return_instance() {
 		$manager = new WP_Customize_Manager();
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 
 		$panel_id = 'foo-panel';
 		$result_panel = $manager->add_panel( $panel_id, array(
@@ -970,7 +1751,7 @@ class Tests_WP_Customize_Manager extends WP_UnitTestCase {
 	function test_add_control_return_instance() {
 		$manager = new WP_Customize_Manager();
 		$section_id = 'foo-section';
-		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		wp_set_current_user( self::$admin_user_id );
 		$manager->add_section( $section_id, array(
 			'title'    => 'Section',
 			'priority' => 1,
diff --git a/tests/phpunit/tests/customize/selective-refresh-ajax.php b/tests/phpunit/tests/customize/selective-refresh-ajax.php
index d2a9cdf7b0..9fab8a11f1 100644
--- a/tests/phpunit/tests/customize/selective-refresh-ajax.php
+++ b/tests/phpunit/tests/customize/selective-refresh-ajax.php
@@ -139,25 +139,6 @@ class Test_WP_Customize_Selective_Refresh_Ajax extends WP_UnitTestCase {
 		$this->do_customize_boot_actions();
 	}
 
-	/**
-	 * Make sure that the Customizer "signature" is not included in partial render responses.
-	 *
-	 * @see WP_Customize_Selective_Refresh::handle_render_partials_request()
-	 */
-	function test_handle_render_partials_request_removes_customize_signature() {
-		$this->setup_valid_render_partials_request_environment();
-		$this->assertTrue( is_customize_preview() );
-		$this->assertEquals( 1000, has_action( 'shutdown', array( $this->wp_customize, 'customize_preview_signature' ) ) );
-		ob_start();
-		try {
-			$this->selective_refresh->handle_render_partials_request();
-		} catch ( WPDieException $e ) {
-			unset( $e );
-		}
-		ob_end_clean();
-		$this->assertFalse( has_action( 'shutdown', array( $this->wp_customize, 'customize_preview_signature' ) ) );
-	}
-
 	/**
 	 * Test WP_Customize_Selective_Refresh::handle_render_partials_request() for an unrecognized partial.
 	 *
diff --git a/tests/phpunit/tests/customize/setting.php b/tests/phpunit/tests/customize/setting.php
index ebc7dfb7b0..89b0720163 100644
--- a/tests/phpunit/tests/customize/setting.php
+++ b/tests/phpunit/tests/customize/setting.php
@@ -97,6 +97,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 	 * @see WP_Customize_Setting::value()
 	 */
 	function test_preview_standard_types_non_multidimensional() {
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		$_POST['customized'] = wp_slash( wp_json_encode( $this->post_data_overrides ) );
 
 		// Try non-multidimensional settings.
@@ -175,6 +176,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 	 * @see WP_Customize_Setting::value()
 	 */
 	function test_preview_standard_types_multidimensional() {
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		$_POST['customized'] = wp_slash( wp_json_encode( $this->post_data_overrides ) );
 
 		foreach ( $this->standard_type_configs as $type => $type_options ) {
@@ -314,6 +316,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 	 * @see WP_Customize_Setting::preview()
 	 */
 	function test_preview_custom_type() {
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		$type = 'custom_type';
 		$post_data_overrides = array(
 			"unset_{$type}_with_post_value" => "unset_{$type}_without_post_value\\o/",
@@ -478,6 +481,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 	 * @ticket 31428
 	 */
 	function test_is_current_blog_previewed() {
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		$type = 'option';
 		$name = 'blogname';
 		$post_value = __FUNCTION__;
@@ -502,6 +506,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 			$this->markTestSkipped( 'Cannot test WP_Customize_Setting::is_current_blog_previewed() with switch_to_blog() if not on multisite.' );
 		}
 
+		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
 		$type = 'option';
 		$name = 'blogdescription';
 		$post_value = __FUNCTION__;
@@ -647,6 +652,7 @@ class Tests_WP_Customize_Setting extends WP_UnitTestCase {
 	 * @ticket 37294
 	 */
 	public function test_multidimensional_value_when_previewed() {
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		WP_Customize_Setting::reset_aggregated_multidimensionals();
 
 		$initial_value = 456;
diff --git a/tests/phpunit/tests/functions.php b/tests/phpunit/tests/functions.php
index f520967f27..5f4d6fd975 100644
--- a/tests/phpunit/tests/functions.php
+++ b/tests/phpunit/tests/functions.php
@@ -880,4 +880,22 @@ class Tests_Functions extends WP_UnitTestCase {
 		$this->assertSame( false, $raised_limit );
 		$this->assertEquals( WP_MAX_MEMORY_LIMIT, $ini_limit_after );
 	}
+
+	/**
+	 * Tests wp_generate_uuid4().
+	 *
+	 * @covers wp_generate_uuid4()
+	 * @ticket 38164
+	 */
+	function test_wp_generate_uuid4() {
+		$uuids = array();
+		for ( $i = 0; $i < 20; $i += 1 ) {
+			$uuid = wp_generate_uuid4();
+			$this->assertRegExp( '/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/', $uuid );
+			$uuids[] = $uuid;
+		}
+
+		$unique_uuids = array_unique( $uuids );
+		$this->assertEquals( $uuids, $unique_uuids );
+	}
 }
diff --git a/tests/phpunit/tests/post.php b/tests/phpunit/tests/post.php
index f34bcf8f61..3f5eeff3d1 100644
--- a/tests/phpunit/tests/post.php
+++ b/tests/phpunit/tests/post.php
@@ -1240,4 +1240,50 @@ class Tests_Post extends WP_UnitTestCase {
 		$this->assertEquals( 0, get_post( $page_id )->post_parent );
 	}
 
+	/**
+	 * Test ensuring that the post_name (UUID) is preserved when wp_insert_post()/wp_update_post() is called.
+	 *
+	 * @see _wp_customize_changeset_filter_insert_post_data()
+	 * @ticket 30937
+	 */
+	function test_wp_insert_post_for_customize_changeset_should_not_drop_post_name() {
+
+		$this->assertEquals( 10, has_filter( 'wp_insert_post_data', '_wp_customize_changeset_filter_insert_post_data' ) );
+
+		$changeset_data = array(
+			'blogname' => array(
+				'value' => 'Hello World',
+			),
+		);
+
+		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'contributor' ) ) );
+
+		$uuid = wp_generate_uuid4();
+		$post_id = wp_insert_post( array(
+			'post_type' => 'customize_changeset',
+			'post_name' => strtoupper( $uuid ),
+			'post_content' => wp_json_encode( $changeset_data ),
+		) );
+		$this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected lower-case UUID4 to be inserted.' );
+		$this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
+
+		$changeset_data['blogname']['value'] = 'Hola Mundo';
+		wp_update_post( array(
+			'ID' => $post_id,
+			'post_status' => 'draft',
+			'post_content' => wp_json_encode( $changeset_data ),
+		) );
+		$this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected post_name to not have been dropped for drafts.' );
+		$this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
+
+		$changeset_data['blogname']['value'] = 'Hallo Welt';
+		wp_update_post( array(
+			'ID' => $post_id,
+			'post_status' => 'pending',
+			'post_content' => wp_json_encode( $changeset_data ),
+		) );
+		$this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected post_name to not have been dropped for pending.' );
+		$this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
+	}
+
 }
diff --git a/tests/qunit/fixtures/customize-settings.js b/tests/qunit/fixtures/customize-settings.js
index 670f783df6..2c232dbc71 100644
--- a/tests/qunit/fixtures/customize-settings.js
+++ b/tests/qunit/fixtures/customize-settings.js
@@ -147,6 +147,17 @@ window._wpCustomizeSettings = {
 		'mobile': {
 			'label': 'Enter mobile preview mode'
 		}
+	},
+	changeset: {
+		status: '',
+		uuid: '0c674ff4-c159-4e7a-beb4-cb830ae73979'
+	},
+	timeouts: {
+		windowRefresh: 250,
+		changesetAutoSave: 60000,
+		keepAliveCheck: 2500,
+		reflowPaneContents: 100,
+		previewFrameSensitivity: 2000
 	}
 };
 window._wpCustomizeControlsL10n = {};
diff --git a/tests/qunit/index.html b/tests/qunit/index.html
index 85a3bd713d..244d41ec6f 100644
--- a/tests/qunit/index.html
+++ b/tests/qunit/index.html
@@ -315,6 +315,10 @@
 			</li>
 		</script>
 
+		<div hidden>
+			<div id="customize-preview"></div>
+		</div>
+
 		<div hidden>
 			<div id="available-menu-items" class="accordion-container">
 			<div class="customize-section-title">
diff --git a/tests/qunit/wp-admin/js/customize-base.js b/tests/qunit/wp-admin/js/customize-base.js
index 8ba7b2ce7f..4f726bff22 100644
--- a/tests/qunit/wp-admin/js/customize-base.js
+++ b/tests/qunit/wp-admin/js/customize-base.js
@@ -184,4 +184,23 @@ jQuery( function( $ ) {
 		assert.equal( 'error', notification.type );
 		assert.equal( null, notification.data );
 	} );
+
+	module( 'Customize Base: utils.parseQueryString' );
+	test( 'wp.customize.utils.parseQueryString works', function( assert ) {
+		var queryParams;
+		queryParams = wp.customize.utils.parseQueryString( 'a=1&b=2' );
+		assert.ok( _.isEqual( queryParams, { a: '1', b: '2' } ) );
+
+		queryParams = wp.customize.utils.parseQueryString( 'a+b=1&b=Hello%20World' );
+		assert.ok( _.isEqual( queryParams, { 'a_b': '1', b: 'Hello World' } ) );
+
+		queryParams = wp.customize.utils.parseQueryString( 'a%20b=1&b=Hello+World' );
+		assert.ok( _.isEqual( queryParams, { 'a_b': '1', b: 'Hello World' } ) );
+
+		queryParams = wp.customize.utils.parseQueryString( 'a=1&b' );
+		assert.ok( _.isEqual( queryParams, { 'a': '1', b: null } ) );
+
+		queryParams = wp.customize.utils.parseQueryString( 'a=1&b=' );
+		assert.ok( _.isEqual( queryParams, { 'a': '1', b: '' } ) );
+	} );
 });
diff --git a/tests/qunit/wp-admin/js/customize-controls.js b/tests/qunit/wp-admin/js/customize-controls.js
index e39b57150c..b5eee18113 100644
--- a/tests/qunit/wp-admin/js/customize-controls.js
+++ b/tests/qunit/wp-admin/js/customize-controls.js
@@ -1,4 +1,4 @@
-/* global wp, test, ok, equal, module */
+/* global JSON, wp, test, ok, equal, module */
 
 wp.customize.settingConstructor.abbreviation = wp.customize.Setting.extend({
 	validate: function( value ) {
@@ -558,4 +558,74 @@ jQuery( window ).load( function (){
 		equal( 1, controlsForSettings['fixture-setting'].length );
 		equal( wp.customize.control( controlId ), controlsForSettings['fixture-setting'][0] );
 	} );
+
+	module( 'Customize Controls wp.customize.dirtyValues' );
+	test( 'dirtyValues() returns expected values', function() {
+		wp.customize.each( function( setting ) {
+			setting._dirty = false;
+		} );
+		ok( _.isEmpty( wp.customize.dirtyValues() ) );
+		ok( _.isEmpty( wp.customize.dirtyValues( { unsaved: false } ) ) );
+
+		wp.customize( 'fixture-setting' )._dirty = true;
+		ok( ! _.isEmpty( wp.customize.dirtyValues() ) );
+		ok( _.isEmpty( wp.customize.dirtyValues( { unsaved: true } ) ) );
+
+		wp.customize( 'fixture-setting' ).set( 'Modified' );
+		ok( ! _.isEmpty( wp.customize.dirtyValues() ) );
+		ok( ! _.isEmpty( wp.customize.dirtyValues( { unsaved: true } ) ) );
+		equal( 'Modified', wp.customize.dirtyValues()['fixture-setting'] );
+	} );
+
+	module( 'Customize Controls: wp.customize.requestChangesetUpdate()' );
+	test( 'requestChangesetUpdate makes request and returns promise', function( assert ) {
+		var request, originalBeforeSetup = jQuery.ajaxSettings.beforeSend;
+
+		jQuery.ajaxSetup( {
+			beforeSend: function( e, data ) {
+				var queryParams, changesetData;
+				queryParams = wp.customize.utils.parseQueryString( data.data );
+
+				assert.equal( 'customize_save', queryParams.action );
+				assert.ok( ! _.isUndefined( queryParams.customize_changeset_data ) );
+				assert.ok( ! _.isUndefined( queryParams.nonce ) );
+				assert.ok( ! _.isUndefined( queryParams.customize_theme ) );
+				assert.equal( wp.customize.settings.changeset.uuid, queryParams.customize_changeset_uuid );
+				assert.equal( 'on', queryParams.wp_customize );
+
+				changesetData = JSON.parse( queryParams.customize_changeset_data );
+				assert.ok( ! _.isUndefined( changesetData.additionalSetting ) );
+				assert.ok( ! _.isUndefined( changesetData['fixture-setting'] ) );
+
+				assert.equal( 'additionalValue', changesetData.additionalSetting.value );
+				assert.equal( 'requestChangesetUpdate', changesetData['fixture-setting'].value );
+
+				// Prevent Ajax request from completing.
+				return false;
+			}
+		} );
+
+		wp.customize.each( function( setting ) {
+			setting._dirty = false;
+		} );
+
+		request = wp.customize.requestChangesetUpdate();
+		assert.equal( 'resolved', request.state());
+		request.done( function( data ) {
+			assert.ok( _.isEqual( {}, data ) );
+		} );
+
+		wp.customize( 'fixture-setting' ).set( 'requestChangesetUpdate' );
+
+		request = wp.customize.requestChangesetUpdate( {
+			additionalSetting: {
+				value: 'additionalValue'
+			}
+		} );
+
+		request.always( function( data ) {
+			assert.equal( 'canceled', data.statusText );
+			jQuery.ajaxSetup( { beforeSend: originalBeforeSetup } );
+		} );
+	} );
 });