Address ExtensionApiTest.Tabs flakiness

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

 // tabs api test
 // browser_tests.exe --gtest_filter=ExtensionApiTest.Tabs
 
 // We have a bunch of places where we need to remember some state from one
 // test (or setup code) to subsequent tests.
 var firstWindowId = null;
 var secondWindowId = null;
 var firstTabIndex = null;
 var testTabId = null;
 
 var moveWindow1 = null;
 var moveWindow2 = null;
 var moveTabIds = {};
 
 var pass = chrome.test.callbackPass;
 var assertEq = chrome.test.assertEq;
 var assertTrue = chrome.test.assertTrue;
 
-// Called by relative.html during onload.
-function relativePageLoaded() {
-  chrome.test.succeed();
+function pageUrl(letter) {
+  return chrome.extension.getURL(letter + ".html");
 }
 
 chrome.test.runTests([
   function getSelected() {
     chrome.tabs.getSelected(null, pass(function(tab) {
       assertEq("about:blank", tab.url);
       assertEq("about:blank", tab.title);
       firstWindowId = tab.windowId;
       firstTabIndex = tab.index;
     }));
@@ skipping 17 matching lines @@
   // Setup a new window for later tests, and open some tabs in the
   // first and second windows.
   function createWindow() {
     // TODO(asargent) Add more tests for:
     //  1) window sizing/positioning.
     //  2) passed url (relative & absolute)
     chrome.windows.create({}, pass(function(win) {
       assertTrue(win.id > 0);
       secondWindowId = win.id;
       // Create first window.
-      chrome.tabs.create({"windowId" : firstWindowId, "url" : "chrome://a"},
+      chrome.tabs.create({"windowId" : firstWindowId, "url" : pageUrl("a")},
                          pass(function() {
         // Create second window.
-        chrome.tabs.create({"windowId" : secondWindowId, "url" : "chrome://b"},
+        chrome.tabs.create({"windowId" : secondWindowId, "url" :pageUrl("b")},
                            pass());
       }));
     }));
   },
 
   function getAllFirstWindow() {
     // TODO(asargent) Add test for passing null for windowId - this should
     // default to the "current" window.
     chrome.tabs.getAllInWindow(firstWindowId,
                                pass(function(tabs) {
       assertEq(3, tabs.length);
       for (var i = 0; i < tabs.length; i++) {
         assertEq(firstWindowId, tabs[i].windowId);
         assertEq(i, tabs[i].index);
 
         // The most recent tab should be selected
         assertEq((i == 2), tabs[i].selected);
       }
       assertEq("about:blank", tabs[0].url);
       assertEq("chrome://newtab/", tabs[1].url);
-      assertEq("chrome://a/", tabs[2].url);
+      assertEq(pageUrl("a"), tabs[2].url);
       testTabId = tabs[2].id;
     }));
   },
 
   function getAllSecondWindow() {
     chrome.tabs.getAllInWindow(secondWindowId,
                                pass(function(tabs) {
       assertEq(2, tabs.length);
       for (var i = 0; i < tabs.length; i++) {
         assertEq(secondWindowId, tabs[i].windowId);
         assertEq(i, tabs[i].index);
       }
       assertEq("chrome://newtab/", tabs[0].url);
-      assertEq("chrome://b/", tabs[1].url);
+      assertEq(pageUrl("b"), tabs[1].url);
     }));
   },
 
   function updateUrl() {
     chrome.tabs.get(testTabId, pass(function(tab) {
-      assertEq("chrome://a/", tab.url);
+      assertEq(pageUrl("a"), tab.url);
       // Update url.
-      chrome.tabs.update(testTabId, {"url": "chrome://c/"},
+      chrome.tabs.update(testTabId, {"url": pageUrl("c")},
                          pass(function(tab){
-        chrome.test.assertEq("chrome://c/", tab.url);
+        chrome.test.assertEq(pageUrl("c"), tab.url);
         // Check url.
         chrome.tabs.get(testTabId, pass(function(tab) {
-          assertEq("chrome://c/", tab.url);
+          assertEq(pageUrl("c"), tab.url);
         }));
       }));
     }));
   },
 
   function updateSelect() {
     chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
       assertEq(false, tabs[1].selected);
       assertEq(true, tabs[2].selected);
       // Select tab[1].
@@ skipping 30 matching lines @@
         }));
       }));
     }));
   },
 
   // Create a bunch of tabs and record the resulting ids.
   function moveTabsSetup2() {
     var letters = ['a', 'b', 'c', 'd', 'e'];
     for (var i in letters) {
       chrome.tabs.create({"windowId": moveWindow1,
-                          "url": "chrome://" + letters[i]},
+                          "url": pageUrl(letters[i])},
                          pass(function(tab) {
-        var letter = tab.url[tab.url.length-2];
+        var letter = tab.url[tab.url.length-6];
         moveTabIds[letter] = tab.id;
         
         // Assert on last callback that tabs were added in the order we created
         // them.
         if (letter == 'e') {
           chrome.tabs.getAllInWindow(moveWindow1, pass(function(tabs) {
             assertEq(6, tabs.length);
             assertEq("chrome://newtab/", tabs[0].url);
-            assertEq("chrome://a/", tabs[1].url);
-            assertEq("chrome://b/", tabs[2].url);
-            assertEq("chrome://c/", tabs[3].url);
-            assertEq("chrome://d/", tabs[4].url);
-            assertEq("chrome://e/", tabs[5].url);
+            assertEq(pageUrl("a"), tabs[1].url);
+            assertEq(pageUrl("b"), tabs[2].url);
+            assertEq(pageUrl("c"), tabs[3].url);
+            assertEq(pageUrl("d"), tabs[4].url);
+            assertEq(pageUrl("e"), tabs[5].url);
           }));
         }
       }));
     }
   },
 
   // Do a series of moves so that we get the following
   //
   // Before:
   //  Window1: (newtab),a,b,c,d,e
@@ skipping 15 matching lines @@
         }));
       }));
     }));
   },
   
   // Check that the tab/window state is what we expect after doing moves.
   function moveTabsCheck() {
     chrome.tabs.getAllInWindow(moveWindow1, pass(function(tabs) {
       assertEq(4, tabs.length);
       assertEq("chrome://newtab/", tabs[0].url);
-      assertEq("chrome://a/", tabs[1].url);
-      assertEq("chrome://e/", tabs[2].url);
-      assertEq("chrome://c/", tabs[3].url);
+      assertEq(pageUrl("a"), tabs[1].url);
+      assertEq(pageUrl("e"), tabs[2].url);
+      assertEq(pageUrl("c"), tabs[3].url);
  
       chrome.tabs.getAllInWindow(moveWindow2, pass(function(tabs) {
         assertEq(3, tabs.length);
-        assertEq("chrome://b/", tabs[0].url);
+        assertEq(pageUrl("b"), tabs[0].url);
         assertEq("chrome://newtab/", tabs[1].url);
-        assertEq("chrome://d/", tabs[2].url);
+        assertEq(pageUrl("d"), tabs[2].url);
       }));      
     }));
   },
 
   function remove() {
     chrome.tabs.remove(moveTabIds["d"], pass(function() {
       chrome.tabs.getAllInWindow(moveWindow2,
                                  pass(function(tabs) {
         assertEq(2, tabs.length);
-        assertEq("chrome://b/", tabs[0].url);
+        assertEq(pageUrl("b"), tabs[0].url);
         assertEq("chrome://newtab/", tabs[1].url);
       }));
     }));
   },
 
   function detectLanguage() {
     chrome.tabs.getAllInWindow(moveWindow1, pass(function(tabs) {
       chrome.tabs.detectLanguage(tabs[0].id, pass(function(lang) {
         assertEq("en", lang);
       }));
@@ skipping 28 matching lines @@
           assertEq("string", typeof(url));
           assertTrue(url.length > 0);
           assertTrue(url == window1Url || url == window2Url);
         }));
       }));
     }));
   }, */
 
   function onCreated() {
     chrome.test.listenOnce(chrome.tabs.onCreated, function(tab) {
-      assertEq("chrome://f/", tab.url);
+      assertEq(pageUrl("f"), tab.url);
     });
     
-    chrome.tabs.create({"windowId": moveWindow1, "url": "chrome://f",
+    chrome.tabs.create({"windowId": moveWindow1, "url": pageUrl("f"),
                         "selected": true}, pass(function(tab) {}));
   },
 
   function onUpdated() {
-    var listener = chrome.test.listenForever(chrome.tabs.onUpdated,
+    var onUpdatedCompleted = chrome.test.listenForever(chrome.tabs.onUpdated,
       function(tabid, info) {
         if (tabid == moveTabIds['a'] && info.status == "complete") {
-          listener.doneListening();
+          onUpdatedCompleted();
         }
       }
     );
     
-    chrome.tabs.update(moveTabIds['a'], {"url": "chrome://aa"},
+    chrome.tabs.update(moveTabIds['a'], {"url": pageUrl("f")},
                        pass());
   },
 
   function onMoved() {
     chrome.test.listenOnce(chrome.tabs.onMoved, function(tabid, info) {
       assertEq(moveTabIds['a'], tabid);
     });
  
     chrome.tabs.move(moveTabIds['a'], {"index": 0}, pass());
   },
@@ skipping 25 matching lines @@
       chrome.windows.getAll({}, pass(function(windows) {
         for (var i = 0; i < windows.length; i++) {
           if (windows[i].id != firstWindowId) {
             chrome.windows.remove(windows[i].id, pass());
           }
         }
       }));
     }));
   },
   
-  // The subsequent three tests all load relative.html, which calls
-  // this page's relativePageLoad(), which ends the test.
   function relativeUrlTabsCreate() {
+    // Will be called from relative.html
+    window.relativePageLoaded = chrome.test.callbackAdded();
+    var createCompleted = chrome.test.callbackAdded();
+
     chrome.tabs.create({windowId: firstWindowId, url: 'relative.html'}, 
       function(tab){
         testTabId = tab.id;
+        createCompleted();
       }
     );
   },
 
   function relativeUrlTabsUpdate() {
-    chrome.tabs.update(testTabId, {url: "chrome://a/"}, function(tab) {
-      chrome.test.assertEq("chrome://a/", tab.url);
+    // Will be called from relative.html
+    window.relativePageLoaded = chrome.test.callbackAdded();
+
+    chrome.tabs.update(testTabId, {url: pageUrl("a")}, function(tab) {
+      chrome.test.assertEq(pageUrl("a"), tab.url);
       chrome.tabs.update(tab.id, {url: "relative.html"}, function(tab) {  
       });
     });
   },
   
   function relativeUrlWindowsCreate() {
+    // Will be called from relative.html
+    window.relativePageLoaded = chrome.test.callbackAdded();
+ 
     chrome.windows.create({url: "relative.html"});
   }
 
   // TODO(asargent) We still need to add tests for the following:
   //  Methods:
   //   -chrome.tabs.connect
   //  Events:
   //   -chrome.tabs.onAttached
   //   -chrome.tabs.onDetched
   //
   // Also, it would be an improvement to check the captureVisibleTab results
   // against a known-good result.
 ]);