Decouple script_url from ServiceWorkerRegistration

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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_version.h"
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
@@ skipping 73 matching lines @@
                            ServiceWorkerStatusCode status) {
   callback.Run(status,
                SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                ServiceWorkerResponse());
 }
 
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
+    const GURL& script_url,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : version_id_(version_id),
       registration_id_(kInvalidServiceWorkerVersionId),
+      script_url_(script_url),
       status_(NEW),
       context_(context),
       script_cache_map_(this, context),
       is_doomed_(false),
       weak_factory_(this) {
   DCHECK(context_);
   DCHECK(registration);
   if (registration) {
     registration_id_ = registration->id();
-    script_url_ = registration->script_url();
     scope_ = registration->pattern();
   }
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddListener(this);
   cache_listener_.reset(new ServiceWorkerCacheListener(this, context));
   embedded_worker_->AddListener(cache_listener_.get());
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
@@ skipping 26 matching lines @@
 void ServiceWorkerVersion::RegisterStatusChangeCallback(
     const base::Closure& callback) {
   status_change_callbacks_.push_back(callback);
 }
 
 ServiceWorkerVersionInfo ServiceWorkerVersion::GetInfo() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return ServiceWorkerVersionInfo(
       running_status(),
       status(),
+      script_url(),
       version_id(),
       embedded_worker()->process_id(),
       embedded_worker()->thread_id(),
       embedded_worker()->worker_devtools_agent_route_id());
 }
 
 void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
   StartWorkerWithCandidateProcesses(std::vector<int>(), false, callback);
 }
 
@@ skipping 55 matching lines @@
   if (update_timer_.IsRunning())
     update_timer_.Reset();
 }
 
 void ServiceWorkerVersion::StartUpdate() {
   update_timer_.Stop();
   if (!context_)
     return;
   ServiceWorkerRegistration* registration =
       context_->GetLiveRegistration(registration_id_);
-  if (!registration)
+  if (!registration || !registration->GetNewestVersion())
     return;
   context_->UpdateServiceWorker(registration);
 }
 
 void ServiceWorkerVersion::SendMessage(
     const IPC::Message& message, const StatusCallback& callback) {
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
@@ skipping 450 matching lines @@
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 }  // namespace content