Issue 21729: Add new event chrome.tabs.onStatusChange .

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;
 
@@ skipping 103 matching lines @@
   },
 
   function updateSelect() {
     chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
       assertEq(false, tabs[1].selected);
       assertEq(true, tabs[2].selected);
       // Select tab[1].
       chrome.tabs.update(tabs[1].id, {selected: true},
                          pass(function(tab1){
         // Check update of tab[1].
-        chrome.test.assertEq(true, tab1.selected);     
+        chrome.test.assertEq(true, tab1.selected);
         chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
           assertEq(true, tabs[1].selected);
           assertEq(false, tabs[2].selected);
           // Select tab[2].
           chrome.tabs.update(tabs[2].id, {selected: true},
                              pass(function(tab2){
             // Check update of tab[2].
-            chrome.test.assertEq(true, tab2.selected); 
+            chrome.test.assertEq(true, tab2.selected);
             chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
               assertEq(false, tabs[1].selected);
               assertEq(true, tabs[2].selected);
             }));
           }));
         }));
       }));
     }));
   },
 
@@ skipping 12 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": pageUrl(letters[i])},
                          pass(function(tab) {
         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(pageUrl("a"), tabs[1].url);
             assertEq(pageUrl("b"), tabs[2].url);
             assertEq(pageUrl("c"), tabs[3].url);
             assertEq(pageUrl("d"), tabs[4].url);
@@ skipping 12 matching lines @@
   //
   // After:
   //  Window1: (newtab),a,e,c
   //  Window2: b,(newtab),d
   function moveTabs() {
     chrome.tabs.move(moveTabIds['b'], {"windowId": moveWindow2, "index": 0},
                      pass(function(tabB) {
         chrome.test.assertEq(0, tabB.index);
         chrome.tabs.move(moveTabIds['e'], {"index": 2},
                          pass(function(tabE) {
-          chrome.test.assertEq(2, tabE.index);           
+          chrome.test.assertEq(2, tabE.index);
           chrome.tabs.move(moveTabIds['d'], {"windowId": moveWindow2,
                            "index": 2}, pass(function(tabD) {
-            chrome.test.assertEq(2, tabD.index);     
+            chrome.test.assertEq(2, tabD.index);
         }));
       }));
     }));
   },
-  
+
   // 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(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(pageUrl("b"), tabs[0].url);
         assertEq("chrome://newtab/", tabs[1].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(pageUrl("b"), tabs[0].url);
         assertEq("chrome://newtab/", tabs[1].url);
@@ skipping 14 matching lines @@
      TODO(rafaelw): This test fails in at least three distinct ways. One where
      the function actually fails to get anything and logs a "Internal error
      while trying to capture visible region of the current tab" error from the
      browser process.
   function captureVisibleTab() {
     // Take First Capture
     chrome.tabs.captureVisibleTab(moveWindow1,
                                   pass(function(window1Url) {
       assertEq("string", typeof(window1Url));
       assertTrue(window1Url.length > 0);
-      
+
       // Take Second Capture
       chrome.tabs.captureVisibleTab(moveWindow2,
                                     pass(function(window2Url) {
         assertEq("string", typeof(window2Url));
         assertTrue(window2Url.length > 0);
         assertTrue(window1Url != window2Url);
-        
+
         // Now pass null for windowId - it should come back with something
         // equal to either the first or second window. This is nondeterministic
         // depending on whether you let chrome stay focused, or click
         // focus away (or are running on the try/build servers).
         chrome.tabs.captureVisibleTab(null, pass(function(url) {
           assertEq("string", typeof(url));
           assertTrue(url.length > 0);
           assertTrue(url == window1Url || url == window2Url);
         }));
       }));
     }));
   }, */
 
   function tabsOnCreated() {
     chrome.test.listenOnce(chrome.tabs.onCreated, function(tab) {
       assertEq(pageUrl("f"), tab.url);
     });
-    
+
     chrome.tabs.create({"windowId": moveWindow1, "url": pageUrl("f"),
                         "selected": true}, pass(function(tab) {}));
   },
 
-  function tabsOnUpdated() {
+  function tabsOnUpdatedIgnoreTabArg() {
+    // A third argument was added to the onUpdated event callback.
+    // Test that an event handler which ignores this argument works.
     var onUpdatedCompleted = chrome.test.listenForever(chrome.tabs.onUpdated,
-      function(tabid, info) {
-        if (tabid == moveTabIds['a'] && info.status == "complete") {
+      function(tabid, changeInfo) {
+        if (tabid == moveTabIds['a'] && changeInfo.status == "complete") {
           onUpdatedCompleted();
         }
       }
     );
-    
-    chrome.tabs.update(moveTabIds['a'], {"url": pageUrl("f")},
-                       pass());
+
+    chrome.tabs.update(moveTabIds['a'], {"url": pageUrl("f")}, pass());
+  },
+
+  function tabsOnUpdated() {
+    var onUpdatedCompleted = chrome.test.listenForever(
+      chrome.tabs.onUpdated,
+      function(tabid, changeInfo, tab) {
+        // |tab| contains the id of the tab it describes.
+        // Test that |tabid| matches this id.
+        assertEq(tabid, tab.id);
+
+        // If |changeInfo| has a status property, than
+        // it should match the status of the tab in |tab|.
+        if (changeInfo.status) {
+          assertEq(changeInfo.status, tab.status);
+        }
+
+        if (tabid == moveTabIds['a'] && changeInfo.status == "complete") {
+          onUpdatedCompleted();
+        }
+      }
+    );
+
+    chrome.tabs.update(moveTabIds['a'], {"url": pageUrl("f")}, pass());
   },
 
   function tabsOnMoved() {
     chrome.test.listenOnce(chrome.tabs.onMoved, function(tabid, info) {
       assertEq(moveTabIds['a'], tabid);
     });
- 
+
     chrome.tabs.move(moveTabIds['a'], {"index": 0}, pass());
   },
 
   function tabsOnSelectionChanged() {
     chrome.test.listenOnce(chrome.tabs.onSelectionChanged,
       function(tabid, info) {
         assertEq(moveTabIds['c'], tabid);
       }
     );
-    
+
     chrome.tabs.update(moveTabIds['c'], {"selected": true},
                        pass());
   },
 
   function tabsOnRemoved() {
     chrome.test.listenOnce(chrome.tabs.onRemoved, function(tabid) {
       assertEq(moveTabIds['c'], tabid);
     });
 
     chrome.tabs.remove(moveTabIds['c'], pass());
   },
 
   function setupRelativeUrlTests() {
     chrome.windows.create({}, pass(function(win) {
       assertTrue(win.id > 0);
       firstWindowId = win.id;
 
       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());
           }
         }
       }));
     }));
   },
-  
+
   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'}, 
+    chrome.tabs.create({windowId: firstWindowId, url: 'relative.html'},
       function(tab){
         testTabId = tab.id;
         createCompleted();
       }
     );
   },
 
   function relativeUrlTabsUpdate() {
     // 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) {  
+      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"});
   },
-  
+
   function windowsOnCreated() {
     chrome.test.listenOnce(chrome.windows.onCreated, function(window) {
       chrome.test.assertTrue(window.width > 0);
       chrome.test.assertTrue(window.height > 0);
       windowEventsWindow = window;
       chrome.tabs.getAllInWindow(window.id, pass(function(tabs) {
         assertEq(pageUrl("a"), tabs[0].url);
       }));
     });
 
@@ skipping 11 matching lines @@
   // 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.
 ]);