Remove deprecated things from net test suite:

chrome/browser/extensions/extension_browsertests_misc.cc

 // Copyright (c) 2010 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.
 
 #include "base/ref_counted.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/extensions/autoupdate_interceptor.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 11 matching lines @@
 #endif
 
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/ui_test_utils.h"
 #include "net/base/net_util.h"
 
 const std::string kSubscribePage = "/subscribe.html";
-const std::wstring kFeedPage = L"files/feeds/feed.html";
-const std::wstring kFeedPageMultiRel = L"files/feeds/feed_multi_rel.html";
-const std::wstring kNoFeedPage = L"files/feeds/no_feed.html";
-const std::wstring kValidFeed0 = L"files/feeds/feed_script.xml";
-const std::wstring kValidFeed1 = L"files/feeds/feed1.xml";
-const std::wstring kValidFeed2 = L"files/feeds/feed2.xml";
-const std::wstring kValidFeed3 = L"files/feeds/feed3.xml";
-const std::wstring kValidFeed4 = L"files/feeds/feed4.xml";
-const std::wstring kValidFeed5 = L"files/feeds/feed5.xml";
-const std::wstring kValidFeedNoLinks = L"files/feeds/feed_nolinks.xml";
-const std::wstring kInvalidFeed1 = L"files/feeds/feed_invalid1.xml";
-const std::wstring kInvalidFeed2 = L"files/feeds/feed_invalid2.xml";
-const std::wstring kLocalization =
-    L"files/extensions/browsertest/title_localized_pa/simple.html";
-const std::wstring kHashPageA =
-    L"files/extensions/api_test/page_action/hash_change/test_page_A.html";
-const std::wstring kHashPageAHash = kHashPageA + L"#asdf";
-const std::wstring kHashPageB =
-    L"files/extensions/api_test/page_action/hash_change/test_page_B.html";
+const std::string kFeedPage = "files/feeds/feed.html";
+const std::string kFeedPageMultiRel = "files/feeds/feed_multi_rel.html";
+const std::string kNoFeedPage = "files/feeds/no_feed.html";
+const std::string kValidFeed0 = "files/feeds/feed_script.xml";
+const std::string kValidFeed1 = "files/feeds/feed1.xml";
+const std::string kValidFeed2 = "files/feeds/feed2.xml";
+const std::string kValidFeed3 = "files/feeds/feed3.xml";
+const std::string kValidFeed4 = "files/feeds/feed4.xml";
+const std::string kValidFeed5 = "files/feeds/feed5.xml";
+const std::string kValidFeedNoLinks = "files/feeds/feed_nolinks.xml";
+const std::string kInvalidFeed1 = "files/feeds/feed_invalid1.xml";
+const std::string kInvalidFeed2 = "files/feeds/feed_invalid2.xml";
+const std::string kLocalization =
+    "files/extensions/browsertest/title_localized_pa/simple.html";
+const std::string kHashPageA =
+    "files/extensions/api_test/page_action/hash_change/test_page_A.html";
+const std::string kHashPageAHash = kHashPageA + "#asdf";
+const std::string kHashPageB =
+    "files/extensions/api_test/page_action/hash_change/test_page_B.html";
 
 // Looks for an ExtensionHost whose URL has the given path component (including
 // leading slash).  Also verifies that the expected number of hosts are loaded.
 static ExtensionHost* FindHostWithPath(ExtensionProcessManager* manager,
                                        const std::string& path,
                                        int expected_hosts) {
   ExtensionHost* host = NULL;
   int num_hosts = 0;
   for (ExtensionProcessManager::const_iterator iter = manager->begin();
        iter != manager->end(); ++iter) {
@@ skipping 151 matching lines @@
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("browsertest")
                     .AppendASCII("crash_25562")));
 
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("subscribe_page_action")));
 
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(0));
 
   // Navigate to the feed page.
-  GURL feed_url = server->TestServerPageW(kFeedPage);
+  GURL feed_url = server->TestServerPage(kFeedPage);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   // We should now have one page action ready to go in the LocationBar.
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   // Navigate to a page with no feed.
-  GURL no_feed = server->TestServerPageW(kNoFeedPage);
+  GURL no_feed = server->TestServerPage(kNoFeedPage);
   ui_test_utils::NavigateToURL(browser(), no_feed);
   // Make sure the page action goes away.
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(0));
 }
 
 // Tests that we don't lose the page action icon on in-page navigations.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, PageActionInPageNavigation) {
   HTTPTestServer* server = StartHTTPServer();
 
   FilePath extension_path(test_data_dir_.AppendASCII("api_test")
                                         .AppendASCII("page_action")
                                         .AppendASCII("hash_change"));
   ASSERT_TRUE(LoadExtension(extension_path));
 
   // Page action should become visible when we navigate here.
-  GURL feed_url = server->TestServerPageW(kHashPageA);
+  GURL feed_url = server->TestServerPage(kHashPageA);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   // In-page navigation, page action should remain.
-  feed_url = server->TestServerPageW(kHashPageAHash);
+  feed_url = server->TestServerPage(kHashPageAHash);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   // Not an in-page navigation, page action should go away.
-  feed_url = server->TestServerPageW(kHashPageB);
+  feed_url = server->TestServerPage(kHashPageB);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(0));
 }
 
 // Tests that the location bar forgets about unloaded page actions.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, UnloadPageAction) {
   HTTPTestServer* server = StartHTTPServer();
 
   FilePath extension_path(test_data_dir_.AppendASCII("subscribe_page_action"));
   ASSERT_TRUE(LoadExtension(extension_path));
 
   // Navigation prompts the location bar to load page actions.
-  GURL feed_url = server->TestServerPageW(kFeedPage);
+  GURL feed_url = server->TestServerPage(kFeedPage);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   ASSERT_TRUE(WaitForPageActionCountChangeTo(1));
 
   UnloadExtension(last_loaded_extension_id_);
 
   // Make sure the page action goes away when it's unloaded.
   ASSERT_TRUE(WaitForPageActionCountChangeTo(0));
 }
 
 // Makes sure that the RSS detects RSS feed links, even when rel tag contains
 // more than just "alternate".
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, RSSMultiRelLink) {
   HTTPTestServer* server = StartHTTPServer();
 
   ASSERT_TRUE(LoadExtension(
     test_data_dir_.AppendASCII("subscribe_page_action")));
 
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(0));
 
   // Navigate to the feed page.
-  GURL feed_url = server->TestServerPageW(kFeedPageMultiRel);
+  GURL feed_url = server->TestServerPage(kFeedPageMultiRel);
   ui_test_utils::NavigateToURL(browser(), feed_url);
   // We should now have one page action ready to go in the LocationBar.
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 }
 
 // Tests that tooltips of a browser action icon can be specified using UTF8.
 // See http://crbug.com/25349.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationBrowserAction) {
   ExtensionsService* service = browser()->profile()->GetExtensionsService();
   const size_t size_before = service->extensions()->size();
@@ skipping 19 matching lines @@
   HTTPTestServer* server = StartHTTPServer();
 
   ExtensionsService* service = browser()->profile()->GetExtensionsService();
   const size_t size_before = service->extensions()->size();
 
   FilePath extension_path(test_data_dir_.AppendASCII("browsertest")
                                         .AppendASCII("title_localized_pa"));
   ASSERT_TRUE(LoadExtension(extension_path));
 
   // Any navigation prompts the location bar to load the page action.
-  GURL url = server->TestServerPageW(kLocalization);
+  GURL url = server->TestServerPage(kLocalization);
   ui_test_utils::NavigateToURL(browser(), url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   Extension* extension = service->extensions()->at(size_before);
 
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n page action").c_str(),
                extension->description().c_str());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
   int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedTabContents());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->page_action()->GetTitle(tab_id).c_str());
 }
 
-GURL GetFeedUrl(HTTPTestServer* server, const std::wstring& feed_page,
+GURL GetFeedUrl(HTTPTestServer* server, const std::string& feed_page,
                 bool direct_url, std::string extension_id) {
-  GURL feed_url = server->TestServerPageW(feed_page);
+  GURL feed_url = server->TestServerPage(feed_page);
   if (direct_url) {
     // We navigate directly to the subscribe page for feeds where the feed
     // sniffing won't work, in other words, as is the case for malformed feeds.
     return GURL(std::string(chrome::kExtensionScheme) +
         chrome::kStandardSchemeSeparator +
         extension_id + std::string(kSubscribePage) + std::string("?") +
         feed_url.spec() + std::string("&synchronous"));
   } else {
     // Navigate to the feed content (which will cause the extension to try to
     // sniff the type and display the subscribe page in another tab.
@@ skipping 41 matching lines @@
 
   EXPECT_STREQ(expected_value.c_str(), returned_value.c_str());
   return expected_value == returned_value;
 }
 
 // Navigates to a feed page and, if |sniff_xml_type| is set, wait for the
 // extension to kick in, detect the feed and redirect to a feed preview page.
 // |sniff_xml_type| is generally set to true if the feed is sniffable and false
 // for invalid feeds.
 void NavigateToFeedAndValidate(HTTPTestServer* server,
-                               const std::wstring& url,
+                               const std::string& url,
                                Browser* browser,
                                bool sniff_xml_type,
                                const std::string& expected_feed_title,
                                const std::string& expected_item_title,
                                const std::string& expected_item_desc,
                                const std::string& expected_error) {
   if (sniff_xml_type) {
     // TODO(finnur): Implement this is a non-flaky way.
   }
 
@@ skipping 132 matching lines @@
                             "Not a valid feed.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedInvalidFeed3) {
   HTTPTestServer* server = StartHTTPServer();
 
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("subscribe_page_action")));
 
   // Try a feed that doesn't exist.
-  NavigateToFeedAndValidate(server, L"foo.xml", browser(), false,
+  NavigateToFeedAndValidate(server, "foo.xml", browser(), false,
                             "Feed for Unknown feed name",
                             "element 'anchor_0' not found",
                             "element 'desc_0' not found",
                             "Not a valid feed.");
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, ParseFeedValidFeedNoLinks) {
   HTTPTestServer* server = StartHTTPServer();
 
   ASSERT_TRUE(LoadExtension(
@@ skipping 192 matching lines @@
 
   // If the options page hasn't already come up, wait for it.
   if (tab_strip->count() == 1) {
     ui_test_utils::WaitForNewTab(browser());
   }
   ASSERT_EQ(2, tab_strip->count());
 
   EXPECT_EQ(extension->GetResourceURL("options.html"),
             tab_strip->GetTabContentsAt(1)->GetURL());
 }