Service Worker: Migrate to version_uuid and surface ServiceWorker.id. (Chromium 2/3)

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/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 453 matching lines @@
   enum PingState { NOT_PINGING, PINGING, PING_TIMED_OUT };
   ServiceWorkerVersion* version_;  // Not owned.
   base::TimeTicks ping_time_;
   PingState ping_state_ = NOT_PINGING;
   DISALLOW_COPY_AND_ASSIGN(PingController);
 };
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     const GURL& script_url,
-    int64 version_id,
+    std::string version_uuid,
     base::WeakPtr<ServiceWorkerContextCore> context)
-    : version_id_(version_id),
+    : version_uuid_(version_uuid),
       registration_id_(registration->id()),
       script_url_(script_url),
       scope_(registration->pattern()),
       context_(context),
       script_cache_map_(this, context),
       ping_controller_(new PingController(this)),
       metrics_(new Metrics),
       weak_factory_(this) {
   DCHECK(context_);
   DCHECK(registration);
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddListener(this);
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
   // The user may have closed the tab waiting for SW to start up.
   if (GetTickDuration(start_time_) >
       base::TimeDelta::FromSeconds(
           kDestructedStartingWorkerTimeoutThresholdSeconds)) {
     DCHECK(timeout_timer_.IsRunning());
     DCHECK(!embedded_worker_->devtools_attached());
     RecordStartWorkerResult(SERVICE_WORKER_ERROR_TIMEOUT);
   }
 
   if (context_)
-    context_->RemoveLiveVersion(version_id_);
+    context_->RemoveLiveVersion(version_uuid_);
 
   if (running_status() == STARTING || running_status() == RUNNING)
     embedded_worker_->Stop();
   embedded_worker_->RemoveListener(this);
 }
 
 void ServiceWorkerVersion::SetStatus(Status status) {
   if (status_ == status)
     return;
 
@@ skipping 14 matching lines @@
 }
 
 void ServiceWorkerVersion::RegisterStatusChangeCallback(
     const base::Closure& callback) {
   status_change_callbacks_.push_back(callback);
 }
 
 ServiceWorkerVersionInfo ServiceWorkerVersion::GetInfo() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerVersionInfo info(
-      running_status(), status(), script_url(), registration_id(), version_id(),
-      embedded_worker()->process_id(), embedded_worker()->thread_id(),
+      running_status(), status(), script_url(), registration_id(),
+      version_uuid(), embedded_worker()->process_id(),
+      embedded_worker()->thread_id(),
       embedded_worker()->worker_devtools_agent_route_id());
   for (const auto& controllee : controllee_map_) {
     const ServiceWorkerProviderHost* host = controllee.second;
     info.clients.insert(std::make_pair(
         host->client_uuid(),
         ServiceWorkerVersionInfo::ClientInfo(
             host->process_id(), host->route_id(), host->provider_type())));
   }
   if (!main_script_http_info_)
     return info;
@@ skipping 1202 matching lines @@
       StartWorkerInternal(pause_after_download);
       return;
   }
 }
 
 void ServiceWorkerVersion::StartWorkerInternal(bool pause_after_download) {
   if (!timeout_timer_.IsRunning())
     StartTimeoutTimer();
   if (running_status() == STOPPED) {
     embedded_worker_->Start(
-        version_id_, scope_, script_url_, pause_after_download,
+        version_uuid_, scope_, script_url_, pause_after_download,
         base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerVersion::GetWindowClients(
     int request_id,
     const ServiceWorkerClientQueryOptions& options) {
   DCHECK(options.client_type == blink::WebServiceWorkerClientTypeWindow ||
          options.client_type == blink::WebServiceWorkerClientTypeAll);
@@ skipping 327 matching lines @@
 }
 
 void ServiceWorkerVersion::FoundRegistrationForUpdate(
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   if (!context_)
     return;
 
   const scoped_refptr<ServiceWorkerVersion> protect = this;
   if (is_update_scheduled_) {
-    context_->UnprotectVersion(version_id_);
+    context_->UnprotectVersion(version_uuid_);
     is_update_scheduled_ = false;
   }
 
   if (status != SERVICE_WORKER_OK || registration->active_version() != this)
     return;
   context_->UpdateServiceWorker(registration.get(),
                                 false /* force_bypass_cache */);
 }
 
 }  // namespace content