Revert of service worker: Don't control a subframe of an insecure context

content/browser/service_worker/service_worker_url_request_job_unittest.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 "content/browser/service_worker/service_worker_url_request_job.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 125 matching lines @@
     browser_context_.reset(new TestBrowserContext);
     InitializeResourceContext(browser_context_.get());
     SetUpWithHelper(new EmbeddedWorkerTestHelper(base::FilePath()));
   }
 
   void SetUpWithHelper(EmbeddedWorkerTestHelper* helper,
                        bool set_main_script_http_response_info = true) {
     helper_.reset(helper);
 
     registration_ = new ServiceWorkerRegistration(
-        GURL("https://example.com/"), 1L, helper_->context()->AsWeakPtr());
+        GURL("http://example.com/"),
+        1L,
+        helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
-        registration_.get(), GURL("https://example.com/service_worker.js"), 1L,
+        registration_.get(),
+        GURL("http://example.com/service_worker.js"),
+        1L,
         helper_->context()->AsWeakPtr());
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
     version_->script_cache_map()->SetResources(records);
 
     // Make the registration findable via storage functions.
     helper_->context()->storage()->LazyInitialize(base::Bind(&base::DoNothing));
     base::RunLoop().RunUntilIdle();
     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
@@ skipping 11 matching lines @@
       EXPECT_TRUE(http_info.ssl_info.is_valid());
       http_info.ssl_info.security_bits = 0x100;
       // SSL3 TLS_DHE_RSA_WITH_AES_256_CBC_SHA
       http_info.ssl_info.connection_status = 0x300039;
       version_->SetMainScriptHttpResponseInfo(http_info);
     }
 
     std::unique_ptr<ServiceWorkerProviderHost> provider_host(
         new ServiceWorkerProviderHost(
             helper_->mock_render_process_id(), MSG_ROUTING_NONE, kProviderID,
-            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-            ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
-            helper_->context()->AsWeakPtr(), nullptr));
+            SERVICE_WORKER_PROVIDER_FOR_WINDOW, helper_->context()->AsWeakPtr(),
+            nullptr));
     provider_host_ = provider_host->AsWeakPtr();
-    provider_host->SetDocumentUrl(GURL("https://example.com/"));
+    provider_host->SetDocumentUrl(GURL("http://example.com/"));
     registration_->SetActiveVersion(version_);
     provider_host->AssociateRegistration(registration_.get(),
                                          false /* notify_controllerchange */);
 
     ChromeBlobStorageContext* chrome_blob_storage_context =
         ChromeBlobStorageContext::GetFor(browser_context_.get());
     // Wait for chrome_blob_storage_context to finish initializing.
     base::RunLoop().RunUntilIdle();
     storage::BlobStorageContext* blob_storage_context =
         chrome_blob_storage_context->context();
 
     url_request_job_factory_.reset(new net::URLRequestJobFactoryImpl);
     url_request_job_factory_->SetProtocolHandler(
-        "https",
+        "http",
         base::WrapUnique(new MockHttpProtocolHandler(
             provider_host->AsWeakPtr(), browser_context_->GetResourceContext(),
             blob_storage_context->AsWeakPtr(), this)));
     url_request_job_factory_->SetProtocolHandler(
         "blob", CreateMockBlobProtocolHandler(blob_storage_context));
     url_request_context_.set_job_factory(url_request_job_factory_.get());
 
     helper_->context()->AddProviderHost(std::move(provider_host));
   }
 
@@ skipping 21 matching lines @@
     } else {
       EXPECT_FALSE(ssl_info.is_valid());
     }
   }
 
   void TestRequest(int expected_status_code,
                    const std::string& expected_status_text,
                    const std::string& expected_response,
                    bool expect_valid_ssl) {
     request_ = url_request_context_.CreateRequest(
-        GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+        GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
         &url_request_delegate_);
 
     request_->set_method("GET");
     request_->Start();
     base::RunLoop().RunUntilIdle();
     TestRequestResult(expected_status_code, expected_status_text,
                       expected_response, expect_valid_ssl);
   }
 
   bool HasInflightRequests() {
@@ skipping 116 matching lines @@
   EXPECT_EQ(GURL(), info->original_url_via_service_worker());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_F(ServiceWorkerURLRequestJobTest, DeletedProviderHostBeforeFetchEvent) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
 
   request_->set_method("GET");
   request_->Start();
   helper_->context()->RemoveProviderHost(helper_->mock_render_process_id(),
                                          kProviderID);
   base::RunLoop().RunUntilIdle();
   TestRequestResult(500, "Service Worker Response Error", std::string(),
                     false /* expect_valid_ssl */);
 
@@ skipping 123 matching lines @@
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse) {
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
       GetStreamContextForResourceContext(
           browser_context_->GetResourceContext());
   scoped_refptr<Stream> stream =
       new Stream(stream_context->registry(), nullptr, stream_url);
   SetUpWithHelper(new StreamResponder(stream_url));
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
 
   std::string expected_response;
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
     stream->AddData(kTestData, sizeof(kTestData) - 1);
   }
@@ skipping 27 matching lines @@
 
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_DelayedRegistration) {
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
       GetStreamContextForResourceContext(
           browser_context_->GetResourceContext());
   SetUpWithHelper(new StreamResponder(stream_url));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
 
   scoped_refptr<Stream> stream =
       new Stream(stream_context->registry(), nullptr, stream_url);
   std::string expected_response;
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
@@ skipping 39 matching lines @@
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
     stream->AddData(kTestData, sizeof(kTestData) - 1);
   }
   stream->Finalize();
   SetUpWithHelper(new StreamResponder(stream_url));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
   EXPECT_FALSE(HasInflightRequests());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HasInflightRequests());
   EXPECT_TRUE(request_->status().is_success());
   EXPECT_EQ(200,
             request_->response_headers()->response_code());
   EXPECT_EQ("OK",
@@ skipping 21 matching lines @@
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
       GetStreamContextForResourceContext(
           browser_context_->GetResourceContext());
   scoped_refptr<Stream> stream =
       new Stream(stream_context->registry(), nullptr, stream_url);
   SetUpWithHelper(new StreamResponder(stream_url));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
   std::string expected_response;
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
     stream->AddData(kTestData, sizeof(kTestData) - 1);
     stream->Flush();
     base::RunLoop().RunUntilIdle();
@@ skipping 27 matching lines @@
       GetStreamContextForResourceContext(
           browser_context_->GetResourceContext());
   scoped_refptr<Stream> stream =
       new Stream(stream_context->registry(), nullptr, stream_url);
   ASSERT_EQ(stream.get(),
             stream_context->registry()->GetStream(stream_url).get());
   SetUpWithHelper(new StreamResponder(stream_url));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
   EXPECT_FALSE(HasInflightRequests());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HasInflightRequests());
 
   std::string expected_response;
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 512; ++i) {
@@ skipping 29 matching lines @@
 TEST_F(ServiceWorkerURLRequestJobTest,
        StreamResponse_DelayedRegistrationAndCancel) {
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
       GetStreamContextForResourceContext(
           browser_context_->GetResourceContext());
   SetUpWithHelper(new StreamResponder(stream_url));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
   EXPECT_FALSE(HasInflightRequests());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HasInflightRequests());
   request_->Cancel();
   EXPECT_FALSE(HasInflightRequests());
 
   scoped_refptr<Stream> stream =
@@ skipping 26 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FailFetchHelper);
 };
 
 TEST_F(ServiceWorkerURLRequestJobTest, FailFetchDispatch) {
   SetUpWithHelper(new FailFetchHelper);
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(request_->status().is_success());
   // We should have fallen back to network.
   EXPECT_EQ(200, request_->GetResponseCode());
   EXPECT_EQ("PASS", url_request_delegate_.response_data());
   EXPECT_FALSE(HasInflightRequests());
   ServiceWorkerProviderHost* host = helper_->context()->GetProviderHost(
       helper_->mock_render_process_id(), kProviderID);
   ASSERT_TRUE(host);
   EXPECT_EQ(host->controlling_version(), nullptr);
 
   EXPECT_EQ(1, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 // TODO(horo): Remove this test when crbug.com/485900 is fixed.
 TEST_F(ServiceWorkerURLRequestJobTest, MainScriptHTTPResponseInfoNotSet) {
   // Shouldn't crash if MainScriptHttpResponseInfo is not set.
   SetUpWithHelper(new EmbeddedWorkerTestHelper(base::FilePath()), false);
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
+      GURL("http://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(request_->status().is_success());
   EXPECT_EQ(200, request_->GetResponseCode());
   EXPECT_EQ("", url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
   EXPECT_EQ(GURL(), info->original_url_via_service_worker());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 // TODO(kinuko): Add more tests with different response data and also for
 // FallbackToNetwork case.
 
 }  // namespace content