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 done = chrome.test.listenForever(chrome.sessions.onChanged, function() {
+      callbackCount++;
+    }
+  );
+
+  return function() {
+    var retry = 0;
+    var checkEvent = function() {
+      if (callbackCount < expectedCallbackCount) {
+        retry++;
+        if (retry % 10 == 0)
+          console.log("Waiting for " +
+                      (expectedCallbackCount - callbackCount) +
+                      " more onChanged events");
+        window.setTimeout(checkEvent, 100);

[not at google - send to devlin, 2014/03/28 18:44:48]

last nit: declare this 100 as a var up in the checkOnChangedEvent scope.

// The frequency in ms between checking whether the right events have
// fired. Every 10 attempts progress is logged.
var retryPeriod = 100ms;

+      } else {
+        assertEq(callbackCount, expectedCallbackCount);
+        done();
+      }
+    };
+    window.setTimeout(checkEvent, 100);
+  };
+}
+
 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.
+    var checkEvent = 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);
             });
+            checkEvent();
           })
         );
       }
     );
   },
 
   function retrieveClosedWindows() {
     // Check that the recently closed list contains what we expect
     // after removing windows.
+    var checkEvent = 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 = [
               { window: { tabsLength: 2 } },
               { window: { tabsLength: 2 } }
             ];
             checkEntries(expectedEntries, entries);
             entries[0].window.tabs.forEach(function(tab) {
               recentlyClosedSecondWindowTabIds.push(tab.sessionId);
             });
             entries.forEach(function(entry) {
               recentlyClosedWindowIds.push(entry.window.sessionId);
             });
+            checkEvent();
           })
         );
       }
     );
   },
 
   function retrieveClosedEntries() {
     // Check that the recently closed list contains what we expect
     // after removing tabs and windows.
     chrome.sessions.getRecentlyClosed(
@@ skipping 23 matching lines @@
           { tab: { url: pages[1] } }
         ];
         checkEntries(expectedEntries, entries);
         assertEq(recentlyClosedTabIds.length + recentlyClosedWindowIds.length,
           entries.length);
       })
     );
   },
 
   function restoreClosedTabs() {
+    var checkEvent = 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);
             });
+            checkEvent();
           })
         );
       })
     );
   },
 
   function restoreTabInClosedWindow() {
+    var checkEvent = 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);
+              checkEvent();
             })
           );
         })
       );
     }));
   },
 
   function restoreClosedWindows() {
+    var checkEvent = 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);
+            checkEvent();
           });
       function done() {
         chrome.windows.getAll({"populate": true},
           callbackPass(function(win) {
             assertEq(windowCountBeforeRestore + 1, win.length);
           })
         );
       }
     }));
   },
@@ skipping 23 matching lines @@
             callbackPass(function(win) {
               assertEq(windowCountBeforeRestore, win.length);
             })
           );
         })
       );
     }));
   },
 
   function restoreMostRecentEntry() {
+    var checkEvent = 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);
+            checkEvent();
           })
         );
       }));
     }));
   },
 
   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);
             })
           );
         })
       );
     }));
   }
 ]);