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,

[not at google - send to devlin, 2014/03/26 21:12:38]

I keep reading this as a function body, because the indent is 2 not 4. I suggest
changing this to look like

var done = chrome.test.listenForever(chrome.sessions.onChanged, function() {
  callbackCount++;
});

+    function() {
+      callbackCount++;
+    }
+  );
+
+  var checkEvent = function() {
+    if (callbackCount < expectedCallbackCount)
+      window.setTimeout(checkEvent, 100);
+    else {
+      assertEq(callbackCount, expectedCallbackCount);
+      doneListening();
+    }
+  };
+  window.setTimeout(checkEvent, 1000);

[not at google - send to devlin, 2014/03/26 21:12:38]

It would be nice to notify the user why this test is still alive, if it is. E.g.
log each time the check is re-retried. Really this should be a helper exposed on
chrome.test, like chrome.test.listenNTimes, but let's worry about that later
(perhaps file a bug).

Anyway, it's not just as simple as logging "checking" each time you check,
because that will cause a lot of log spew. There needs to be a way to signal to
the event checker that all the events should have happened by now, and to wait.

How about:
- change the test retry to 1000 (from 100)
- make this function return a function meaning "test is finished, call me now"
- when that function is called, start logging "waiting for <n> more onChanged
events"

+}
+
 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);
             })
           );
         })
       );
     }));
   }
 ]);