Add onChanged callback for chrome.sessions API.

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

 // Copyright 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.
 
 var pages = [pageUrl('a'), pageUrl('b'), pageUrl('c')];
 var firstWindowTabIds = [];
 var recentlyClosedSecondWindowTabIds = [];
 var recentlyClosedTabIds = [];
 var recentlyClosedWindowIds = [];
 var windowIds = [];
@@ skipping 41 matching lines @@
       assertFalse(actual.hasOwnProperty('window'));
       assertEq(expected.tab.url, actual.tab.url);
     } else {
       assertTrue(actual.hasOwnProperty('window'));
       assertFalse(actual.hasOwnProperty('tab'));
       assertEq(expected.window.tabsLength, actual.window.tabs.length);
     }
   });
 }
 
+function checkOnChangedEvent(expectedCallbackCount) {
+  var callbackCount = 0;
+  var doneListening = chrome.test.listenForever(
+    chrome.sessions.onChanged,
+    function() {
+      callbackCount++;
+      if (callbackCount == expectedCallbackCount)
+        doneListening();
+    }
+  );
+}

[not at google - send to devlin, 2014/03/21 10:52:59]

this doesn't actually make any assertions. yes it counts but what then? does it
mean that the test times out? that's not a great experience. what if it's called
too many times?

testing events is hard :\

an alternatively might be to add a listener for each test then do like

assertEq(2, numEventsFired)

or whatever.

[wjywbs, 2014/03/21 19:45:33]

I haven't found a good way yet. I looked at the other api tests just now, such
as chrome.tabs.onRemoved event:
chrome/test/data/extensions/api_test/tabs/on_removed/test.js
In that test, it used chrome.test.listenOnce, so if the callback is called for
multiple times, it would not detect that. Yes, it times out if the listener is
not called.

If we do assertEq(2, numEventsFired), I think I need to wait for 1 or 2 seconds
for finishing the callbacks and then do this check. Is this acceptable?

+
 chrome.test.runTests([
   // After setupWindows
   //
   //  Window1: a,b,c
   //  Window2: a,b
   //  Window3: a,b
   //
   // After retrieveClosedTabs:
   //
   //  Window1: c
@@ skipping 29 matching lines @@
             assertEq(callArgs.length + 1, win.length);
           })
         );
       }
     );
   },
 
   function retrieveClosedTabs() {
     // Check that the recently closed list contains what we expect
     // after removing tabs.
+    checkOnChangedEvent(2);
+
     callForEach(
       chrome.tabs.remove,
       firstWindowTabIds.slice(0, 2).reverse(),
       function each() {
       },
       function done() {
         chrome.sessions.getRecentlyClosed(
           {maxResults: 2},
           callbackPass(function(entries) {
             var expectedEntries = [
               { tab: { url: pages[0] } },
               { tab: { url: pages[1] } }
             ];
             checkEntries(expectedEntries, entries);
             entries.forEach(function(entry) {
               recentlyClosedTabIds.push(entry.tab.sessionId);
             });
           })
         );
       }
     );
   },
 
   function retrieveClosedWindows() {
     // Check that the recently closed list contains what we expect
     // after removing windows.
+    checkOnChangedEvent(2);
+
     callForEach(
       chrome.windows.remove,
       windowIds.slice(1, 3).reverse(),
       function each() {
       },
       function done() {
         chrome.sessions.getRecentlyClosed(
           {maxResults: 2},
           callbackPass(function(entries) {
             var expectedEntries = [
@@ skipping 43 matching lines @@
           { tab: { url: pages[1] } }
         ];
         checkEntries(expectedEntries, entries);
         assertEq(recentlyClosedTabIds.length + recentlyClosedWindowIds.length,
           entries.length);
       })
     );
   },
 
   function restoreClosedTabs() {
+    checkOnChangedEvent(2);
+
     chrome.windows.get(windowIds[0], {"populate": true},
       callbackPass(function(win) {
         var tabCountBeforeRestore = win.tabs.length;
         chrome.sessions.restore(recentlyClosedTabIds[0], function(tab_session) {
           assertEq(pages[0], tab_session.tab.url);
         });
         chrome.sessions.restore(recentlyClosedTabIds[1], function(tab_session) {
           assertEq(pages[1], tab_session.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() {
+    checkOnChangedEvent(1);
+
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
       chrome.sessions.restore(recentlyClosedSecondWindowTabIds[0],
         callbackPass(function(tab_session) {
           assertEq(pages[0], tab_session.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() {
+    checkOnChangedEvent(1);
+
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
       chrome.sessions.restore(recentlyClosedWindowIds[0],
           function(win_session) {
             assertEq(1, win_session.window.tabs.length);
           });
       function done() {
         chrome.windows.getAll({"populate": true},
           callbackPass(function(win) {
             assertEq(windowCountBeforeRestore + 1, win.length);
@@ skipping 28 matching lines @@
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   },
 
   function restoreMostRecentEntry() {
+    checkOnChangedEvent(1);
+
     chrome.windows.getAll({"populate": true}, callbackPass(function(win) {
       var windowCountBeforeRestore = win.length;
       chrome.sessions.restore(callbackPass(function(win_session) {
         assertEq(2, win_session.window.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.sessions.restore(
         callbackFail("There are no recently closed sessions.", function() {
           chrome.windows.getAll({"populate": true},
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   }
 ]);