Sessions API - previously Session Restore API. Supports restoring currently open foreign windows an…

chrome/test/data/extensions/api_test/sessions/sessions.js

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 

[not at google - send to devlin, 2013/07/31 22:54:22]

IIRC this test is disabled on most platforms, because it takes waaaaay too long
to run. It's not high quality; really needs to be broken up into much smaller
tests and factored in a sane way.

[Kristen Dwan, 2013/08/02 20:54:19]

Alright, will refactor and send out separately. 

 var pages = [pageUrl('a'), pageUrl('b'), pageUrl('c')];
 var firstWindowTabIds = [];
 var recentlyClosedSecondWindowTabIds = [];
 var recentlyClosedTabIds = [];
 var recentlyClosedWindowIds = [];
 var windowIds = [];
 
 var callbackPass = chrome.test.callbackPass;
 var callbackFail = chrome.test.callbackFail;
 var assertEq = chrome.test.assertEq;
@@ skipping 44 matching lines @@
   });
 }
 
 chrome.test.runTests([
   // After setupWindows
   //
   //  Window1: a,b,c
   //  Window2: a,b
   //  Window3: a,b
   //
-  // After retriveClosedTabs:
+  // After retrieveClosedTabs:
   //
   //  Window1: c
   //  Window2: a,b
   //  Window3: a,b
   //  ClosedList: a,b
   //
-  // After retriveClosedWindows:
+  // After retrieveClosedWindows:
   //
   //  Window1: c
   //  ClosedList: Window2,Window3,a,b
   function setupWindows() {
     var callArgs = [
       pages,
       pages.slice(0, 2),
       pages.slice(0, 2)
     ];
     callForEach(
@@ skipping 20 matching lines @@
 
   function retrieveClosedTabs() {
     // Check that the recently closed list contains what we expect
     // after removing tabs.
     callForEach(
       chrome.tabs.remove,
       firstWindowTabIds.slice(0, 2).reverse(),
       function each() {
       },
       function done() {
-        chrome.sessionRestore.getRecentlyClosed(
+        chrome.sessions.getRecentlyClosed(
           {maxResults: 2, entryType: "tab"},
           callbackPass(function(entries) {
             var expectedEntries = [
               { tab: { url: pages[0] } },
               { tab: { url: pages[1] } }
             ];
             checkEntries(expectedEntries, entries);
             entries.forEach(function(entry) {
-              recentlyClosedTabIds.push(entry.id);
+              recentlyClosedTabIds.push(entry.tab.sessionId);
             });
           })
         );
       }
     );
   },
 
   function retrieveClosedWindows() {
     // Check that the recently closed list contains what we expect
     // after removing windows.
     callForEach(
       chrome.windows.remove,
       windowIds.slice(1, 3).reverse(),
       function each() {
       },
       function done() {
-        chrome.sessionRestore.getRecentlyClosed(
+        chrome.sessions.getRecentlyClosed(
           {maxResults: 2, entryType: "window"},
           callbackPass(function(entries) {
             var expectedEntries = [
               { window: { tabsLength: 2 } },
               { window: { tabsLength: 2 } }
             ];
             checkEntries(expectedEntries, entries);
             entries[0].window.tabs.forEach(function(tab) {
-              recentlyClosedSecondWindowTabIds.push(tab.id);
+              recentlyClosedSecondWindowTabIds.push(tab.sessionId);
             });
             entries.forEach(function(entry) {
-              recentlyClosedWindowIds.push(entry.id);
+              recentlyClosedWindowIds.push(entry.window.sessionId);
             });
           })
         );
       }
     );
   },
 
   function retrieveClosedEntries() {
     // Check that the recently closed list contains what we expect
     // after removing tabs and windows.
-    chrome.sessionRestore.getRecentlyClosed(
+    chrome.sessions.getRecentlyClosed(
       callbackPass(function(entries) {
         var expectedEntries = [
           { window: { tabsLength: 2 } },
           { window: { tabsLength: 2 } },
           { tab: { url: pages[0] } },
           { tab: { url: pages[1] } }
         ];
         checkEntries(expectedEntries, entries);
         assertEq(recentlyClosedTabIds.length + recentlyClosedWindowIds.length,
           entries.length);
       })
     );
   },
 
   function retrieveMaxEntries() {
     // Check that the recently closed list contains what we expect
     // after removing tabs and windows.
-    chrome.sessionRestore.getRecentlyClosed({maxResults: 25},
+    chrome.sessions.getRecentlyClosed({maxResults: 25},
       callbackPass(function(entries) {
         var expectedEntries = [
           { window: { tabsLength: 2 } },
           { window: { tabsLength: 2 } },
           { tab: { url: pages[0] } },
           { tab: { url: pages[1] } }
         ];
         checkEntries(expectedEntries, entries);
         assertEq(recentlyClosedTabIds.length + recentlyClosedWindowIds.length,
           entries.length);
       })
     );
   },
 
   function restoreClosedTabs() {
     chrome.windows.get(windowIds[0], {"populate": true},
       callbackPass(function(win) {
         var tabCountBeforeRestore = win.tabs.length;
-        callForEach(
-          chrome.sessionRestore.restore,
-          recentlyClosedTabIds.slice(0, 2),
-          function each() {
-          },
-          function done() {
-            chrome.windows.get(windowIds[0], {"populate": true},
-              callbackPass(function(win){
-                assertEq(tabCountBeforeRestore + 2, win.tabs.length);
-                win.tabs.forEach(function(tab, i) {
-                  assertEq(pages[i++], tab.url);
-                });
-              })
-            );
-          }
+        chrome.sessions.restore(recentlyClosedTabIds[0], function(tab) {
+          assertEq(pages[0], tab.url);
+        });
+        chrome.sessions.restore(recentlyClosedTabIds[1], function(tab) {
+          assertEq(pages[1], tab.url);
+        });
+        chrome.windows.get(windowIds[0], {"populate": true},
+          callbackPass(function(win){
+            assertEq(tabCountBeforeRestore + 2, win.tabs.length);
+            win.tabs.forEach(function(tab, i) {
+              assertEq(pages[i++], tab.url);
+            });
+          })
         );
       })
     );
   },
 
   function restoreTabInClosedWindow() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      chrome.sessionRestore.restore(recentlyClosedSecondWindowTabIds[0],
-        callbackPass(function() {
+      chrome.sessions.restore(recentlyClosedSecondWindowTabIds[0],
+        callbackPass(function(tab) {
+          assertEq(pages[0], tab.url);
           chrome.windows.getAll({"populate": true},
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore + 1, win.length);
               assertEq(1, win[win.length - 1].tabs.length);
               assertEq(pages[0], win[win.length - 1].tabs[0].url);
             })
           );
         })
       );
     }));
   },
 
   function restoreClosedWindows() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      callForEach(
-        chrome.sessionRestore.restore,
-        recentlyClosedWindowIds.slice(0, 1),
-        function each() {
-        },
-        function done() {
-          chrome.windows.getAll({"populate": true},
-            callbackPass(function(win) {
-              assertEq(windowCountBeforeRestore + 1, win.length);
-            })
-          );
-        }
-      );
+      chrome.sessions.restore(recentlyClosedWindowIds[0], function(window) {
+        assertEq(1, window.tabs.length);
+      });
+      function done() {
+        chrome.windows.getAll({"populate": true},
+          callbackPass(function(win) {
+            assertEq(windowCountBeforeRestore + 1, win.length);
+          })
+        );
+      }
     }));
   },
 
   function restoreSameEntryTwice() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      chrome.sessionRestore.restore(recentlyClosedWindowIds[0],
+      chrome.sessions.restore(recentlyClosedWindowIds[0],
         callbackFail("Invalid session id.", function() {
           chrome.windows.getAll({"populate": true},
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   },
 
   function restoreInvalidEntries() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      chrome.sessionRestore.restore(-1,
+      chrome.sessions.restore("-1",
         callbackFail("Invalid session id.", function() {
           chrome.windows.getAll({"populate": true},
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   },
 
   function restoreMostRecentEntry() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      chrome.sessionRestore.restore(callbackPass(function() {
+      chrome.sessions.restore(callbackPass(function(restoredWindow) {
+        assertEq(2, restoredWindow.tabs.length);
         chrome.windows.getAll({"populate": true},
           callbackPass(function(win) {
             assertEq(windowCountBeforeRestore + 1, win.length);
           })
         );
       }));
     }));
   },
 
   function checkRecentlyClosedListEmpty() {
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
-      chrome.sessionRestore.restore(
+      chrome.sessions.restore(
         callbackFail("There are no recently closed sessions.", function() {
           chrome.windows.getAll({"populate": true},
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   }
-
 ]);