/**
* @license
* Copyright The Closure Library Authors.
* SPDX-License-Identifier: Apache-2.0
*/
goog.provide('goog.labs.pubsub.BroadcastPubSub');
goog.require('goog.Disposable');
goog.require('goog.Timer');
goog.require('goog.array');
goog.require('goog.async.run');
goog.require('goog.events.EventHandler');
goog.require('goog.events.EventType');
goog.require('goog.log');
goog.require('goog.math');
goog.require('goog.pubsub.PubSub');
goog.require('goog.storage.Storage');
goog.require('goog.storage.mechanism.HTML5LocalStorage');
goog.require('goog.string');
goog.require('goog.userAgent');
goog.requireType('goog.events.BrowserEvent');
/**
* Topic-based publish/subscribe messaging implementation that provides
* communication between browsing contexts that share the same origin.
*
* Wrapper around PubSub that utilizes localStorage to broadcast publications to
* all browser windows with the same origin as the publishing context. This
* allows for topic-based publish/subscribe implementation of strings shared by
* all browser contexts that share the same origin.
*
* Delivery is guaranteed on all browsers except IE8 where topics expire after a
* timeout. Publishing of a topic within a callback function provides no
* guarantee on ordering in that there is a possibility that separate origin
* contexts may see topics in a different order.
*
* This class is not secure and in certain cases (e.g., a browser crash) data
* that is published can persist in localStorage indefinitely. Do not use this
* class to communicate private or confidential information.
*
* On IE8, localStorage is shared by the http and https origins. An attacker
* could possibly leverage this to publish to the secure origin.
*
* goog.labs.pubsub.BroadcastPubSub wraps an instance of PubSub rather than
* subclassing because the base PubSub class allows publishing of arbitrary
* objects.
*
* Special handling is done for the IE8 browsers. See the IE8_EVENTS_KEY_
* constant and the `publish` function for more information.
*
*
* @constructor @struct @extends {goog.Disposable}
*/
goog.labs.pubsub.BroadcastPubSub = function() {
'use strict';
goog.labs.pubsub.BroadcastPubSub.base(this, 'constructor');
goog.labs.pubsub.BroadcastPubSub.instances_.push(this);
/** @private @const */
this.pubSub_ = new goog.pubsub.PubSub();
this.registerDisposable(this.pubSub_);
/** @private @const */
this.handler_ = new goog.events.EventHandler(this);
this.registerDisposable(this.handler_);
/** @private @const */
this.logger_ = goog.log.getLogger('goog.labs.pubsub.BroadcastPubSub');
/** @private @const */
this.mechanism_ = new goog.storage.mechanism.HTML5LocalStorage();
/** @private {?goog.storage.Storage} */
this.storage_ = null;
/** @private {?Object<string, number>} */
this.ie8LastEventTimes_ = null;
/** @private {number} */
this.ie8StartupTimestamp_ = Date.now() - 1;
if (this.mechanism_.isAvailable()) {
this.storage_ = new goog.storage.Storage(this.mechanism_);
let target = window;
if (goog.labs.pubsub.BroadcastPubSub.IS_IE8_) {
this.ie8LastEventTimes_ = {};
target = document;
}
this.handler_.listen(
target, goog.events.EventType.STORAGE, this.handleStorageEvent_);
}
};
goog.inherits(goog.labs.pubsub.BroadcastPubSub, goog.Disposable);
/** @private @const {!Array<!goog.labs.pubsub.BroadcastPubSub>} */
goog.labs.pubsub.BroadcastPubSub.instances_ = [];
/**
* SitePubSub namespace for localStorage.
* @private @const
*/
goog.labs.pubsub.BroadcastPubSub.STORAGE_KEY_ = '_closure_bps';
/**
* Handle the storage event and possibly dispatch topics.
* @param {!goog.events.BrowserEvent} e Event object.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.prototype.handleStorageEvent_ = function(e) {
'use strict';
if (goog.labs.pubsub.BroadcastPubSub.IS_IE8_) {
// Even though we have the event, IE8 doesn't update our localStorage until
// after we handle the actual event.
goog.async.run(this.handleIe8StorageEvent_, this);
return;
}
const browserEvent = e.getBrowserEvent();
if (browserEvent.key != goog.labs.pubsub.BroadcastPubSub.STORAGE_KEY_) {
return;
}
const data = JSON.parse(browserEvent.newValue);
const args = goog.isObject(data) && data['args'];
if (Array.isArray(args) &&
goog.array.every(args, x => typeof x === 'string')) {
this.dispatch_(args);
} else {
goog.log.warning(this.logger_, 'storage event contained invalid arguments');
}
};
/**
* Dispatches args on the internal pubsub queue.
* @param {!Array<string>} args The arguments to publish.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.prototype.dispatch_ = function(args) {
'use strict';
goog.pubsub.PubSub.prototype.publish.apply(this.pubSub_, args);
};
/**
* Publishes a message to a topic. Remote subscriptions in other tabs/windows
* are dispatched via local storage events. Local subscriptions are called
* asynchronously via Timer event in order to simulate remote behavior locally.
* @param {string} topic Topic to publish to.
* @param {...string} var_args String arguments that are applied to each
* subscription function.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.publish = function(topic, var_args) {
'use strict';
const args = Array.prototype.slice.call(arguments);
// Dispatch to localStorage.
if (this.storage_) {
// Update topics to use the optional prefix.
let now = Date.now();
const data = {'args': args, 'timestamp': now};
if (!goog.labs.pubsub.BroadcastPubSub.IS_IE8_) {
// Generated events will contain all the data in modern browsers.
this.storage_.set(goog.labs.pubsub.BroadcastPubSub.STORAGE_KEY_, data);
this.storage_.remove(goog.labs.pubsub.BroadcastPubSub.STORAGE_KEY_);
} else {
// With IE8 we need to manage our own events queue.
let events = null;
try {
events =
this.storage_.get(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
} catch (ex) {
goog.log.error(
this.logger_, 'publish encountered invalid event queue at ' +
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
}
if (!Array.isArray(events)) {
events = [];
}
// Avoid a race condition where we're publishing in the same
// millisecond that another event that may be getting
// processed. In short, we try go guarantee that whatever event
// we put on the event queue has a timestamp that is older than
// any other timestamp in the queue.
const lastEvent = events[events.length - 1];
const lastTimestamp =
lastEvent && lastEvent['timestamp'] || this.ie8StartupTimestamp_;
if (lastTimestamp >= now) {
now = lastTimestamp +
goog.labs.pubsub.BroadcastPubSub.IE8_TIMESTAMP_UNIQUE_OFFSET_MS_;
data['timestamp'] = now;
}
events.push(data);
this.storage_.set(
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_, events);
// Cleanup this event in IE8_EVENT_LIFETIME_MS_ milliseconds.
goog.Timer.callOnce(
goog.bind(this.cleanupIe8StorageEvents_, this, now),
goog.labs.pubsub.BroadcastPubSub.IE8_EVENT_LIFETIME_MS_);
}
}
// W3C spec is to not dispatch the storage event to the same window that
// modified localStorage. For conforming browsers we have to manually dispatch
// the publish event to subscriptions on instances of BroadcastPubSub in the
// current window.
if (!goog.userAgent.IE) {
// Dispatch the publish event to local instances asynchronously to fix some
// quirks with timings. The result is that all subscriptions are dispatched
// before any future publishes are processed. The effect is that
// subscriptions in the same window are dispatched as if they are the result
// of a publish from another tab.
goog.labs.pubsub.BroadcastPubSub.instances_.forEach(function(instance) {
'use strict';
goog.async.run(goog.bind(instance.dispatch_, instance, args));
});
}
};
/**
* Unsubscribes a function from a topic. Only deletes the first match found.
* Returns a Boolean indicating whether a subscription was removed.
* @param {string} topic Topic to unsubscribe from.
* @param {Function} fn Function to unsubscribe.
* @param {Object=} opt_context Object in whose context the function was to be
* called (the global scope if none).
* @return {boolean} Whether a matching subscription was removed.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.unsubscribe = function(
topic, fn, opt_context) {
'use strict';
return this.pubSub_.unsubscribe(topic, fn, opt_context);
};
/**
* Removes a subscription based on the key returned by {@link #subscribe}. No-op
* if no matching subscription is found. Returns a Boolean indicating whether a
* subscription was removed.
* @param {number} key Subscription key.
* @return {boolean} Whether a matching subscription was removed.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.unsubscribeByKey = function(key) {
'use strict';
return this.pubSub_.unsubscribeByKey(key);
};
/**
* Subscribes a function to a topic. The function is invoked as a method on the
* given `opt_context` object, or in the global scope if no context is
* specified. Subscribing the same function to the same topic multiple times
* will result in multiple function invocations while publishing. Returns a
* subscription key that can be used to unsubscribe the function from the topic
* via {@link #unsubscribeByKey}.
* @param {string} topic Topic to subscribe to.
* @param {Function} fn Function to be invoked when a message is published to
* the given topic.
* @param {Object=} opt_context Object in whose context the function is to be
* called (the global scope if none).
* @return {number} Subscription key.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.subscribe = function(
topic, fn, opt_context) {
'use strict';
return this.pubSub_.subscribe(topic, fn, opt_context);
};
/**
* Subscribes a single-use function to a topic. The function is invoked as a
* method on the given `opt_context` object, or in the global scope if no
* context is specified, and is then unsubscribed. Returns a subscription key
* that can be used to unsubscribe the function from the topic via {@link
* #unsubscribeByKey}.
* @param {string} topic Topic to subscribe to.
* @param {Function} fn Function to be invoked once and then unsubscribed when
* a message is published to the given topic.
* @param {Object=} opt_context Object in whose context the function is to be
* called (the global scope if none).
* @return {number} Subscription key.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.subscribeOnce = function(
topic, fn, opt_context) {
'use strict';
return this.pubSub_.subscribeOnce(topic, fn, opt_context);
};
/**
* Returns the number of subscriptions to the given topic (or all topics if
* unspecified). This number will not change while publishing any messages.
* @param {string=} opt_topic The topic (all topics if unspecified).
* @return {number} Number of subscriptions to the topic.
*/
goog.labs.pubsub.BroadcastPubSub.prototype.getCount = function(opt_topic) {
'use strict';
return this.pubSub_.getCount(opt_topic);
};
/**
* Clears the subscription list for a topic, or all topics if unspecified.
* @param {string=} opt_topic Topic to clear (all topics if unspecified).
*/
goog.labs.pubsub.BroadcastPubSub.prototype.clear = function(opt_topic) {
'use strict';
this.pubSub_.clear(opt_topic);
};
/** @override */
goog.labs.pubsub.BroadcastPubSub.prototype.disposeInternal = function() {
'use strict';
goog.array.remove(goog.labs.pubsub.BroadcastPubSub.instances_, this);
if (goog.labs.pubsub.BroadcastPubSub.IS_IE8_ && this.storage_ != null &&
goog.labs.pubsub.BroadcastPubSub.instances_.length == 0) {
this.storage_.remove(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
}
goog.labs.pubsub.BroadcastPubSub.base(this, 'disposeInternal');
};
/**
* Prefix for IE8 storage event queue keys.
* @private @const
*/
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_PREFIX_ = '_closure_bps_ie8evt';
/**
* Time (in milliseconds) that IE8 events should live. If they are not
* processed by other windows in this time they will be removed.
* @private @const
*/
goog.labs.pubsub.BroadcastPubSub.IE8_EVENT_LIFETIME_MS_ = 1000 * 10;
/**
* Time (in milliseconds) that the IE8 event queue should live.
* @private @const
*/
goog.labs.pubsub.BroadcastPubSub.IE8_QUEUE_LIFETIME_MS_ = 1000 * 30;
/**
* Time delta that is used to distinguish between timestamps of events that
* happen in the same millisecond.
* @private @const
*/
goog.labs.pubsub.BroadcastPubSub.IE8_TIMESTAMP_UNIQUE_OFFSET_MS_ = .01;
/**
* Name for this window/tab's storage key that stores its IE8 event queue.
*
* The browsers storage events are supposed to track the key which was changed,
* the previous value for that key, and the new value of that key. Our
* implementation is dependent on this information but IE8 doesn't provide it.
* We implement our own event queue using local storage to track this
* information in IE8. Since all instances share the same localStorage context
* in a particular tab, we share the events queue.
*
* This key is a static member shared by all instances of BroadcastPubSub in the
* same Window context. To avoid read-update-write contention, this key is only
* written in a single context in the cleanupIe8StorageEvents_ function. Since
* instances in other contexts will read this key there is code in the
* `publish` function to make sure timestamps are unique even within the same
* millisecond.
*
* @private @const {string}
*/
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_ =
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_PREFIX_ +
goog.math.randomInt(1e9);
/**
* All instances of this object should access elements using strings and not
* attributes. Since we are communicating across browser tabs we could be
* dealing with different versions of javascript and thus may have different
* obfuscation in each tab.
* @private @typedef {{'timestamp': number, 'args': !Array<string>}}
*/
goog.labs.pubsub.BroadcastPubSub.Ie8Event_;
/** @private @const */
goog.labs.pubsub.BroadcastPubSub.IS_IE8_ =
goog.userAgent.IE && goog.userAgent.DOCUMENT_MODE == 8;
/**
* Validates an event object.
* @param {!Object} obj The object to validate as an Event.
* @return {?goog.labs.pubsub.BroadcastPubSub.Ie8Event_} A valid
* event object or null if the object is invalid.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.validateIe8Event_ = function(obj) {
'use strict';
if (goog.isObject(obj) && typeof obj['timestamp'] === 'number' &&
goog.array.every(obj['args'], x => typeof x === 'string')) {
return {'timestamp': obj['timestamp'], 'args': obj['args']};
}
return null;
};
/**
* Returns an array of valid IE8 events.
* @param {!Array<!Object>} events Possible IE8 events.
* @return {!Array<!goog.labs.pubsub.BroadcastPubSub.Ie8Event_>}
* Valid IE8 events.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.filterValidIe8Events_ = function(events) {
'use strict';
return goog.array.filter(
events.map(goog.labs.pubsub.BroadcastPubSub.validateIe8Event_),
x => x != null);
};
/**
* Returns the IE8 events that have a timestamp later than the provided
* timestamp.
* @param {number} timestamp Expired timestamp.
* @param {!Array<!goog.labs.pubsub.BroadcastPubSub.Ie8Event_>} events
* Possible IE8 events.
* @return {!Array<!goog.labs.pubsub.BroadcastPubSub.Ie8Event_>}
* Unexpired IE8 events.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.filterNewIe8Events_ = function(
timestamp, events) {
'use strict';
return events.filter(function(event) {
'use strict';
return event['timestamp'] > timestamp;
});
};
/**
* Processes the events array for key if all elements are valid IE8 events.
* @param {string} key The key in localStorage where the event queue is stored.
* @param {!Array<!Object>} events Array of possible events stored at key.
* @return {boolean} Return true if all elements in the array are valid
* events, false otherwise.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.prototype.maybeProcessIe8Events_ = function(
key, events) {
'use strict';
if (!events.length) {
return false;
}
let validEvents =
goog.labs.pubsub.BroadcastPubSub.filterValidIe8Events_(events);
if (validEvents.length == events.length) {
const lastTimestamp = goog.array.peek(validEvents)['timestamp'];
const previousTime =
this.ie8LastEventTimes_[key] || this.ie8StartupTimestamp_;
if (lastTimestamp > previousTime -
goog.labs.pubsub.BroadcastPubSub.IE8_QUEUE_LIFETIME_MS_) {
this.ie8LastEventTimes_[key] = lastTimestamp;
validEvents = goog.labs.pubsub.BroadcastPubSub.filterNewIe8Events_(
previousTime, validEvents);
for (let i = 0, event; event = validEvents[i]; i++) {
this.dispatch_(event['args']);
}
return true;
}
} else {
goog.log.warning(this.logger_, 'invalid events found in queue ' + key);
}
return false;
};
/**
* Handle the storage event and possibly dispatch events. Looks through all keys
* in localStorage for valid keys.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.prototype.handleIe8StorageEvent_ = function() {
'use strict';
const numKeys = this.mechanism_.getCount();
for (let idx = 0; idx < numKeys; idx++) {
const key = this.mechanism_.key(idx);
// Don't process events we generated. The W3C standard says that storage
// events should be queued by the browser for each window whose document's
// storage object is affected by a change in localStorage. Chrome, Firefox,
// and modern IE don't dispatch the event to the window which made the
// change. This code simulates that behavior in IE8.
if (!(typeof key === 'string' &&
goog.string.startsWith(
key, goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_PREFIX_))) {
continue;
}
let events = null;
try {
events = this.storage_.get(key);
} catch (ex) {
goog.log.warning(this.logger_, 'invalid remote event queue ' + key);
}
if (!(Array.isArray(events) && this.maybeProcessIe8Events_(key, events))) {
// Events is not an array, empty, contains invalid events, or expired.
this.storage_.remove(key);
}
}
};
/**
* Cleanup our IE8 event queue by removing any events that come at or before the
* given timestamp.
* @param {number} timestamp Maximum timestamp to remove from the queue.
* @private
*/
goog.labs.pubsub.BroadcastPubSub.prototype.cleanupIe8StorageEvents_ = function(
timestamp) {
'use strict';
let events = null;
try {
events =
this.storage_.get(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
} catch (ex) {
goog.log.error(
this.logger_, 'cleanup encountered invalid event queue key ' +
goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
}
if (!Array.isArray(events)) {
this.storage_.remove(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
return;
}
events = goog.labs.pubsub.BroadcastPubSub.filterNewIe8Events_(
timestamp,
goog.labs.pubsub.BroadcastPubSub.filterValidIe8Events_(events));
if (events.length > 0) {
this.storage_.set(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_, events);
} else {
this.storage_.remove(goog.labs.pubsub.BroadcastPubSub.IE8_EVENTS_KEY_);
}
};
Codebase Browser
chromium