Cleanup of static lists of schemes & origins that are created at startup.

content/browser/service_worker/service_worker_provider_host_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_provider_host.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/url_schemes.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 const char kServiceWorkerScheme[] = "i-can-use-service-worker";
 
 class ServiceWorkerTestContentClient : public TestContentClient {
  public:
-  void AddServiceWorkerSchemes(std::set<std::string>* schemes) override {
-    schemes->insert(kServiceWorkerScheme);
+  void AddAdditionalSchemes(Schemes* schemes) override {
+    schemes->service_worker_schemes.push_back(kServiceWorkerScheme);
   }
 };
 
 class ServiceWorkerProviderHostTest : public testing::Test {
  protected:
   ServiceWorkerProviderHostTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
     SetContentClient(&test_content_client_);
   }
   ~ServiceWorkerProviderHostTest() override {}
 
   void SetUp() override {
     old_content_browser_client_ =
         SetBrowserClientForTesting(&test_content_browser_client_);
+    RefreshSecuritySchemesForTesting();
 
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
     context_ = helper_->context();
     script_url_ = GURL("https://www.example.com/service_worker.js");
     registration1_ = new ServiceWorkerRegistration(
         GURL("https://www.example.com/"), 1L, context_->AsWeakPtr());
     registration2_ = new ServiceWorkerRegistration(
         GURL("https://www.example.com/example"), 2L, context_->AsWeakPtr());
     registration3_ = new ServiceWorkerRegistration(
         GURL("https://other.example.com/"), 3L, context_->AsWeakPtr());
@@ skipping 17 matching lines @@
     provider_host2_ = host2->AsWeakPtr();
     context_->AddProviderHost(base::WrapUnique(host1.release()));
     context_->AddProviderHost(base::WrapUnique(host2.release()));
   }
 
   void TearDown() override {
     registration1_ = 0;
     registration2_ = 0;
     helper_.reset();
     SetBrowserClientForTesting(old_content_browser_client_);
+    // Reset cached security schemes so we don't affect other tests.
+    RefreshSecuritySchemesForTesting();
   }
 
   bool PatternHasProcessToRun(const GURL& pattern) const {
     return context_->process_manager()->PatternHasProcessToRun(pattern);
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
+  TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   ServiceWorkerContextCore* context_;
   scoped_refptr<ServiceWorkerRegistration> registration1_;
   scoped_refptr<ServiceWorkerRegistration> registration2_;
   scoped_refptr<ServiceWorkerRegistration> registration3_;
   base::WeakPtr<ServiceWorkerProviderHost> provider_host1_;
   base::WeakPtr<ServiceWorkerProviderHost> provider_host2_;
   GURL script_url_;
   ServiceWorkerTestContentClient test_content_client_;
   TestContentBrowserClient test_content_browser_client_;
@@ skipping 66 matching lines @@
 
   // SetDocumentUrl with another origin also updates matching registrations
   provider_host1_->SetDocumentUrl(GURL("https://other.example.com/example"));
   ASSERT_EQ(registration3_, provider_host1_->MatchRegistration());
   provider_host1_->RemoveMatchingRegistration(registration3_.get());
   ASSERT_EQ(nullptr, provider_host1_->MatchRegistration());
 }
 
 TEST_P(ServiceWorkerProviderHostTestP, ContextSecurity) {
   using FrameSecurityLevel = ServiceWorkerProviderHost::FrameSecurityLevel;
-  content::ResetSchemesAndOriginsWhitelistForTesting();
 
   // Insecure document URL.
   provider_host1_->SetDocumentUrl(GURL("http://host"));
   provider_host1_->parent_frame_security_level_ = FrameSecurityLevel::SECURE;
   EXPECT_FALSE(provider_host1_->IsContextSecureForServiceWorker());
 
   // Insecure parent frame.
   provider_host1_->SetDocumentUrl(GURL("https://host"));
   provider_host1_->parent_frame_security_level_ = FrameSecurityLevel::INSECURE;
   EXPECT_FALSE(provider_host1_->IsContextSecureForServiceWorker());
@@ skipping 15 matching lines @@
   // Exceptional service worker scheme with insecure parent frame.
   provider_host1_->parent_frame_security_level_ = FrameSecurityLevel::INSECURE;
   EXPECT_FALSE(provider_host1_->IsContextSecureForServiceWorker());
 }
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerProviderHostTest,
                         ServiceWorkerProviderHostTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content