(false positive) Revert of Set render_frame_id while fetching from the dedicated worker ...

content/browser/shared_worker/worker_browsertest.cc

 // Copyright 2014 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/bind.h"
-#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/test_timeouts.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/client_certificate_delegate.h"
-#include "content/public/common/content_features.h"
 #include "content/public/common/content_paths.h"
-#include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/shell/browser/shell_resource_dispatcher_host_delegate.h"
 #include "net/base/escape.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
@@ skipping 71 matching lines @@
     shell()->LoadURL(url);
     runner->Run();
   }
 
  private:
   void OnSelectClientCertificate() { select_certificate_count_++; }
 
   int select_certificate_count_;
 };
 
-class WorkerFetchTest : public testing::WithParamInterface<bool>,
-                        public WorkerTest {
- public:
-  ~WorkerFetchTest() override {}
-  void SetUpCommandLine(base::CommandLine* command_line) override {
-    if (GetParam()) {
-      command_line->AppendSwitchASCII(switches::kEnableFeatures,
-                                      features::kOffMainThreadFetch.name);
-    } else {
-      command_line->AppendSwitchASCII(switches::kDisableFeatures,
-                                      features::kOffMainThreadFetch.name);
-    }
-  }
-};
-
 IN_PROC_BROWSER_TEST_F(WorkerTest, SingleWorker) {
   RunTest("single_worker.html", std::string());
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, MultipleWorkers) {
   RunTest("multi_worker.html", std::string());
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, SingleSharedWorker) {
   if (!SupportsSharedWorker())
@@ skipping 18 matching lines @@
 
   // Load a non-incognito tab and have it create a shared worker
   RunTest("incognito_worker.html", std::string());
 
   // Incognito worker should not share with non-incognito
   RunTest(CreateOffTheRecordBrowser(), "incognito_worker.html", std::string());
 }
 
 // Make sure that auth dialog is displayed from worker context.
 // http://crbug.com/33344
-IN_PROC_BROWSER_TEST_P(WorkerFetchTest, WorkerHttpAuth) {
+IN_PROC_BROWSER_TEST_F(WorkerTest, WorkerHttpAuth) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url = embedded_test_server()->GetURL("/workers/worker_auth.html");
 
   NavigateAndWaitForAuth(url);
 }
 
 // Make sure that HTTP auth dialog is displayed from shared worker context.
 // http://crbug.com/33344
 //
 // TODO(davidben): HTTP auth dialogs are no longer displayed on shared workers,
 // but this test only tests that the delegate is called. Move handling the
 // WebContentsless case from chrome/ to content/ and adjust the test
 // accordingly.
-IN_PROC_BROWSER_TEST_P(WorkerFetchTest, SharedWorkerHttpAuth) {
+IN_PROC_BROWSER_TEST_F(WorkerTest, SharedWorkerHttpAuth) {
   if (!SupportsSharedWorker())
     return;
 
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url = embedded_test_server()->GetURL("/workers/shared_worker_auth.html");
   NavigateAndWaitForAuth(url);
 }
 
-// Tests that TLS client auth prompts for normal workers's importScripts.
-IN_PROC_BROWSER_TEST_P(WorkerFetchTest, WorkerTlsClientAuthImportScripts) {
+// Tests that TLS client auth prompts for normal workers.
+IN_PROC_BROWSER_TEST_F(WorkerTest, WorkerTlsClientAuth) {
   // Launch HTTPS server.
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.ServeFilesFromSourceDirectory("content/test/data");
   net::SSLServerConfig ssl_config;
   ssl_config.client_cert_type =
       net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
   ASSERT_TRUE(https_server.Start());
 
   RunTest("worker_tls_client_auth.html",
-          "test=import&url=" + net::EscapeQueryParamValue(
-                                   https_server.GetURL("/").spec(), true));
+          "url=" + net::EscapeQueryParamValue(https_server.GetURL("/").spec(),
+                                              true));
   EXPECT_EQ(1, select_certificate_count());
 }
 
-// Tests that TLS client auth prompts for normal workers's fetch() call.
-IN_PROC_BROWSER_TEST_P(WorkerFetchTest, WorkerTlsClientAuthFetch) {
+// Tests that TLS client auth does not prompt for a shared worker; shared
+// workers are not associated with a WebContents.
+IN_PROC_BROWSER_TEST_F(WorkerTest, SharedWorkerTlsClientAuth) {
+  if (!SupportsSharedWorker())
+    return;
+
   // Launch HTTPS server.
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.ServeFilesFromSourceDirectory("content/test/data");
   net::SSLServerConfig ssl_config;
   ssl_config.client_cert_type =
       net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
   ASSERT_TRUE(https_server.Start());
 
   RunTest("worker_tls_client_auth.html",
-          "test=fetch&url=" + net::EscapeQueryParamValue(
-                                  https_server.GetURL("/").spec(), true));
-  EXPECT_EQ(1, select_certificate_count());
-}
-
-// Tests that TLS client auth does not prompt for a shared worker; shared
-// workers are not associated with a WebContents.
-IN_PROC_BROWSER_TEST_P(WorkerFetchTest,
-                       SharedWorkerTlsClientAuthImportScripts) {
-  if (!SupportsSharedWorker())
-    return;
-
-  // Launch HTTPS server.
-  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
-  https_server.ServeFilesFromSourceDirectory("content/test/data");
-  net::SSLServerConfig ssl_config;
-  ssl_config.client_cert_type =
-      net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
-  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
-  ASSERT_TRUE(https_server.Start());
-
-  RunTest(
-      "worker_tls_client_auth.html",
-      "test=import&shared=true&url=" +
-          net::EscapeQueryParamValue(https_server.GetURL("/").spec(), true));
+          "shared=true&url=" + net::EscapeQueryParamValue(
+                                   https_server.GetURL("/").spec(), true));
   EXPECT_EQ(0, select_certificate_count());
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, WebSocketSharedWorker) {
   if (!SupportsSharedWorker())
     return;
 
   // Launch WebSocket server.
   net::SpawnedTestServer ws_server(net::SpawnedTestServer::TYPE_WS,
                                    net::SpawnedTestServer::kLocalhost,
@@ skipping 23 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest,
                        PassMessagePortToSharedWorkerDontWaitForConnect) {
   if (!SupportsSharedWorker())
     return;
 
   RunTest("pass_messageport_to_sharedworker_dont_wait_for_connect.html", "");
 }
 
-INSTANTIATE_TEST_CASE_P(/* no prefix */,
-                        WorkerFetchTest,
-                        ::testing::Values(true, false));
-
 }  // namespace content