service worker: Update job gets the script url when the job starts

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 <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 1114 matching lines @@
             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);
 
   EXPECT_TRUE(update_helper->update_found_);
 }
 
-TEST_F(ServiceWorkerJobTest, Update_NewestVersionChanged) {
+// Test that the update job uses the script URL of the newest worker when the
+// job starts, rather than when it is scheduled.
+TEST_F(ServiceWorkerJobTest, Update_ScriptUrlChanged) {
+  // Create a registration with an active version.
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(GURL("http://www.example.com/one/"),
                      GURL("http://www.example.com/service_worker.js"));
 
-  ServiceWorkerVersion* active_version = registration->active_version();
-
-  // Queue an Update, it should abort when it starts and sees the new version.
+  // Queue an Update. When this runs, it will use the waiting version's script.
   job_coordinator()->Update(registration.get(), false);
 
-  // Add a waiting version with new script.
-  scoped_refptr<ServiceWorkerVersion> version =
-      new ServiceWorkerVersion(registration.get(),
-                               GURL("http://www.example.com/new_worker.js"),
-                               2L /* dummy version id */,
-                               helper_->context()->AsWeakPtr());
+  // Add a waiting version with a new script.
+  GURL new_script("http://www.example.com/new_worker.js");
+  scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
+      registration.get(), new_script, 2L /* dummy version id */,
+      helper_->context()->AsWeakPtr());
   registration->SetWaitingVersion(version);
 
+  // Run the update job.
   base::RunLoop().RunUntilIdle();
 
-  // Verify the registration was not modified by the Update.
-  EXPECT_EQ(active_version, registration->active_version());
-  EXPECT_EQ(version.get(), registration->waiting_version());
-  EXPECT_EQ(NULL, registration->installing_version());
+  // The update job should have created a new version with the new script,
+  // and promoted it to the active version.
+  EXPECT_EQ(new_script, registration->active_version()->script_url());
+  EXPECT_EQ(nullptr, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
 }
 
 // Test that update succeeds if the incumbent worker was evicted
 // during the update job (this can happen on disk cache failure).
 TEST_F(ServiceWorkerJobTest, Update_EvictedIncumbent) {
   EvictIncumbentVersionHelper* update_helper = new EvictIncumbentVersionHelper;
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNewVersionOrigin);
   ASSERT_TRUE(registration.get());
@@ skipping 410 matching lines @@
     ASSERT_TRUE(start_msg);
     EmbeddedWorkerMsg_StartWorker::Param param;
     EmbeddedWorkerMsg_StartWorker::Read(start_msg, &param);
     EmbeddedWorkerMsg_StartWorker_Params start_params = base::get<0>(param);
     EXPECT_TRUE(start_params.pause_after_download);
     sink->ClearMessages();
   }
 }
 
 }  // namespace content