2008-06-26 14:49:01 -07:00
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Bookmarks Sync.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Mozilla.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2008
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Myk Melez <myk@mozilla.org>
|
2009-02-04 19:51:20 -08:00
|
|
|
* Jono DiCarlo <jdicarlo@mozilla.com>
|
2008-06-26 14:49:01 -07:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
2008-06-03 14:45:53 -07:00
|
|
|
const EXPORTED_SYMBOLS = ['TabEngine'];
|
|
|
|
|
|
|
|
const Cc = Components.classes;
|
|
|
|
const Ci = Components.interfaces;
|
|
|
|
const Cu = Components.utils;
|
|
|
|
|
2009-02-06 17:50:12 -08:00
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
2008-06-03 14:45:53 -07:00
|
|
|
Cu.import("resource://weave/util.js");
|
|
|
|
Cu.import("resource://weave/engines.js");
|
|
|
|
Cu.import("resource://weave/stores.js");
|
|
|
|
Cu.import("resource://weave/trackers.js");
|
2008-06-25 13:51:32 -07:00
|
|
|
Cu.import("resource://weave/constants.js");
|
2009-02-04 19:51:20 -08:00
|
|
|
Cu.import("resource://weave/type_records/tabs.js");
|
2009-02-09 20:23:42 -08:00
|
|
|
Cu.import("resource://weave/engines/clientData.js");
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-01-08 16:57:35 -08:00
|
|
|
function TabEngine() {
|
|
|
|
this._init();
|
2008-06-03 14:45:53 -07:00
|
|
|
}
|
|
|
|
TabEngine.prototype = {
|
2009-01-08 16:57:35 -08:00
|
|
|
__proto__: SyncEngine.prototype,
|
|
|
|
name: "tabs",
|
2009-10-28 00:42:35 -07:00
|
|
|
_displayName: "Tabs",
|
2009-09-15 18:54:05 -07:00
|
|
|
description: "Access tabs from other devices via the History menu",
|
2009-01-08 16:57:35 -08:00
|
|
|
logName: "Tabs",
|
|
|
|
_storeObj: TabStore,
|
|
|
|
_trackerObj: TabTracker,
|
2009-02-04 19:51:20 -08:00
|
|
|
_recordObj: TabSetRecord,
|
|
|
|
|
|
|
|
// API for use by Weave UI code to give user choices of tabs to open:
|
|
|
|
getAllClients: function TabEngine_getAllClients() {
|
|
|
|
return this._store._remoteClients;
|
|
|
|
},
|
|
|
|
|
|
|
|
getClientById: function TabEngine_getClientById(id) {
|
|
|
|
return this._store._remoteClients[id];
|
2009-02-26 22:36:14 -08:00
|
|
|
},
|
2009-02-04 19:51:20 -08:00
|
|
|
|
2009-02-26 22:36:14 -08:00
|
|
|
_resetClient: function TabEngine__resetClient() {
|
|
|
|
this.resetLastSync();
|
|
|
|
this._store.wipe();
|
2009-03-12 15:54:26 -07:00
|
|
|
},
|
|
|
|
|
2009-11-12 14:48:54 -08:00
|
|
|
_syncFinish: function _syncFinish() {
|
|
|
|
SyncEngine.prototype._syncFinish.call(this);
|
|
|
|
this._tracker.resetChanged();
|
|
|
|
},
|
|
|
|
|
2009-03-12 15:54:26 -07:00
|
|
|
/* The intent is not to show tabs in the menu if they're already
|
|
|
|
* open locally. There are a couple ways to interpret this: for
|
|
|
|
* instance, we could do it by removing a tab from the list when
|
|
|
|
* you open it -- but then if you close it, you can't get back to
|
|
|
|
* it. So the way I'm doing it here is to not show a tab in the menu
|
|
|
|
* if you have a tab open to the same URL, even though this means
|
|
|
|
* that as soon as you navigate anywhere, the original tab will
|
|
|
|
* reappear in the menu.
|
|
|
|
*/
|
|
|
|
locallyOpenTabMatchesURL: function TabEngine_localTabMatches(url) {
|
|
|
|
// url should be string, not object
|
|
|
|
/* Some code duplication from _addFirefoxTabsToRecord and
|
|
|
|
* _addFennecTabsToRecord. Unify? */
|
|
|
|
if (Cc["@mozilla.org/browser/sessionstore;1"]) {
|
|
|
|
let state = this._store._sessionStore.getBrowserState();
|
2009-03-31 12:09:38 -07:00
|
|
|
let session = JSON.parse(state);
|
2009-03-12 15:54:26 -07:00
|
|
|
for (let i = 0; i < session.windows.length; i++) {
|
|
|
|
let window = session.windows[i];
|
|
|
|
for (let j = 0; j < window.tabs.length; j++) {
|
|
|
|
let tab = window.tabs[j];
|
|
|
|
if (tab.entries.length > 0) {
|
|
|
|
let tabUrl = tab.entries[tab.entries.length-1].url;
|
|
|
|
if (tabUrl == url) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
let wm = Cc["@mozilla.org/appshell/window-mediator;1"]
|
|
|
|
.getService(Ci.nsIWindowMediator);
|
|
|
|
let browserWindow = wm.getMostRecentWindow("navigator:browser");
|
|
|
|
for each (let tab in browserWindow.Browser._tabs ) {
|
|
|
|
let tabUrl = tab.browser.contentWindow.location.toString();
|
|
|
|
if (tabUrl == url) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
2009-02-26 22:36:14 -08:00
|
|
|
}
|
2008-06-03 14:45:53 -07:00
|
|
|
};
|
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
|
2008-06-03 14:45:53 -07:00
|
|
|
function TabStore() {
|
2009-01-08 16:57:35 -08:00
|
|
|
this._TabStore_init();
|
2008-06-03 14:45:53 -07:00
|
|
|
}
|
|
|
|
TabStore.prototype = {
|
2009-02-04 19:51:20 -08:00
|
|
|
__proto__: Store.prototype,
|
2009-07-14 18:34:03 -07:00
|
|
|
name: "tabs",
|
2009-01-08 16:57:35 -08:00
|
|
|
_logName: "Tabs.Store",
|
2009-03-31 17:52:16 -07:00
|
|
|
_filePath: "meta/tabSets",
|
2009-02-04 19:51:20 -08:00
|
|
|
_remoteClients: {},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
_TabStore_init: function TabStore__init() {
|
|
|
|
this._init();
|
|
|
|
this._readFromFile();
|
|
|
|
},
|
|
|
|
|
|
|
|
get _localClientName() {
|
2009-02-09 20:23:42 -08:00
|
|
|
return Clients.clientName;
|
2009-02-04 19:51:20 -08:00
|
|
|
},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
_writeToFile: function TabStore_writeToFile() {
|
2009-03-31 17:52:16 -07:00
|
|
|
let json = {};
|
|
|
|
for (let [id, val] in Iterator(this._remoteClients))
|
|
|
|
json[id] = val.toJson();
|
|
|
|
|
|
|
|
Utils.jsonSave(this._filePath, this, json);
|
2009-02-04 19:51:20 -08:00
|
|
|
},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
_readFromFile: function TabStore_readFromFile() {
|
2009-03-31 17:52:16 -07:00
|
|
|
Utils.jsonLoad(this._filePath, this, function(json) {
|
|
|
|
for (let [id, val] in Iterator(json)) {
|
2009-02-04 19:51:20 -08:00
|
|
|
this._remoteClients[id] = new TabSetRecord();
|
2009-03-31 17:52:16 -07:00
|
|
|
this._remoteClients[id].fromJson(val);
|
2009-02-04 19:51:20 -08:00
|
|
|
this._remoteClients[id].id = id;
|
2009-02-06 11:19:50 -08:00
|
|
|
}
|
2009-03-31 17:52:16 -07:00
|
|
|
});
|
2009-02-04 19:51:20 -08:00
|
|
|
},
|
2008-06-30 15:13:07 -07:00
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
get _sessionStore() {
|
|
|
|
let sessionStore = Cc["@mozilla.org/browser/sessionstore;1"].
|
|
|
|
getService(Ci.nsISessionStore);
|
|
|
|
this.__defineGetter__("_sessionStore", function() { return sessionStore;});
|
|
|
|
return this._sessionStore;
|
2008-06-03 14:45:53 -07:00
|
|
|
},
|
|
|
|
|
2009-03-17 17:57:53 -07:00
|
|
|
get _windowMediator() {
|
|
|
|
let wm = Cc["@mozilla.org/appshell/window-mediator;1"]
|
|
|
|
.getService(Ci.nsIWindowMediator);
|
|
|
|
this.__defineGetter__("_windowMediator", function() { return wm;});
|
|
|
|
return this._windowMediator;
|
|
|
|
},
|
|
|
|
|
2009-02-09 21:16:18 -08:00
|
|
|
_createLocalClientTabSetRecord: function TabStore__createLocalTabSet() {
|
|
|
|
// Test for existence of sessionStore. If it doesn't exist, then
|
|
|
|
// use get _fennecTabs instead.
|
2009-02-04 19:51:20 -08:00
|
|
|
let record = new TabSetRecord();
|
|
|
|
record.setClientName( this._localClientName );
|
|
|
|
|
2009-02-09 21:16:18 -08:00
|
|
|
if (Cc["@mozilla.org/browser/sessionstore;1"]) {
|
2009-02-10 19:23:06 -08:00
|
|
|
this._addFirefoxTabsToRecord(record);
|
2009-02-09 21:16:18 -08:00
|
|
|
} else {
|
2009-02-10 19:23:06 -08:00
|
|
|
this._addFennecTabsToRecord(record);
|
2009-02-04 19:51:20 -08:00
|
|
|
}
|
|
|
|
return record;
|
|
|
|
},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-10 19:23:06 -08:00
|
|
|
_addFirefoxTabsToRecord: function TabStore__addFirefoxTabs(record) {
|
2009-03-17 17:57:53 -07:00
|
|
|
// Iterate through each tab of each window
|
|
|
|
let enumerator = this._windowMediator.getEnumerator("navigator:browser");
|
|
|
|
while (enumerator.hasMoreElements()) {
|
|
|
|
let window = enumerator.getNext();
|
|
|
|
let tabContainer = window.getBrowser().tabContainer;
|
2009-06-25 22:46:14 -07:00
|
|
|
|
|
|
|
// Grab each tab child from the array-like child NodeList
|
|
|
|
for each (let tab in Array.slice(tabContainer.childNodes)) {
|
|
|
|
if (!(tab instanceof Ci.nsIDOMNode))
|
2009-03-17 17:57:53 -07:00
|
|
|
continue;
|
2009-06-25 22:46:14 -07:00
|
|
|
|
2009-03-31 12:09:38 -07:00
|
|
|
let tabState = JSON.parse(this._sessionStore.getTabState(tab));
|
2009-02-19 11:20:23 -08:00
|
|
|
// Skip empty (i.e. just-opened, no history yet) tabs:
|
2009-03-17 17:57:53 -07:00
|
|
|
if (tabState.entries.length == 0)
|
2009-02-19 11:20:23 -08:00
|
|
|
continue;
|
2009-03-17 17:57:53 -07:00
|
|
|
|
|
|
|
// Get the time the tab was last used
|
2009-11-25 15:14:56 -08:00
|
|
|
let lastUsedTimestamp = tab.lastUsed;
|
2009-03-17 17:57:53 -07:00
|
|
|
|
|
|
|
// Get title of current page
|
|
|
|
let currentPage = tabState.entries[tabState.entries.length - 1];
|
2009-03-12 15:54:26 -07:00
|
|
|
/* TODO not always accurate -- if you've hit Back in this tab,
|
|
|
|
* then the current page might not be the last entry. Deal
|
2009-03-17 17:57:53 -07:00
|
|
|
* with this later. */
|
|
|
|
|
|
|
|
// Get url history
|
2009-02-10 19:23:06 -08:00
|
|
|
let urlHistory = [];
|
2009-02-18 18:18:50 -08:00
|
|
|
// Include URLs in reverse order; max out at 10, and skip nulls.
|
2009-03-17 17:57:53 -07:00
|
|
|
for (let i = tabState.entries.length -1; i >= 0; i--) {
|
|
|
|
let entry = tabState.entries[i];
|
2009-02-18 18:18:50 -08:00
|
|
|
if (entry && entry.url)
|
|
|
|
urlHistory.push(entry.url);
|
|
|
|
if (urlHistory.length >= 10)
|
|
|
|
break;
|
|
|
|
}
|
2009-03-17 17:57:53 -07:00
|
|
|
|
|
|
|
// add tab to record
|
|
|
|
this._log.debug("Wrapping a tab with title " + currentPage.title);
|
2009-07-22 21:40:18 -07:00
|
|
|
this._log.trace("And timestamp " + lastUsedTimestamp);
|
2009-03-17 17:57:53 -07:00
|
|
|
record.addTab(currentPage.title, urlHistory, lastUsedTimestamp);
|
2009-02-10 19:23:06 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_addFennecTabsToRecord: function TabStore__addFennecTabs(record) {
|
|
|
|
let wm = Cc["@mozilla.org/appshell/window-mediator;1"]
|
|
|
|
.getService(Ci.nsIWindowMediator);
|
|
|
|
let browserWindow = wm.getMostRecentWindow("navigator:browser");
|
|
|
|
for each (let tab in browserWindow.Browser._tabs ) {
|
|
|
|
let title = tab.browser.contentDocument.title;
|
2009-02-10 21:54:11 -08:00
|
|
|
let url = tab.browser.contentWindow.location.toString();
|
2009-02-10 19:23:06 -08:00
|
|
|
let urlHistory = [url];
|
2009-03-18 12:40:27 -07:00
|
|
|
|
|
|
|
// TODO how to get older entries in urlHistory? without session store?
|
2009-03-16 16:49:56 -07:00
|
|
|
// can we use BrowserUI._getHistory somehow?
|
2009-03-18 12:40:27 -07:00
|
|
|
|
|
|
|
// Get the time the tab was last used
|
|
|
|
/* let lastUsedTimestamp = tab.getAttribute(TAB_TIME_ATTR);
|
|
|
|
if (!lastUsedTimestamp) */
|
|
|
|
// TODO that doesn't work: tab.getAttribute is not a function on Fennec.
|
|
|
|
let lastUsedTimestamp = "0";
|
|
|
|
|
|
|
|
this._log.debug("Wrapping a tab with title " + title);
|
2009-07-22 21:40:18 -07:00
|
|
|
this._log.trace("And timestamp " + lastUsedTimestamp);
|
2009-03-18 12:40:27 -07:00
|
|
|
record.addTab(title, urlHistory, lastUsedTimestamp);
|
2009-03-16 16:49:56 -07:00
|
|
|
// TODO add last-visited date for this tab... but how?
|
2009-02-10 19:23:06 -08:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
itemExists: function TabStore_itemExists(id) {
|
2009-11-25 15:17:39 -08:00
|
|
|
return id == Clients.clientID;
|
2009-02-04 19:51:20 -08:00
|
|
|
},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-19 00:36:55 -08:00
|
|
|
createRecord: function TabStore_createRecord(id, cryptoMetaURL) {
|
2009-11-25 15:17:39 -08:00
|
|
|
let record = this._createLocalClientTabSetRecord();
|
2009-02-04 19:51:20 -08:00
|
|
|
record.id = id;
|
2009-02-19 00:36:55 -08:00
|
|
|
record.encryption = cryptoMetaURL;
|
2009-02-04 19:51:20 -08:00
|
|
|
return record;
|
|
|
|
},
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-09 20:23:42 -08:00
|
|
|
getAllIDs: function TabStore_getAllIds() {
|
2009-11-25 15:17:39 -08:00
|
|
|
let ids = {};
|
|
|
|
ids[Clients.clientID] = true;
|
|
|
|
return ids;
|
2008-06-03 14:45:53 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
wipe: function TabStore_wipe() {
|
2009-02-04 19:51:20 -08:00
|
|
|
this._remoteClients = {};
|
|
|
|
},
|
|
|
|
|
|
|
|
create: function TabStore_create(record) {
|
2009-09-11 14:39:48 -07:00
|
|
|
this._log.debug("Adding remote tabs from " + record.getClientName());
|
2009-02-04 19:51:20 -08:00
|
|
|
this._remoteClients[record.id] = record;
|
|
|
|
this._writeToFile();
|
|
|
|
// TODO writing to file after every change is inefficient. How do we
|
|
|
|
// make sure to do it (or at least flush it) only after sync is done?
|
|
|
|
// override syncFinished
|
2008-06-03 14:45:53 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-03-16 16:49:56 -07:00
|
|
|
|
2009-02-04 19:51:20 -08:00
|
|
|
function TabTracker() {
|
2009-02-06 17:50:12 -08:00
|
|
|
this._TabTracker_init();
|
2008-06-03 14:45:53 -07:00
|
|
|
}
|
|
|
|
TabTracker.prototype = {
|
2009-02-04 19:51:20 -08:00
|
|
|
__proto__: Tracker.prototype,
|
2009-07-14 18:34:03 -07:00
|
|
|
name: "tabs",
|
2008-06-03 14:45:53 -07:00
|
|
|
_logName: "TabTracker",
|
2009-02-04 19:51:20 -08:00
|
|
|
file: "tab_tracker",
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-02-06 17:50:12 -08:00
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]),
|
|
|
|
|
|
|
|
_TabTracker_init: function TabTracker__init() {
|
|
|
|
this._init();
|
2009-11-12 14:48:54 -08:00
|
|
|
this.resetChanged();
|
2008-06-03 14:45:53 -07:00
|
|
|
|
2009-06-02 02:25:37 -07:00
|
|
|
// Make sure "this" pointer is always set correctly for event listeners
|
2009-11-25 15:14:56 -08:00
|
|
|
this.onTab = Utils.bind2(this, this.onTab);
|
2009-03-17 17:57:53 -07:00
|
|
|
|
|
|
|
// Register as an observer so we can catch windows opening and closing:
|
2009-11-25 15:14:56 -08:00
|
|
|
Svc.WinWatcher.registerNotification(this);
|
2009-06-22 15:53:42 -07:00
|
|
|
|
2009-11-25 15:14:56 -08:00
|
|
|
// Also register listeners on already open windows
|
|
|
|
let wins = Svc.WinMediator.getEnumerator("navigator:browser");
|
|
|
|
while (wins.hasMoreElements())
|
|
|
|
this._registerListenersForWindow(wins.getNext());
|
2009-06-22 15:53:42 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
_registerListenersForWindow: function TabTracker__registerListen(window) {
|
2009-11-25 15:14:56 -08:00
|
|
|
this._log.trace("Registering tab listeners in new window");
|
2009-03-17 17:57:53 -07:00
|
|
|
|
2009-11-25 15:14:56 -08:00
|
|
|
// For each topic, add or remove onTab as the listener
|
|
|
|
let topics = ["TabOpen", "TabClose", "TabSelect"];
|
|
|
|
let onTab = this.onTab;
|
|
|
|
let addRem = function(add) topics.forEach(function(topic) {
|
|
|
|
window[(add ? "add" : "remove") + "EventListener"](topic, onTab, false);
|
|
|
|
});
|
2009-06-22 15:53:42 -07:00
|
|
|
|
2009-11-25 15:14:56 -08:00
|
|
|
// Add the listeners now and remove them on unload
|
|
|
|
addRem(true);
|
|
|
|
window.addEventListener("unload", function() addRem(false), false);
|
2009-03-17 17:57:53 -07:00
|
|
|
},
|
|
|
|
|
|
|
|
observe: function TabTracker_observe(aSubject, aTopic, aData) {
|
2009-11-25 15:14:56 -08:00
|
|
|
// Add tab listeners now that a window has opened
|
2009-03-17 17:57:53 -07:00
|
|
|
let window = aSubject.QueryInterface(Ci.nsIDOMWindow);
|
2009-11-25 15:14:56 -08:00
|
|
|
if (aTopic == "domwindowopened")
|
2009-03-17 17:57:53 -07:00
|
|
|
this._registerListenersForWindow(window);
|
2008-06-03 14:45:53 -07:00
|
|
|
},
|
|
|
|
|
2009-11-25 15:14:56 -08:00
|
|
|
onTab: function onTab(event) {
|
|
|
|
this._log.trace(event.type);
|
|
|
|
this.score += 1;
|
2009-11-12 14:48:54 -08:00
|
|
|
this._changedIDs[Clients.clientID] = true;
|
|
|
|
|
2009-03-17 17:57:53 -07:00
|
|
|
// Store a timestamp in the tab to track when it was last used
|
2009-11-25 15:14:56 -08:00
|
|
|
event.originalTarget.lastUsed = Math.floor(Date.now() / 1000);
|
2009-02-11 19:14:25 -08:00
|
|
|
},
|
|
|
|
|
2009-11-12 14:48:54 -08:00
|
|
|
get changedIDs() this._changedIDs,
|
|
|
|
|
|
|
|
// Provide a way to empty out the changed ids
|
|
|
|
resetChanged: function resetChanged() this._changedIDs = {}
|
2008-06-03 14:45:53 -07:00
|
|
|
}
|