ServiceWorker: Remove wildcard from scope matching (Chromium)

content/browser/service_worker/service_worker_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 "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
@@ skipping 112 matching lines @@
  protected:
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   int render_process_id_;
 };
 
 TEST_F(ServiceWorkerJobTest, SameDocumentSameRegistration) {
   scoped_refptr<ServiceWorkerRegistration> original_registration;
   bool called;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration1));
   scoped_refptr<ServiceWorkerRegistration> registration2;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_TRUE(registration1);
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, SameMatchSameRegistration) {
   bool called;
   scoped_refptr<ServiceWorkerRegistration> original_registration;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_NE(static_cast<ServiceWorkerRegistration*>(NULL),
             original_registration.get());
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
@@ skipping 10 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, DifferentMatchDifferentRegistration) {
   bool called1;
   scoped_refptr<ServiceWorkerRegistration> original_registration1;
   job_coordinator()->Register(
-      GURL("http://www.example.com/one/*"),
+      GURL("http://www.example.com/one/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called1, &original_registration1));
 
   bool called2;
   scoped_refptr<ServiceWorkerRegistration> original_registration2;
   job_coordinator()->Register(
-      GURL("http://www.example.com/two/*"),
+      GURL("http://www.example.com/two/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called2, &original_registration2));
 
   EXPECT_FALSE(called1);
   EXPECT_FALSE(called2);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
   ASSERT_NE(registration1, registration2);
 }
 
 // Make sure basic registration is working.
 TEST_F(ServiceWorkerJobTest, Register) {
   bool called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_NE(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 // Make sure registrations are cleaned up when they are unregistered.
 TEST_F(ServiceWorkerJobTest, Unregister) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
 
   ASSERT_FALSE(called);
@@ skipping 15 matching lines @@
                             &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 TEST_F(ServiceWorkerJobTest, Unregister_NothingRegistered) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   bool called;
   job_coordinator()->Unregister(pattern,
                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 }
 
 // Make sure that when a new registration replaces an existing
 // registration, that the old one is cleaned up.
 TEST_F(ServiceWorkerJobTest, RegisterNewScript) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> old_registration;
   job_coordinator()->Register(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
 
   ASSERT_FALSE(called);
@@ skipping 37 matching lines @@
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   ASSERT_NE(new_registration_by_pattern, old_registration);
 }
 
 // Make sure that when registering a duplicate pattern+script_url
 // combination, that the same registration is used.
 TEST_F(ServiceWorkerJobTest, RegisterDuplicateScript) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool called;
   scoped_refptr<ServiceWorkerRegistration> old_registration;
   job_coordinator()->Register(
       pattern,
       script_url,
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
 
@@ skipping 54 matching lines @@
     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
   }
 };
 
 TEST_F(ServiceWorkerJobTest, Register_FailToStartWorker) {
   helper_.reset(new FailToStartWorkerTestHelper(render_process_id_));
 
   bool called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(
           SERVICE_WORKER_ERROR_START_WORKER_FAILED, &called, &registration));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(called);
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 // Register and then unregister the pattern, in parallel. Job coordinator should
 // process jobs until the last job.
 TEST_F(ServiceWorkerJobTest, ParallelRegUnreg) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
       pattern,
       script_url,
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &registration_called, &registration));
 
@@ skipping 16 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // Register conflicting scripts for the same pattern. The most recent
 // registration should win, and the old registration should have been
 // shutdown.
 TEST_F(ServiceWorkerJobTest, ParallelRegNewScript) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   GURL script_url1("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
       pattern,
       script_url1,
       render_process_id_,
       SaveRegistration(
           SERVICE_WORKER_OK, &registration1_called, &registration1));
@@ skipping 23 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(registration2, registration);
 }
 
 // Register the exact same pattern + script. Requests should be
 // coalesced such that both callers get the exact same registration
 // object.
 TEST_F(ServiceWorkerJobTest, ParallelRegSameScript) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   GURL script_url("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
       pattern,
       script_url,
       render_process_id_,
       SaveRegistration(
           SERVICE_WORKER_OK, &registration1_called, &registration1));
@@ skipping 21 matching lines @@
       pattern,
       SaveFoundRegistration(
           SERVICE_WORKER_OK, &find_called, &registration));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(registration, registration1);
 }
 
 // Call simulataneous unregister calls.
 TEST_F(ServiceWorkerJobTest, ParallelUnreg) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
 
   GURL script_url("http://www.example.com/service_worker.js");
   bool unregistration1_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_OK, &unregistration1_called));
 
   bool unregistration2_called = false;
   job_coordinator()->Unregister(
       pattern, SaveUnregistration(SERVICE_WORKER_OK, &unregistration2_called));
@@ skipping 12 matching lines @@
   storage()->FindRegistrationForPattern(
       pattern,
       SaveFoundRegistration(
           SERVICE_WORKER_ERROR_NOT_FOUND, &find_called, &registration));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_Register) {
-  GURL pattern1("http://www1.example.com/*");
-  GURL pattern2("http://www2.example.com/*");
+  GURL pattern1("http://www1.example.com/");
+  GURL pattern2("http://www2.example.com/");
   GURL script_url1("http://www1.example.com/service_worker.js");
   GURL script_url2("http://www2.example.com/service_worker.js");
 
   bool registration_called1 = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
       pattern1,
       script_url1,
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
@@ skipping 29 matching lines @@
           SERVICE_WORKER_ERROR_NOT_FOUND, &find_called2, &registration2));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(find_called1);
   ASSERT_TRUE(find_called2);
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration1);
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_Unregister) {
-  GURL pattern1("http://www1.example.com/*");
-  GURL pattern2("http://www2.example.com/*");
+  GURL pattern1("http://www1.example.com/");
+  GURL pattern2("http://www2.example.com/");
 
   bool unregistration_called1 = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Unregister(
       pattern1,
       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
                          &unregistration_called1));
 
   bool unregistration_called2 = false;
   job_coordinator()->Unregister(
       pattern2,
       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
                          &unregistration_called2));
 
   ASSERT_FALSE(unregistration_called1);
   ASSERT_FALSE(unregistration_called2);
   job_coordinator()->AbortAll();
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(unregistration_called1);
   ASSERT_TRUE(unregistration_called2);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_RegUnreg) {
-  GURL pattern("http://www.example.com/*");
+  GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
       pattern,
       script_url,
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
                        &registration_called, &registration));
@@ skipping 22 matching lines @@
   ASSERT_TRUE(find_called);
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // Tests that the waiting worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest, UnregisterWaitingSetsRedundant) {
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool called = false;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
   ASSERT_TRUE(registration);
 
   // Manually create the waiting worker since there is no way to become a
   // waiting worker until Update is implemented.
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration, 1L, helper_->context()->AsWeakPtr());
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
   version->StartWorker(CreateReceiverOnCurrentThread(&status));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
   version->SetStatus(ServiceWorkerVersion::INSTALLED);
   registration->SetWaitingVersion(version);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING,
             version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, version->status());
 
   called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/*"),
+  job_coordinator()->Unregister(GURL("http://www.example.com/"),
                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   // The version should be stopped since there is no controllee after
   // unregistration.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 }
 
 // Tests that the active worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest, UnregisterActiveSetsRedundant) {
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool called = false;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
   ASSERT_TRUE(registration);
 
   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
   called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/*"),
+  job_coordinator()->Unregister(GURL("http://www.example.com/"),
                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   // The version should be stopped since there is no controllee after
   // unregistration.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 }
 
 // Tests that the active worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest,
        UnregisterActiveSetsRedundant_WaitForNoControllee) {
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool called = false;
   job_coordinator()->Register(
-      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/"),
       GURL("http://www.example.com/service_worker.js"),
       render_process_id_,
       SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
   ASSERT_TRUE(registration);
 
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     1 /* dummy provider_id */,
                                     context()->AsWeakPtr(),
                                     NULL));
   registration->active_version()->AddControllee(host.get());
 
   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
   called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/*"),
+  job_coordinator()->Unregister(GURL("http://www.example.com/"),
                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(called);
 
   // The version should be running since there is still a controllee.
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
   registration->active_version()->RemoveControllee(host.get());
   base::RunLoop().RunUntilIdle();
 
   // The version should be stopped since there is no controllee.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 }
 
 namespace {  // Helpers for the update job tests.
 
 const GURL kNoChangeOrigin("http://nochange/");
 const GURL kNewVersionOrigin("http://newversion/");
-const std::string kScope("scope/*");
+const std::string kScope("scope/");
 const std::string kScript("script.js");
 
 void RunNestedUntilIdle() {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void OnIOComplete(int* rv_out, int rv) {
   *rv_out = rv;
@@ skipping 246 matching lines @@
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING,
             update_helper->state_change_log_[3].status);
 
   EXPECT_EQ(registration->active_version()->version_id(),
             update_helper->state_change_log_[4].version_id);
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
             update_helper->state_change_log_[4].status);
 }
 
 }  // namespace content