windows.create({url:}) now supports relative paths. tabs.update()/tabs.move() now return Tab.

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();
+}
+
 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 21 matching lines @@
     chrome.windows.create({}, pass(function(win) {
       assertTrue(win.id > 0);
       secondWindowId = win.id;
       // Create first window.
       chrome.tabs.create({"windowId" : firstWindowId, "url" : "chrome://a"},
                          pass(function() {
         // Create second window.
         chrome.tabs.create({"windowId" : secondWindowId, "url" : "chrome://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);
@@ skipping 19 matching lines @@
       }
       assertEq("chrome://newtab/", tabs[0].url);
       assertEq("chrome://b/", tabs[1].url);
     }));
   },
 
   function updateUrl() {
     chrome.tabs.get(testTabId, pass(function(tab) {
       assertEq("chrome://a/", tab.url);
       // Update url.
-      chrome.tabs.update(testTabId, {"url": "chrome://c"},
-                         pass(function(){
+      chrome.tabs.update(testTabId, {"url": "chrome://c/"},
+                         pass(function(tab){
+        chrome.test.assertEq("chrome://c/", tab.url);
         // Check url.
         chrome.tabs.get(testTabId, pass(function(tab) {
           assertEq("chrome://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].
       chrome.tabs.update(tabs[1].id, {selected: true},
-                         pass(function(){
+                         pass(function(tab1){
         // Check update of tab[1].
+        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(){
+                             pass(function(tab2){
             // Check update of tab[2].
+            chrome.test.assertEq(true, tab2.selected); 
             chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
               assertEq(false, tabs[1].selected);
               assertEq(true, tabs[2].selected);
             }));
           }));
         }));
       }));
     }));
   },
 
@@ skipping 41 matching lines @@
   //
   // Before:
   //  Window1: (newtab),a,b,c,d,e
   //  Window2: (newtab)
   //
   // After:
   //  Window1: (newtab),a,e,c
   //  Window2: b,(newtab),d
   function moveTabs() {
     chrome.tabs.move(moveTabIds['b'], {"windowId": moveWindow2, "index": 0},
-                     pass(function() {
+                     pass(function(tabB) {
+        chrome.test.assertEq(0, tabB.index);
         chrome.tabs.move(moveTabIds['e'], {"index": 2},
-                         pass(function() {
+                         pass(function(tabE) {
+          chrome.test.assertEq(2, tabE.index);           
           chrome.tabs.move(moveTabIds['d'], {"windowId": moveWindow2,
-              "index": 2}, pass(function() {}));
+                           "index": 2}, pass(function(tabD) {
+            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("chrome://a/", tabs[1].url);
       assertEq("chrome://e/", tabs[2].url);
       assertEq("chrome://c/", tabs[3].url);
  
       chrome.tabs.getAllInWindow(moveWindow2, pass(function(tabs) {
@@ skipping 97 matching lines @@
     chrome.tabs.update(moveTabIds['c'], {"selected": true},
                        pass());
   },
 
   function onRemoved() {
     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());
+          }
+        }
+      }));
+    }));
+  },
+  
+  // The subsequent three tests all load relative.html, which calls
+  // this page's relativePageLoad(), which ends the test.
+  function relativeUrlTabsCreate() {
+    chrome.tabs.create({windowId: firstWindowId, url: 'relative.html'},
+      pass(function(tab){
+        testTabId = tab.id;
+      }
+    ));
+  },
+
+  function relativeUrlTabsUpdate() {
+    chrome.tabs.update(testTabId, {url: "chrome://a/"}, function(tab) {
+      chrome.test.assertEq("chrome://a/", tab.url);
+      chrome.tabs.update(tab.id, {url: "relative.html"}, function(tab) {  
+      });
+    });
+  },
+  
+  function relativeUrlWindowsCreate() {
+    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.
 ]);