background.js

   1 // Migrate old localStorage to chrome.storage.local.
   2 if (localStorage.prefsMaxBackupItems !== undefined) {
   3         chrome.storage.local.set({
   4                 prefs_max_backup_items: parseInt(localStorage.prefsMaxBackupItems),
   5         });
   6         localStorage.removeItem("prefsMaxBackupItems");
   7 }
   8 if (localStorage.prefsBackupTimer !== undefined) {
   9         chrome.storage.local.set({
  10                 prefs_backup_timer: parseInt(localStorage.prefsBackupTimer),
  11         });
  12         localStorage.removeItem("prefsBackupTimer");
  13 }
  14 if (localStorage.prefsTheme !== undefined) {
  15         chrome.storage.local.set({
  16                 prefs_theme: localStorage.prefsTheme,
  17         });
  18         localStorage.removeItem("prefsTheme");
  19 }
  20 localStorage.removeItem("lastBackupTime");
  21
  22 // Create a backup on first install (or if storage is wiped for some reason.
  23 chrome.storage.local.get(function(items) {
  24         // Setup defaults.
  25         if (items.prefs_max_backup_items === undefined) {
  26                 chrome.storage.local.set({prefs_max_backup_items: 10});
  27         }
  28         if (items.prefs_backup_timer === undefined) {
  29                 chrome.storage.local.set({prefs_backup_timer: 30});
  30         }
  31
  32         // If a backup exists already, nothing to do.
  33         if (items.backups_list) {
  34                 return;
  35         }
  36
  37         // Create a backup now
  38         var d = new Date();
  39         var formattedDate = date_format (d);
  40
  41         backupNow(true, formattedDate, function({success, backupName, backupObj}) {
  42                 // backup completed
  43         });
  44 });
  45
  46 function initAlarm () {
  47         //console.log("initAlarm");
  48
  49         var BACKUP_ALARM_NAME = "backup_alarm";
  50
  51         // Clear any previous alarm
  52         chrome.alarms.clearAll();
  53
  54         chrome.storage.local.get(function(items) {
  55                 const timerMinutes = items.prefs_backup_timer;
  56                 chrome.alarms.create(BACKUP_ALARM_NAME, {periodInMinutes: timerMinutes});
  57         });
  58 }
  59
  60 initAlarm();
  61
  62 function onAlarm (alarm) {
  63         var d = new Date();
  64         var formattedDate = date_format (d);
  65
  66         console.log("Alarm {" + alarm + "} fired up: " + formattedDate);
  67
  68         // if last backup time != lastTabsEdit
  69         //      perform automatic backup
  70                 backupNow(true, formattedDate, function({success, backupName, backupObj}) {
  71                         // automatic backup completed
  72                         var popupViews = chrome.extension.getViews({type: "popup"});
  73                         if (popupViews.length > 0) {
  74                                 for (var i = 0; i < popupViews.length; i++) {
  75                                         var popupView = popupViews[i];
  76                                         if (!popupView.insertBackupItem) {
  77                                                 continue;
  78                                         }
  79
  80                                         popupView.insertBackupItem(backupName, backupObj, true /*insertAtBeginning*/, true /*doAnimation*/);
  81                                         popupView.updateStorageInfo();
  82                                 }
  83                         }
  84                 });
  85 }
  86
  87 chrome.alarms.onAlarm.addListener(onAlarm);
  88
  89 function date_prependZero (val) {
  90         return val < 10 ? "0" + val : "" + val;
  91 }
  92
  93 // yyyy-m-d h:i:s
  94 function date_format (d) {
  95         var monthOneOffset = d.getMonth() + 1; // convert from 0-11 to 1-12
  96
  97         var formattedDate = d.getFullYear() + "-" + date_prependZero(monthOneOffset) + "-" + date_prependZero(d.getDate())
  98                 + " " + date_prependZero(d.getHours()) + ":" + date_prependZero(d.getMinutes()) + ":" + date_prependZero(d.getSeconds());
  99
 100         return formattedDate;
 101 }
 102
 103
 104 function backupNowManual (callbackDone) {
 105         var d = new Date();
 106         var formattedDate = date_format (d);
 107
 108         backupNow(false, formattedDate, callbackDone);
 109
 110
 111 }
 112
 113 function deleteOldestBackup () {
 114         chrome.storage.local.get(function(items) {
 115                 if(!items.backups_list) {
 116                         return;
 117                 }
 118
 119                 var backupsList = items.backups_list;
 120                 var numItemsToDelete = backupsList.length - items.prefs_max_backup_items;
 121                 if (numItemsToDelete > 0) {
 122                         var i = 0;
 123                         var loopFunc = function () {
 124                                 //
 125                                 if (i > 0) {
 126                                         var deletedBackupName = backupsList[i-1];
 127                                         var popupViews = chrome.extension.getViews({type: "popup"});
 128                                         if (popupViews.length > 0) {
 129                                                 for (var j = 0; j < popupViews.length; j++) {
 130                                                         var popupView = popupViews[j];
 131                                                         if (!popupView.removeBackupItemDiv) {
 132                                                                 continue;
 133                                                         }
 134
 135                                                         popupView.removeBackupItemDiv(deletedBackupName);
 136                                                         popupView.updateStorageInfo();
 137                                                 }
 138                                         }
 139                                 }
 140                                 //
 141
 142                                 if (i >= numItemsToDelete) {
 143                                         return;
 144                                 }
 145
 146                                 deleteBackup (backupsList[i], loopFunc);
 147                                 i++;
 148                         };
 149
 150                         loopFunc ();
 151                 }
 152
 153                 //for (var i = 0; i < numItemsToDelete; i++) {
 154                 // TODO WARNING: I'm calling deleteBackup rapidly, while deleting is async...(I should wait for each delete to complete before deleting the next)
 155                         //deleteBackup (backupsList[i], function() {
 156
 157                         //});
 158                 //}
 159
 160         });
 161 }
 162
 163 //var isCreatingBackup = false;
 164
 165 function backupNow(isAutomatic, backupName, callbackDone) {
 166         console.log("backupNow - isAutomatic: " + isAutomatic + " name: " + backupName);
 167         /*if (isCreatingBackup === true) {
 168                 console.log("backupNow - already running..skipping..");
 169                 return;
 170         }*/
 171
 172         //isCreatingBackup = true;
 173
 174         /*if (!confirm("Perform a full backup? All windows and their tabs will be saved!")) {
 175                 return;
 176         }*/
 177
 178         var fullBackup = {
 179                 windows: [],
 180                 isAutomatic: isAutomatic,
 181                 totNumTabs: 0
 182         };
 183
 184         chrome.windows.getAll({populate : true}, function (window_list) {
 185                 var totNumTabs = 0;
 186
 187                 for(var i=0;i<window_list.length;i++) {
 188                         var window = window_list[i];
 189
 190                         //console.log ("Window " + i);
 191
 192                         var bkpWindow = {
 193                                 state: window.state,
 194                                 top: window.top,
 195                                 left: window.left,
 196                                 width: window.width,
 197                                 height: window.height,
 198                                 tabs: []
 199                         };
 200
 201                         var windowTabs = window.tabs;
 202
 203                         // If it's a single window sittig at the new tab page, don't bother
 204                         // saving it.  This is a nice shortcut when things crash as it will
 205                         // only show a single window.
 206                         if (windowTabs.length == 1) {
 207                                 const tab = windowTabs[0];
 208                                 if (tab.url == 'chrome://newtab/')
 209                                         continue;
 210                         }
 211
 212                         for (var j = 0; j < windowTabs.length; j++) {
 213                                 var tab = windowTabs[j];
 214
 215                                 //console.log("==> Tab " + j + " (" + tab.index + "): " + tabUrl);
 216
 217                                 var bkpTab = {
 218                                         url: tab.url,
 219                                         title: tab.title,
 220                                         highlighted: tab.highlighted,
 221                                         pinned: tab.pinned,
 222                                 };
 223
 224                                 // Add tab to tabs arrays
 225                                 bkpWindow.tabs.push(bkpTab);
 226                         }
 227
 228                         totNumTabs += windowTabs.length;
 229
 230                         fullBackup.windows.push(bkpWindow);
 231                 }
 232
 233                 if (totNumTabs == 0)
 234                         return;
 235
 236                 fullBackup.totNumTabs = totNumTabs;
 237
 238                 var storageSetValues = {};
 239                 storageSetValues[backupName] = fullBackup;
 240
 241                 // Store backup
 242                 chrome.storage.local.set(storageSetValues, function () {
 243                         if (chrome.runtime.lastError) {
 244                                 //isCreatingBackup = false;
 245                                 // TODO change icon to error..
 246                                 //alert ("Error: " + chrome.runtime.lastError.message);
 247                                 updateBrowserActionIcon (1);
 248
 249                                 callbackDone({success: false});
 250                         } else {
 251                                 console.log("backup saved");
 252                                 //alert("Backup saved successfully!");
 253
 254                                 chrome.storage.local.get(function(items) {
 255                                         var backupsList = [];
 256                                         if(items.backups_list) {
 257                                                 backupsList = items.backups_list;
 258                                         }
 259
 260                                         console.log("Updating 'backups_list' - cur. size: " + backupsList.length);
 261
 262                                         backupsList.push(backupName);
 263
 264                                         chrome.storage.local.set({"backups_list": backupsList}, function () {
 265                                                 //isCreatingBackup = false;
 266
 267                                                 if (chrome.runtime.lastError) {
 268                                                         console.log ("Error saving backups_list: " + chrome.runtime.lastError.message);
 269                                                         updateBrowserActionIcon (1);
 270                                                         callbackDone({success: false});
 271                                                 } else {
 272                                                         console.log("Backups list saved successfully");
 273
 274                                                         updateBrowserActionIcon (0);
 275                                                         callbackDone({
 276                                                                 success: true,
 277                                                                 backupName,
 278                                                                 backupObj: fullBackup,
 279                                                         });
 280
 281                                                         if (backupsList.length > items.prefs_max_backup_items) {
 282                                                                 deleteOldestBackup();
 283                                                         }
 284                                                 }
 285                                         });
 286                                 });
 287                         }
 288                 });
 289         });
 290 }
 291
 292 /**
 293  * 0 ==> OK
 294  * 1 ==> ERROR
 295  */
 296 function updateBrowserActionIcon (status) {
 297         var icon;
 298         switch(status) {
 299                 case 0:
 300                         icon = "icon_ok.png";
 301                         break;
 302                 default:
 303                         icon = "icon_error.png";
 304                         break;
 305         }
 306
 307         chrome.browserAction.setIcon({path: icon});
 308 }
 309
 310 function deleteBackup (backupName, callback) {
 311         console.log("Deleting backup " + backupName);
 312
 313         chrome.storage.local.remove(backupName, function() {
 314                 //console.log ("=> Deleted backup " + backupName);
 315
 316                 chrome.storage.local.get("backups_list", function(items) {
 317                         //console.log ("==> got backups_list " + backupName);
 318
 319                         if(!items.backups_list) {
 320                                 callback();
 321                                 return;
 322                         }
 323
 324                         var backupsList = items.backups_list;
 325
 326                         var index = backupsList.indexOf(backupName);
 327                         if (index >= 0) {
 328                                 backupsList.splice(index, 1);
 329                         }
 330
 331                         //console.log ("===> Updating backups_list (removing " + backupName + ")");
 332
 333                         chrome.storage.local.set({"backups_list": backupsList}, function() {
 334                                 //console.log ("===> Updated backups_list (removed " + backupName + ")");
 335
 336                                 callback();
 337                         });
 338
 339                         //console.log ("==> EXIT got backups_list " + backupName);
 340                 });
 341
 342                 //console.log ("=> EXIT Deleted backup " + backupName);
 343         });
 344
 345         //console.log("EXIT Deleting backup " + backupName);
 346
 347
 348 }
 349
 350 function restoreNow(backupName) {
 351         console.log("restoreNow");
 352
 353         chrome.storage.local.get(backupName, function(items) {
 354                 if(!items[backupName]) {
 355                         alert("No Backup found");
 356                         return;
 357                 }
 358
 359                 /*if (!confirm("Restore full backup?")) {
 360                         return;
 361                 }*/
 362                 /*
 363                 if (confirm("Would you like to close all existing windows first?")) {
 364                         chrome.windows.getAll({populate : false}, function (window_list) {
 365                                 for(var i=0;i<window_list.length;i++) {
 366                                         var window = window_list[i];
 367                                         chrome.windows.remove(window.id);
 368                                 }
 369                         });
 370                 }*/
 371
 372
 373                 var fullBackup = items[backupName];
 374
 375                 for(var i=0;i<fullBackup.windows.length;i++) {
 376                         const window = fullBackup.windows[i];
 377
 378                         //console.log ("Window " + i);
 379
 380                         urlsToOpen = [];
 381
 382                         const windowTabs = window.tabs;
 383                         for (let j = 0; j < windowTabs.length; j++) {
 384                                 const tab = windowTabs[j];
 385                                 const tabUrl = tab.url;
 386                                 urlsToOpen.push(tabUrl);
 387                         }
 388
 389                         const windowProperties = {
 390                                 state: 'normal',
 391                                 url: urlsToOpen,
 392                                 top: window.top,
 393                                 left: window.left,
 394                                 width: window.width,
 395                                 height: window.height,
 396                         };
 397
 398                         // Create a new Window
 399                         chrome.windows.create(windowProperties, function(createdWindow) {
 400                                 // Chrome errors if the dimensions are set on non-normal windows.
 401                                 // So we create the window first with the right settings, then
 402                                 // update the window state.
 403                                 if (window.state != 'normal') {
 404                                         chrome.windows.update(createdWindow.id, {state: window.state});
 405                                 }
 406
 407                                 chrome.windows.get(createdWindow.id, {populate: true}, ({tabs}) => {
 408                                         for (let tabi = 0; tabi < windowTabs.length; ++tabi) {
 409                                                 const oldtab = windowTabs[tabi];
 410                                                 const newtab = tabs[tabi];
 411                                                 chrome.tabs.update(newtab.id, {
 412                                                         highlighted: oldtab.highlighted,
 413                                                         pinned: oldtab.pinned,
 414                                                 }, () => {
 415                                                         if (!oldtab.highlighted) {
 416                                                                 // If we discard a tab too fast, Chrome will completely
 417                                                                 // throw it away.  Wait until it's in a stable enough
 418                                                                 // state for us to discard it.
 419                                                                 let retryCount = 60;
 420                                                                 const checktab = (id) => {
 421                                                                         if (retryCount-- < 0)
 422                                                                                 return;
 423                                                                         chrome.tabs.get(id, (tab) => {
 424                                                                                 if (tab.pendingUrl)
 425                                                                                         setTimeout(() => checktab(id), 500);
 426                                                                                 else
 427                                                                                         chrome.tabs.discard(id);
 428                                                                         });
 429                                                                 };
 430                                                                 checktab(newtab.id);
 431                                                         }
 432                                                 });
 433                                         }
 434                                 });
 435                         });
 436                 }
 437         });
 438 }
 439
 440 /**
 441  * Callback from other pages (like the popup).
 442  */
 443 chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
 444         console.log(`Got message from ${sender.id}: action=${request.action}`, request);
 445
 446         let asyncResponse = false;
 447         switch (request?.action) {
 448                 case 'initAlarm':
 449                         initAlarm();
 450                         break;
 451
 452                 case 'restoreNow':
 453                         restoreNow(...request.args);
 454                         break;
 455
 456                 case 'deleteBackup':
 457                         deleteBackup(...request.args, sendResponse);
 458                         asyncResponse = true;
 459                         break;
 460
 461                 case 'backupNowManual':
 462                         backupNowManual(sendResponse);
 463                         asyncResponse = true;
 464                         break;
 465         }
 466         return asyncResponse;
 467 });