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

[not at google - send to devlin, 2014/03/28 15:51:10]

100*10ms is too small, this only gives the test 1 second to finish which is
going to be flaky. I'd say give it 10 seconds, or really, just don't have a max
number of retries at all and just let the normal test timeout (30s) kick in.

So yeah. No maxRetry. and increase to 1s so that while it's waiting it doesn't
totally spam the console output.

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