tenfourfox/browser/modules/TabGroupsMigrator.jsm
Cameron Kaiser c9b2922b70 hello FPR
2017-04-19 00:56:45 -07:00

298 lines
11 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
this.EXPORTED_SYMBOLS = ["TabGroupsMigrator"];
const { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components;
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "Services", "resource://gre/modules/Services.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils", "resource://gre/modules/PlacesUtils.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "Task", "resource://gre/modules/Task.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "OS", "resource://gre/modules/osfile.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown", "resource://gre/modules/AsyncShutdown.jsm");
XPCOMUtils.defineLazyGetter(this, "gBrowserBundle", function() {
return Services.strings.createBundle('chrome://browser/locale/browser.properties');
});
const RECOVERY_URL = "chrome://browser/content/aboutTabGroupsMigration.xhtml";
this.TabGroupsMigrator = {
bookmarkedGroupsPromise: null,
/**
* If this state contains tab groups, migrate the user's data. This means:
* - make a backup of the user's data.
* - create bookmarks of all the user's tab groups in a single folder
* - append a tab to the active window that lets the user restore background
* groups.
* - remove all the tabs hidden through tab groups from the state data.
*/
migrate(stateAsSupportsString) {
stateAsSupportsString.QueryInterface(Ci.nsISupportsString);
let stateStr = stateAsSupportsString.data;
// If this is the very first startup of this profile, this is going to be empty:
if (!stateStr) {
return;
}
let state;
try {
state = JSON.parse(stateStr);
} catch (ex) {
Cu.reportError("Failed to parse sessionstore state JSON to migrate tab groups: " + ex);
return; // can't recover from invalid JSON
}
let groupData = this._gatherGroupData(state);
// This strips out the hidden tab groups and puts them in a different object.
// It also removes all tabview metadata.
// We always do this, and always reassign the new state back into the
// nsISupportsString for use by sessionstore, in order to tidy up the state
// object.
let hiddenTabState = this._removeHiddenTabGroupsFromState(state, groupData);
// However, we will only create a backup file, bookmarks and a new tab to
// restore hidden tabs if tabs were actually removed from |state| by
// _removeHiddenTabGroupsFromState.
if (hiddenTabState.windows.length) {
// We create the backup with the original string, from before all our
// changes:
this._createBackup(stateStr);
this._createBackgroundTabGroupRestorationPage(state, hiddenTabState);
// Bookmark creation is async. We need to return synchronously,
// so we purposefully don't wait for this to be finished here. We do
// store the promise it creates and use that in the session restore page
// to be able to link to the bookmarks folder...
let bookmarksFinishedPromise = this._bookmarkAllGroupsFromState(groupData);
// ... and we make sure we finish before shutting down:
AsyncShutdown.profileBeforeChange.addBlocker(
"Tab groups migration bookmarks",
bookmarksFinishedPromise
);
}
// We always write this back to ensure that any spurious tab groups data is
// removed:
stateAsSupportsString.data = JSON.stringify(state);
},
/**
* Returns a Map from window state objects to per-window group data.
* Specifically, the values in the Map are themselves Maps from group IDs to
* JS Objects which have these properties:
* - tabGroupsMigrationTitle: the title of the group (or empty string)
* - tabs: an array of the tabs objects in this group.
*/
_gatherGroupData(state) {
let allGroupData = new Map();
let globalAnonGroupID = 0;
for (let win of state.windows) {
if (win.extData && win.extData["tabview-group"]) {
let groupInfo = {};
try {
groupInfo = JSON.parse(win.extData["tabview-group"]);
} catch (ex) {
// This is annoying, but we'll try to deal with this.
}
let windowGroupData = new Map();
let activeGroupID = null;
let tabsWithoutGroup = [];
for (let tab of win.tabs) {
let group;
// Get a string group ID:
try {
let tabViewData = tab.extData && tab.extData["tabview-tab"] &&
JSON.parse(tab.extData["tabview-tab"]);
if (tabViewData && ("groupID" in tabViewData)) {
group = tabViewData.groupID + "";
}
} catch (ex) {
// Ignore errors reading group info, treat as active group
}
if (!group) {
// We didn't find group info. If we already have an active group,
// pretend this is part of that group:
if (activeGroupID) {
group = activeGroupID;
} else {
if (!tabsWithoutGroup) {
Cu.reportError("ERROR: the list of tabs without groups was " +
"nulled out, but there's no active group ID? " +
"This should never happen!");
tabsWithoutGroup = [];
}
// Otherwise, add to the list of tabs with no group and move to
// the next tab immediately. We'll add all these tabs at the
// beginning of the active group as soon as we find a tab in it,
// so as to preserve their order.
tabsWithoutGroup.push(tab);
continue;
}
}
let groupData = windowGroupData.get(group);
if (!groupData) {
let title = (groupInfo[group] && groupInfo[group].title) || "";
groupData = {
tabs: [],
tabGroupsMigrationTitle: title,
};
if (!title) {
groupData.anonGroupID = ++globalAnonGroupID;
groupData.tabGroupsMigrationTitle =
gBrowserBundle.formatStringFromName("tabgroups.migration.anonGroup",
[groupData.anonGroupID], 1);
}
// If this is the active group, set the active group ID and add
// all the already-known tabs (that didn't list a group ID), if any.
if (!activeGroupID && !tab.hidden) {
activeGroupID = group;
groupData.tabs = tabsWithoutGroup;
tabsWithoutGroup = null;
}
windowGroupData.set(group, groupData);
}
groupData.tabs.push(tab);
}
// If we found tabs but no active group, assume there's just 1 group:
if (tabsWithoutGroup && tabsWithoutGroup.length) {
windowGroupData.set("active group", {
tabs: tabsWithoutGroup,
anonGroupID: ++globalAnonGroupID,
});
}
allGroupData.set(win, windowGroupData);
}
}
return allGroupData;
},
_createBackup(stateStr) {
let dest = Services.dirsvc.get("ProfD", Ci.nsIFile);
dest.append("tabgroups-session-backup.json");
let promise = OS.File.writeAtomic(dest.path, stateStr, {encoding: "utf-8"});
AsyncShutdown.webWorkersShutdown.addBlocker("TabGroupsMigrator", promise);
return promise;
},
_groupSorter(a, b) {
if (!a.anonGroupID) {
return -1;
}
if (!b.anonGroupID) {
return 1;
}
return a.anonGroupID - b.anonGroupID;
},
_bookmarkAllGroupsFromState: Task.async(function*(groupData) {
// First create a folder in which to put all these bookmarks:
this.bookmarkedGroupsPromise = PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.menuGuid,
type: PlacesUtils.bookmarks.TYPE_FOLDER,
index: 0,
title: gBrowserBundle.GetStringFromName("tabgroups.migration.tabGroupBookmarkFolderName"),
}).catch(Cu.reportError);
let tabgroupsFolder = yield this.bookmarkedGroupsPromise;
for (let [, windowGroupMap] of groupData) {
let windowGroups = [... windowGroupMap.values()].sort(this._groupSorter);
for (let group of windowGroups) {
let groupFolder = yield PlacesUtils.bookmarks.insert({
parentGuid: tabgroupsFolder.guid,
type: PlacesUtils.bookmarks.TYPE_FOLDER,
title: group.tabGroupsMigrationTitle
}).catch(Cu.reportError);
for (let tab of group.tabs) {
let entry = tab.entries[tab.index - 1];
yield PlacesUtils.bookmarks.insert({
parentGuid: groupFolder.guid,
title: tab.title || entry.title,
url: entry.url,
}).catch(Cu.reportError);
}
}
}
}),
_removeHiddenTabGroupsFromState(state, groups) {
let stateToReturn = {windows: []};
for (let win of state.windows) {
let groupInfoForWindow = groups.get(win);
let hiddenGroupIDs = new Set();
for (let i = win.tabs.length - 1; i >= 0; i--) {
let tab = win.tabs[i];
// Determine whether the tab is grouped:
let tabGroupInfo = null;
try {
tabGroupInfo = tab.extData && tab.extData["tabview-tab"] &&
JSON.parse(tab.extData["tabview-tab"]);
} catch (ex) {}
// Then remove this data.
if (tab.extData) {
delete tab.extData["tabview-tab"];
if (Object.keys(tab.extData).length == 0) {
delete tab.extData;
}
}
// If the tab was grouped and hidden, remove it:
if (tabGroupInfo && tab.hidden) {
hiddenGroupIDs.add(tabGroupInfo.groupID);
win.tabs.splice(i, 1);
// Make sure we unhide it, or it won't get restored correctly
tab.hidden = false;
}
}
// We then convert any hidden groups into windows for the state object
// we show in about:tabgroupsdata
if (groupInfoForWindow) {
let windowsToReturn = [];
for (let groupID of hiddenGroupIDs) {
let group = groupInfoForWindow.get("" + groupID);
if (group) {
windowsToReturn.push(group);
}
}
windowsToReturn.sort(this._groupSorter);
stateToReturn.windows = stateToReturn.windows.concat(windowsToReturn);
}
// Finally we remove tab groups data from the window:
if (win.extData) {
delete win.extData["tabview-group"];
delete win.extData["tabview-groups"];
delete win.extData["tabview-ui"];
delete win.extData["tabview-visibility"];
if (Object.keys(win.extData).length == 0) {
delete win.extData;
}
}
}
return stateToReturn;
},
_createBackgroundTabGroupRestorationPage(state, backgroundData) {
let win = state.windows[(state.selectedWindow || 1) - 1];
let formdata = {id: {sessionData: JSON.stringify(backgroundData)}, url: RECOVERY_URL};
let newTab = { entries: [{url: RECOVERY_URL}], formdata, index: 1 };
// Add tab and mark it as selected:
win.selected = win.tabs.push(newTab);
},
};