Migrating tests to use EmbeddedTestServer (/chrome/browser misc)

chrome/browser/notifications/notification_browsertest.cc

 // Copyright (c) 2012 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 <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 374 matching lines @@
   return false;
 }
 
 void NotificationsTest::DropOriginPreference(const GURL& origin) {
   DesktopNotificationProfileUtil::ClearSetting(browser()->profile(),
       ContentSettingsPattern::FromURLNoWildcard(origin));
 }
 
 // Flaky on Windows, Mac, Linux: http://crbug.com/437414.
 IN_PROC_BROWSER_TEST_F(NotificationsTest, DISABLED_TestUserGestureInfobar) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL(
           "/notifications/notifications_request_function.html"));
 
   // Request permission by calling request() while eval'ing an inline script;
   // That's considered a user gesture to webkit, and should produce an infobar.
   bool result;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       GetActiveWebContents(browser()),
       "window.domAutomationController.send(request());", &result));
   EXPECT_TRUE(result);
 
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser()->tab_strip_model()->GetWebContentsAt(0));
   EXPECT_EQ(1U, infobar_service->infobar_count());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCreateSimpleNotification) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Creates a simple notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   GURL EXPECTED_ICON_URL = embedded_test_server()->GetURL(kExpectedIconUrl);
   ASSERT_EQ(1, GetNotificationCount());
@@ skipping 17 matching lines @@
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
   result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   blocker.SetNotificationsEnabled(false);
   EXPECT_EQ(0, GetNotificationPopupCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseNotification) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Creates a notification and closes it.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
   ASSERT_EQ(1, GetNotificationCount());
 
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   message_center::MessageCenter::Get()->RemoveNotification(
       (*notifications.rbegin())->id(),
       true);  // by_user
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCancelNotification) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Creates a notification and cancels it in the origin page.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string note_id = CreateSimpleNotification(browser(), true);
   EXPECT_NE(note_id, "-1");
 
   ASSERT_EQ(1, GetNotificationCount());
   ASSERT_TRUE(CancelNotification(note_id.c_str(), browser()));
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 // Requests notification privileges and verifies the prompt appears.
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestPermissionRequestUIAppears) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   EXPECT_TRUE(RequestPermissionAndWait(browser()));
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowOnPermissionRequestUI) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Tries to create a notification & clicks 'allow' on the prompt.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   // This notification should not be shown because we do not have permission.
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
 
   ASSERT_TRUE(RequestAndAcceptPermission(browser()));
 
   CreateSimpleNotification(browser(), true);
   EXPECT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyOnPermissionRequestUI) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test that no notification is created when Deny is chosen from prompt.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestAndDenyPermission(browser()));
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   EXPECT_TRUE(CheckOriginInSetting(settings, GetTestPageURL()));
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestClosePermissionRequestUI) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test that no notification is created when prompt is dismissed.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestAndDismissPermission(browser()));
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   EXPECT_EQ(0U, settings.size());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowNotificationsFromAllSites) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that all domains can be allowed to show notifications.
   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyNotificationsFromAllSites) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that no domain can show notifications.
   SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), false);
   EXPECT_EQ("-1", result);
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyDomainAndAllowAll) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that denying a domain and allowing all shouldn't show
   // notifications from the denied domain.
   DenyOrigin(GetTestPageURL().GetOrigin());
   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), false);
   EXPECT_EQ("-1", result);
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowDomainAndDenyAll) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that allowing a domain and denying all others should show
   // notifications from the allowed domain.
   AllowOrigin(GetTestPageURL().GetOrigin());
   SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyAndThenAllowDomain) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that denying and again allowing should show notifications.
   DenyOrigin(GetTestPageURL().GetOrigin());
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), false);
   EXPECT_EQ("-1", result);
 
   ASSERT_EQ(0, GetNotificationCount());
 
   AllowOrigin(GetTestPageURL().GetOrigin());
   result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCreateDenyCloseNotifications) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify able to create, deny, and close the notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   CreateSimpleNotification(browser(), true);
   ASSERT_EQ(1, GetNotificationCount());
 
   DenyOrigin(GetTestPageURL().GetOrigin());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   ASSERT_TRUE(CheckOriginInSetting(settings, GetTestPageURL().GetOrigin()));
 
   EXPECT_EQ(1, GetNotificationCount());
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   message_center::MessageCenter::Get()->RemoveNotification(
       (*notifications.rbegin())->id(),
       true);  // by_user
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 // Crashes on Linux/Win. See http://crbug.com/160657.
 IN_PROC_BROWSER_TEST_F(
     NotificationsTest,
     DISABLED_TestOriginPrefsNotSavedInIncognito) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Verify that allow/deny origin preferences are not saved in incognito.
   Browser* incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestAndDenyPermission(incognito));
   CloseBrowserWindow(incognito);
 
   incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestAndAcceptPermission(incognito));
   CreateSimpleNotification(incognito, true);
   ASSERT_EQ(1, GetNotificationCount());
   CloseBrowserWindow(incognito);
 
   incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(incognito));
 
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   EXPECT_EQ(0U, settings.size());
   GetPrefsByContentSetting(CONTENT_SETTING_ALLOW, &settings);
   EXPECT_EQ(0U, settings.size());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestIncognitoNotification) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test notifications in incognito window.
   Browser* browser = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(browser, GetTestPageURL());
   browser->tab_strip_model()->ActivateTabAt(0, true);
   ASSERT_TRUE(RequestAndAcceptPermission(browser));
   CreateSimpleNotification(browser, true);
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseTabWithPermissionRequestUI) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test that user can close tab when bubble present.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   EXPECT_TRUE(RequestPermissionAndWait(browser()));
   content::WebContentsDestroyedWatcher destroyed_watcher(
       browser()->tab_strip_model()->GetWebContentsAt(0));
   browser()->tab_strip_model()->CloseWebContentsAt(0,
                                                    TabStripModel::CLOSE_NONE);
   destroyed_watcher.Wait();
 }
 
 // See crbug.com/248470
 #if defined(OS_LINUX)
 #define MAYBE_TestCrashRendererNotificationRemain \
     DISABLED_TestCrashRendererNotificationRemain
 #else
 #define MAYBE_TestCrashRendererNotificationRemain \
     TestCrashRendererNotificationRemain
 #endif
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest,
                        MAYBE_TestCrashRendererNotificationRemain) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test crashing renderer does not close or crash notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("about:blank"),
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
   browser()->tab_strip_model()->ActivateTabAt(0, true);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   CreateSimpleNotification(browser(), true);
   ASSERT_EQ(1, GetNotificationCount());
   CrashTab(browser(), 0);
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationReplacement) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test that we can replace a notification using the replaceId.
   AllowAllOrigins();
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateNotification(
       browser(), true, "abc.png", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 
   result = CreateNotification(
       browser(), false, "no_such_file.png", "Title2", "Body2", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   EXPECT_EQ(base::ASCIIToUTF16("Title2"), (*notifications.rbegin())->title());
   EXPECT_EQ(base::ASCIIToUTF16("Body2"),
             (*notifications.rbegin())->message());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestLastUsage) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(browser()->profile());
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   settings_map->SetPrefClockForTesting(scoped_ptr<base::Clock>(clock));
   clock->SetNow(base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(10));
 
   // Creates a simple notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(settings_map->GetLastUsage(GetTestPageURL().GetOrigin(),
                                        GetTestPageURL().GetOrigin(),
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
                 .ToDoubleT(),
             13);
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest,
                        TestNotificationReplacementReappearance) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   // Test that we can replace a notification using the tag, and that it will
   // cause the notification to reappear as a popup again.
   AllowAllOrigins();
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   ASSERT_EQ(0, GetNotificationPopupCount());
 
   std::string result = CreateNotification(
@@ skipping 14 matching lines @@
 #endif
 
   result = CreateNotification(
       browser(), true, "abc.png", "Title2", "Body2", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationPopupCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationValidIcon) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
   AllowAllOrigins();
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_EQ(0, GetNotificationPopupCount());
 
   std::string result = CreateNotification(
       browser(), true, "icon.png", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 
   message_center::NotificationList::PopupNotifications notifications =
       message_center::MessageCenter::Get()->GetPopupNotifications();
   ASSERT_EQ(1u, notifications.size());
 
   auto* notification = *notifications.rbegin();
 
   EXPECT_EQ(100, notification->icon().Width());
   EXPECT_EQ(100, notification->icon().Height());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationInvalidIcon) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
   AllowAllOrigins();
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_EQ(0, GetNotificationPopupCount());
 
   // Not supplying an icon URL.
   std::string result = CreateNotification(
       browser(), true, "", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 
@@ skipping 10 matching lines @@
   EXPECT_NE("-1", result);
 
   notifications = message_center::MessageCenter::Get()->GetPopupNotifications();
   ASSERT_EQ(1u, notifications.size());
 
   notification = *notifications.rbegin();
   EXPECT_TRUE(notification->icon().IsEmpty());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationDoubleClose) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
   AllowAllOrigins();
 
   ui_test_utils::NavigateToURL(
       browser(), GetTestPageURLForFile("notification-double-close.html"));
   ASSERT_EQ(0, GetNotificationPopupCount());
 
   std::string result = CreateNotification(
       browser(), true, "", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
   message_center::NotificationList::Notifications notifications =
       message_center::MessageCenter::Get()->GetVisibleNotifications();
   message_center::MessageCenter::Get()->RemoveNotification(
       (*notifications.rbegin())->id(),
       true);  // by_user
 
   ASSERT_EQ(0, GetNotificationCount());
 
   // Calling WebContents::IsCrashed() will return FALSE here, even if the WC did
   // crash. Work around this timing issue by creating another notification,
   // which requires interaction with the renderer process.
   result = CreateNotification(browser(), true, "", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 }