Reverting the CLD CL altogether, the reliability bot is still red.

BUG=30681 TEST=None TBR=brettw Review URL: http://codereview.chromium.org/504048 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@34867 0039d316-1c4b-4281-b951-d872f2087c98
author: jcampan@chromium.org <jcampan@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2009-12-17 20:17:00 +0000
committer: jcampan@chromium.org <jcampan@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2009-12-17 20:17:00 +0000
commit: f345876ca7aac5ff6f4e08242891b800c48cedcd (patch)
tree: d8096238c5a3acad0f08a69f45744d5c843875f5 /chrome/test
parent: f7b7ffe4267e517b99c24391a51622f29c0476f0 (diff)
download: chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.zip
chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.tar.gz
chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.tar.bz2
5 files changed, 576 insertions, 48 deletions
diff --git a/chrome/test/data/english_page.html b/chrome/test/data/english_page.html
deleted file mode 100644
index 539920d..0000000
--- a/chrome/test/data/english_page.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<html>
-<head><title>This page is in English</title></head>
-<body>
-No joke! This is a page written in English. Awesome don't you think?
-</body>
-</html>
diff --git a/chrome/test/data/extensions/api_test/tabs/test.js b/chrome/test/data/extensions/api_test/tabs/test.js
new file mode 100644
index 0000000..ba02f033
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/tabs/test.js
@@ -0,0 +1,576 @@
+// 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 windowEventsWindow = null;
+var moveTabIds = {};
+
+var pass = chrome.test.callbackPass;
+var assertEq = chrome.test.assertEq;
+var assertTrue = chrome.test.assertTrue;
+
+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;
+    }));
+  },
+
+  function create() {
+    chrome.tabs.create({"windowId" : firstWindowId, "selected" : false},
+                       pass(function(tab){
+      assertTrue(tab.index > firstTabIndex);
+      assertEq(firstWindowId, tab.windowId);
+      assertEq(false, tab.selected);
+      assertEq("chrome://newtab/", tab.url);
+    }));
+  },
+
+  function createInOtherWindow() {
+    chrome.windows.create({}, pass(function(win) {
+      // The newly created window is now the currentWindow.
+      // Create a tab in the older window.
+      chrome.tabs.create({"windowId" : firstWindowId, "selected" : false},
+                         pass(function(tab) {
+        assertEq(firstWindowId, tab.windowId);
+      }));
+      // Create a tab in this new window.
+      chrome.tabs.create({"windowId" : win.id}, pass(function(tab) {
+        assertEq(win.id, tab.windowId);
+      }));
+    }));
+  },
+
+  function createAtIndex() {
+    chrome.tabs.create({"windowId" : firstWindowId, "index" : 1},
+                       pass(function(tab) {
+      assertEq(1, tab.index);
+    }));
+  },
+
+  function createSelected() {
+    chrome.tabs.create({"windowId" : firstWindowId, "selected" : true},
+                       pass(function(tab) {
+      assertTrue(tab.selected);
+      chrome.tabs.getSelected(firstWindowId, pass(function(selectedTab) {
+        assertEq(tab.id, selectedTab.id);
+      }));
+    }));
+  },
+
+  function setupTwoWindows() {
+    setupWindow(["about:blank", "chrome://newtab/", pageUrl("a")],
+                        pass(function(winId, tabIds) {
+      firstWindowId = winId;
+      testTabId = tabIds[2];
+
+      createWindow(["chrome://newtab/", pageUrl("b")],
+                           pass(function(winId, tabIds) {
+        secondWindowId = winId;
+      }));
+    }));
+  },
+
+  function getAllInWindow() {
+    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(pageUrl("a"), tabs[2].url);
+    }));
+
+    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(pageUrl("b"), tabs[1].url);
+    }));
+  },
+
+  /* TODO: Enable this test when crbug.com/28055 is fixed. This bug causes a
+     newly created window not to be set as the current window, if
+     Chrome was not the foreground window when the create call was made.
+  function getAllInWindowNullArg() {
+    chrome.tabs.getAllInWindow(null, pass(function(tabs) {
+      assertEq(2, tabs.length);
+      assertEq(secondWindowId, tabs[0].windowId);
+    }));
+  }, */
+
+  function update() {
+    chrome.tabs.get(testTabId, pass(function(tab) {
+      assertEq(pageUrl("a"), tab.url);
+      // Update url.
+      chrome.tabs.update(testTabId, {"url": pageUrl("c")},
+                         pass(function(tab){
+        chrome.test.assertEq(pageUrl("c"), tab.url);
+        // Check url.
+        chrome.tabs.get(testTabId, pass(function(tab) {
+          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].
+      chrome.tabs.update(tabs[1].id, {selected: true},
+                         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(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);
+            }));
+          }));
+        }));
+      }));
+    }));
+  },
+
+  // Do a series of moves so that we get the following
+  //
+  // Before:
+  //  Window1: (newtab),a,b,c,d,e
+  //  Window2: (newtab)
+  //
+  // After:
+  //  Window1: (newtab),a,e,c
+  //  Window2: b,(newtab),d
+  function setupLetterPages() {
+    var pages = ["chrome://newtab/", pageUrl('a'), pageUrl('b'),
+                   pageUrl('c'), pageUrl('d'), pageUrl('e')];
+    setupWindow(pages, pass(function(winId, tabIds) {
+      firstWindowId = winId;
+      moveTabIds['a'] = tabIds[1];
+      moveTabIds['b'] = tabIds[2];
+      moveTabIds['c'] = tabIds[3];
+      moveTabIds['d'] = tabIds[4];
+      moveTabIds['e'] = tabIds[5];
+      createWindow(["chrome://newtab/"], pass(function(winId, tabIds) {
+        secondWindowId = winId;
+      }));
+      chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
+        assertEq(pages.length, tabs.length);
+        for (var i in tabs) {
+          assertEq(pages[i], tabs[i].url);
+        }
+      }));
+    }));
+  },
+
+  function move() {
+    // Check that the tab/window state is what we expect after doing moves.
+    function checkMoveResults()
+    {
+      chrome.tabs.getAllInWindow(firstWindowId, 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(secondWindowId, 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);
+        }));
+      }));
+    }
+
+    chrome.tabs.move(moveTabIds['b'], {"windowId": secondWindowId, "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.tabs.move(moveTabIds['d'], {"windowId": secondWindowId,
+                           "index": 2}, pass(function(tabD) {
+            chrome.test.assertEq(2, tabD.index);
+            checkMoveResults();
+        }));
+      }));
+    }));
+  },
+
+  function remove() {
+    chrome.tabs.remove(moveTabIds["d"], pass(function() {
+      chrome.tabs.getAllInWindow(secondWindowId,
+                                 pass(function(tabs) {
+        assertEq(2, tabs.length);
+        assertEq(pageUrl("b"), tabs[0].url);
+        assertEq("chrome://newtab/", tabs[1].url);
+      }));
+    }));
+  },
+
+  function detectLanguage() {
+    chrome.tabs.getAllInWindow(firstWindowId, pass(function(tabs) {
+      chrome.tabs.detectLanguage(tabs[0].id, pass(function(lang) {
+        assertEq("en", lang);
+      }));
+    }));
+  },
+
+  /* TODO(rafaelw): Ideally, this test would include a page with known content,
+     it'd take a capture and compare it to some expected output.
+     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(firstWindowId,
+                                  pass(function(window1Url) {
+      assertEq("string", typeof(window1Url));
+      assertTrue(window1Url.length > 0);
+
+      // Take Second Capture
+      chrome.tabs.captureVisibleTab(secondWindowId,
+                                    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": firstWindowId, "url": pageUrl("f"),
+                        "selected": true}, pass(function(tab) {}));
+  },
+
+  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, changeInfo) {
+        if (tabid == moveTabIds['a'] && changeInfo.status == "complete") {
+          onUpdatedCompleted();
+        }
+      }
+    );
+
+    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 setupTabsOnAttachDetach()
+  {
+    setupWindow(["", ""], pass(function(winId, tabIds) {
+      firstWindowId = winId;
+      testTabId = tabIds[1];
+      createWindow([""], pass(function(winId, tabIds) {
+        secondWindowId = winId;
+      }));
+    }));
+  },
+
+  function tabsOnAttached() {
+    function moveAndListen(tabId, properties, callback) {
+      chrome.test.listenOnce(chrome.tabs.onAttached,
+                             function(testTabId, info) {
+        // Ensure notification is correct.
+        assertEq(testTabId, tabId);
+        assertEq(properties.windowId, info.newWindowId);
+        assertEq(properties.index, info.newPosition);
+        if (callback)
+          callback();
+      });
+      chrome.tabs.move(tabId, properties);
+    };
+
+    // Move tab to second window, then back to first.
+    // The original tab/window configuration should be restored.
+    // tabsOnDetached() depends on it.
+    moveAndListen(testTabId, {"windowId": secondWindowId, "index": 0},
+                  pass(function() {
+      moveAndListen(testTabId, {"windowId": firstWindowId, "index": 1});
+    }));
+  },
+
+  function tabsOnDetached() {
+    function moveAndListen(tabId, oldWindowId, oldIndex, properties,
+                                 callback) {
+      chrome.test.listenOnce(chrome.tabs.onDetached,
+                             function(detachedTabId, info) {
+        // Ensure notification is correct.
+        assertEq(detachedTabId, tabId);
+        assertEq(oldWindowId, info.oldWindowId);
+        assertEq(oldIndex, info.oldPosition);
+        if (callback)
+          callback();
+      });
+      chrome.tabs.move(tabId, properties);
+    };
+
+    // Move tab to second window, then back to first.
+    moveAndListen(testTabId, firstWindowId, 1,
+                  {"windowId": secondWindowId, "index": 0}, pass(function() {
+      moveAndListen(testTabId, secondWindowId, 0,
+                    {"windowId": firstWindowId, "index": 1});
+    }));
+  },
+
+  function setupRelativeUrlTests() {
+    setupWindow(["about:blank"], pass(function(winId, tabIds) {
+      firstWindowId = winId;
+    }));
+  },
+
+  function relativeUrlTestsTabsCreate() {
+    // 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 relativeUrlTestsTabsUpdate() {
+    // 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 relativeUrlTestsWindowCreate() {
+    // 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);
+      }));
+    });
+
+    chrome.windows.create({"url": pageUrl("a")}, pass(function(tab) {}));
+  },
+
+  /* TODO: Enable this test when crbug.com/28055 is fixed. This bug causes a
+     newly created window not to be set as the current window, if
+     Chrome was not the foreground window when the create call was made.
+  function windowsOnFocusChanged() {
+    chrome.windows.create({}, pass(function(window) {
+      chrome.test.listenOnce(chrome.windows.onFocusChanged,
+                             function(windowId) {
+        assertEq(windowEventsWindow.id, windowId);
+      });
+      chrome.windows.remove(window.id);
+    }));
+  }, */
+
+  function windowsOnRemoved() {
+    chrome.test.listenOnce(chrome.windows.onRemoved, function(windowId) {
+      assertEq(windowEventsWindow.id, windowId);
+    });
+
+    chrome.windows.remove(windowEventsWindow.id, pass());
+  },
+
+  function setupConnect() {
+    // The web page that our content script will be injected into.
+    var relativePath = '/files/extensions/api_test/tabs/relative.html';
+    var testUrl = 'http://localhost:1337' + relativePath;
+
+    setupWindow([testUrl], pass(function(winId, tabIds) {
+      testTabId = tabIds[0];
+      waitForAllTabs(pass());
+    }));
+  },
+
+  function connectMultipleConnects() {
+    var connectCount = 0;
+    function connect10() {
+      var port = chrome.tabs.connect(testTabId);
+      chrome.test.listenOnce(port.onMessage, function(msg) {
+        assertEq(++connectCount, msg.connections);
+        if (connectCount < 10)
+          connect10();
+      });
+      port.postMessage("GET");
+    }
+    connect10();
+  },
+
+  function connectName() {
+    var name = "akln3901n12la";
+    var port = chrome.tabs.connect(testTabId, {"name": name});
+    chrome.test.listenOnce(port.onMessage, function(msg) {
+      assertEq(name, msg.name);
+
+      var port = chrome.tabs.connect(testTabId);
+      chrome.test.listenOnce(port.onMessage, function(msg) {
+        assertEq('', msg.name);
+      });
+      port.postMessage("GET");
+    });
+    port.postMessage("GET");
+  },
+
+  function connectPostMessageTypes() {
+    var port = chrome.tabs.connect(testTabId);
+    // Test the content script echoes the message back.
+    var echoMsg = {"num": 10, "string": "hi", "array": [1,2,3,4,5],
+                   "obj":{"dec": 1.0}};
+    chrome.test.listenOnce(port.onMessage, function(msg) {
+      assertEq(echoMsg.num, msg.num);
+      assertEq(echoMsg.string, msg.string);
+      assertEq(echoMsg.array[4], msg.array[4]);
+      assertEq(echoMsg.obj.dec, msg.obj.dec);
+    });
+    port.postMessage(echoMsg);
+  },
+
+  function connectPostManyMessages() {
+    var port = chrome.tabs.connect(testTabId);
+    var count = 0;
+    var done = chrome.test.listenForever(port.onMessage, function(msg) {
+      assertEq(count++, msg);
+      if (count == 999) {
+        done();
+      }
+    });
+    for (var i = 0; i < 1000; i++) {
+      port.postMessage(i);
+    }
+  },
+
+  /* TODO: Enable this test once we do checking on the tab id for
+     chrome.tabs.connect (crbug.com/27565).
+  function connectNoTab() {
+    chrome.tabs.create({}, pass(function(tab) {
+      chrome.tabs.remove(tab.id, pass(function() {
+        var port = chrome.tabs.connect(tab.id);
+        assertEq(null, port);
+      }));
+    }));
+  }, */
+
+  function sendRequest() {
+    var request = "test";
+    chrome.tabs.sendRequest(testTabId, request, pass(function(response) {
+      assertEq(request, response);
+    }));
+  },
+
+  // TODO(asargent)
+  // It would be an improvement to check the captureVisibleTab results
+  // against a known-good result.
+]);
+
diff --git a/chrome/test/data/french_page.html b/chrome/test/data/french_page.html
deleted file mode 100644
index 7fcf684..0000000
--- a/chrome/test/data/french_page.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<html>
-<head><title>Cette page est en Fran�ais</title></head>
-<body>
-Cette page a �t� r�dig�e en fran�ais. Saviez-vous que le Fran�ais est la langue officielle des jeux olympiques? �a vous en bouche un coin, pas vrai?
-</body>
-</html>
diff --git a/chrome/test/ui_test_utils.cc b/chrome/test/ui_test_utils.cc
index e4b5818..6723084 100644
--- a/chrome/test/ui_test_utils.cc
+++ b/chrome/test/ui_test_utils.cc
@@ -254,33 +254,6 @@ class SimpleNotificationObserver : public NotificationObserver {
   DISALLOW_COPY_AND_ASSIGN(SimpleNotificationObserver);
 };
 
-class LanguageDetectionNotificationObserver : public NotificationObserver {
- public:
-  explicit LanguageDetectionNotificationObserver(
-      RenderViewHost* render_view_host) {
-    registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
-                  Source<RenderViewHost>(render_view_host));
-    ui_test_utils::RunMessageLoop();
-  }
-
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) {
-    language_ = *(Details<std::string>(details).ptr());
-    MessageLoopForUI::current()->Quit();
-  }
-
-  std::string language() const {
-    return language_;
-  }
-
- private:
-  NotificationRegistrar registrar_;
-  std::string language_;
-
-  DISALLOW_COPY_AND_ASSIGN(LanguageDetectionNotificationObserver);
-};
-
 class FindInPageNotificationObserver : public NotificationObserver {
  public:
   explicit FindInPageNotificationObserver(TabContents* parent_tab)
@@ -511,11 +484,6 @@ void WaitForFocusInBrowser(Browser* browser) {
       browser);
 }
 
-std::string WaitForLanguageDetection(TabContents* tab) {
-  LanguageDetectionNotificationObserver observer(tab->render_view_host());
-  return observer.language();
-}
-
 int FindInPage(TabContents* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->StartFinding(search_string, forward, match_case);
diff --git a/chrome/test/ui_test_utils.h b/chrome/test/ui_test_utils.h
index 2c4cd95..89dc8fc 100644
--- a/chrome/test/ui_test_utils.h
+++ b/chrome/test/ui_test_utils.h
@@ -115,10 +115,6 @@ void WaitForFocusChange(RenderViewHost* rvh);
 // traversal).
 void WaitForFocusInBrowser(Browser* browser);
 
-// Waits for the language of the page to have been detected and returns it.
-// This should be called right after a navigation notification was received.
-std::string WaitForLanguageDetection(TabContents* tab_contents);
-
 // Performs a find in the page of the specified tab. Returns the number of
 // matches found.  |ordinal| is an optional parameter which is set to the index
 // of the current match.
author	jcampan@chromium.org <jcampan@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2009-12-17 20:17:00 +0000
committer	jcampan@chromium.org <jcampan@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2009-12-17 20:17:00 +0000
commit	f345876ca7aac5ff6f4e08242891b800c48cedcd (patch)
tree	d8096238c5a3acad0f08a69f45744d5c843875f5 /chrome/test
parent	f7b7ffe4267e517b99c24391a51622f29c0476f0 (diff)
download	chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.zip chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.tar.gz chromium_src-f345876ca7aac5ff6f4e08242891b800c48cedcd.tar.bz2