ServiceWorker: Make claim() uses living matching registrations instead of fetching from DB.

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/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 1374 matching lines @@
   if (pending_skip_waiting_requests_.size() == 1)
     registration->ActivateWaitingVersionWhenReady();
 }
 
 void ServiceWorkerVersion::DidSkipWaiting(int request_id) {
   if (running_status() == STARTING || running_status() == RUNNING)
     embedded_worker_->SendMessage(ServiceWorkerMsg_DidSkipWaiting(request_id));
 }
 
 void ServiceWorkerVersion::OnClaimClients(int request_id) {
-  StatusCallback callback = base::Bind(&ServiceWorkerVersion::DidClaimClients,
-                                       weak_factory_.GetWeakPtr(), request_id);
   if (status_ != ACTIVATING && status_ != ACTIVATED) {
-    callback.Run(SERVICE_WORKER_ERROR_STATE);
+    embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
+        request_id, blink::WebServiceWorkerError::ErrorTypeState,
+        base::ASCIIToUTF16(kClaimClientsStateErrorMesage)));
     return;
   }
-  if (!context_) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT);
-    return;
+  if (context_) {
+    if (ServiceWorkerRegistration* registration =
+            context_->GetLiveRegistration(registration_id_)) {

[falken, 2015/03/23 00:38:57]

(unrelated to this patch) I think there might be an existing bug here... does
anything guarantee the registration is live here? We had a similar bug in
crbug.com/465254 that was fixed by ensuring the live registration for starting
SWVersions, but not for running ones.

[michaeln, 2015/03/23 20:02:26]

Good question. I think the answer is 'yes', hiroki's patch kept a reference
alive long enough for the a RegistrationHandle to be established on behalf of
the running worker script. See GetRegistrationObjectInfoAndVersionAttributes and
 GetOrCreateRegistrationHandle.

[xiang, 2015/03/24 07:32:51]

Thanks for the clarification, yes, the RegistrationHandle will keep the
registration alive after worker starts.

+      registration->ClaimClients();
+      embedded_worker_->SendMessage(
+          ServiceWorkerMsg_DidClaimClients(request_id));
+      return;
+    }
   }
 
-  ServiceWorkerRegistration* registration =
-      context_->GetLiveRegistration(registration_id_);
-  if (!registration) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT);
-    return;
-  }
-  registration->ClaimClients(callback);
+  embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
+      request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
+      base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
+  return;

[michaeln, 2015/03/20 19:25:21]

this return statement is not needed

[xiang, 2015/03/24 07:32:51]

Done.

 }
 
 void ServiceWorkerVersion::OnPongFromWorker() {
   ClearTick(&ping_time_);
 }
 
 void ServiceWorkerVersion::DidEnsureLiveRegistrationForStartWorker(
     bool pause_after_download,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status,
@@ skipping 20 matching lines @@
         cache_listener_.reset(new ServiceWorkerCacheListener(this, context_));
         embedded_worker_->Start(
             version_id_, scope_, script_url_, pause_after_download,
             base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                        weak_factory_.GetWeakPtr()));
       }
       return;
   }
 }
 
-void ServiceWorkerVersion::DidClaimClients(
-    int request_id, ServiceWorkerStatusCode status) {
-  if (status == SERVICE_WORKER_ERROR_STATE) {
-    embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
-        request_id, blink::WebServiceWorkerError::ErrorTypeState,
-        base::ASCIIToUTF16(kClaimClientsStateErrorMesage)));
-    return;
-  }
-  if (status == SERVICE_WORKER_ERROR_ABORT) {
-    embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
-        request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
-        base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
-    return;
-  }
-  DCHECK(status == SERVICE_WORKER_OK);
-  embedded_worker_->SendMessage(ServiceWorkerMsg_DidClaimClients(request_id));
-}
-
 void ServiceWorkerVersion::DidGetClients(
     int request_id,
     const std::vector<ServiceWorkerClientInfo>& clients) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (running_status() != RUNNING)
     return;
 
   embedded_worker_->SendMessage(
       ServiceWorkerMsg_DidGetClients(request_id, clients));
 }
@@ skipping 171 matching lines @@
     int request_id) {
   callbacks->Remove(request_id);
   if (is_doomed_) {
     // The stop should be already scheduled, but try to stop immediately, in
     // order to release worker resources soon.
     StopWorkerIfIdle();
   }
 }
 
 }  // namespace content