Adds a basic offline check to InstallableManager.

content/browser/service_worker/service_worker_context_core.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_context_core.h"
 
 #include <limits>
 #include <set>
 #include <utility>
 
@@ skipping 14 matching lines @@
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_database_task_manager.h"
 #include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
+#include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "ipc/ipc_message.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace {
 
+void CheckFetchHandlerOfRegisteredServiceWorker(

[falken, 2017/03/17 07:54:37]

This name is a bit inconsistent with SW nomenclature. All service workers are
"registered" in the sense that all service workers are associated with a
registration.

I might recommend CheckFetchHandlerOfInstalledServiceWorker or just
CheckFetchHandler and with maybe a comment that the registration needs to have
an installed worker. Or maybe the caller should just pass the
ServiceWorkerVersion directly?

[piotrs, 2017/03/21 00:00:43]

Chunk of the work of this method is taking right service worker version from
registration, so I went for your suggestion to use
CheckFetchHandlerOfInstalledServiceWorker.

Done.

+    const ServiceWorkerContext::CheckServiceWorkerStatusCallback callback,
+    scoped_refptr<ServiceWorkerRegistration> registration) {
+  ServiceWorkerVersion* sw_version = registration->active_version()
+                                         ? registration->active_version()
+                                         : registration->waiting_version();

[falken, 2017/03/17 07:54:37]

Are you sure you want the active version to override the waiting version? The
waiting version is the newest installed version. So when making decisions about
whether this SW registration has offline capability, it might be more
appropriate to use the waiting version.

[piotrs, 2017/03/21 00:00:43]

Done + added a comment for posterity as it's possibly not obvious for every
reader.

+
+  DCHECK(sw_version);
+
+  ServiceWorkerVersion::FetchHandlerExistence existence =
+      sw_version->fetch_handler_existence();
+
+  DCHECK(existence != ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);

[falken, 2017/03/17 07:54:37]

nit: Is it possible to use DCHECK_NE here?

[piotrs, 2017/03/21 00:00:44]

Done.

+
+  callback.Run(existence == ServiceWorkerVersion::FetchHandlerExistence::EXISTS
+                   ? ServiceWorkerStatus::SERVICE_WORKER_WITH_FETCH_HANDLER
+                   : ServiceWorkerStatus::SERVICE_WORKER_NO_FETCH_HANDLER);
+}
+
 void SuccessCollectorCallback(const base::Closure& done_closure,
                               bool* overall_success,
                               ServiceWorkerStatusCode status) {
   if (status != ServiceWorkerStatusCode::SERVICE_WORKER_OK) {
     *overall_success = false;
   }
   done_closure.Run();
 }
 
 void SuccessReportingCallback(
@@ skipping 634 matching lines @@
   scoped_refptr<ClearAllServiceWorkersHelper> helper(
       new ClearAllServiceWorkersHelper(callback));
   if (!was_service_worker_registered_)
     return;
   was_service_worker_registered_ = false;
   storage()->GetAllRegistrationsInfos(
       base::Bind(&ClearAllServiceWorkersHelper::DidGetAllRegistrations, helper,
                  AsWeakPtr()));
 }
 
-void ServiceWorkerContextCore::CheckHasServiceWorker(
+void ServiceWorkerContextCore::CheckServiceWorkerStatus(
     const GURL& url,
     const GURL& other_url,
-    const ServiceWorkerContext::CheckHasServiceWorkerCallback callback) {
+    const ServiceWorkerContext::CheckServiceWorkerStatusCallback callback) {
   storage()->FindRegistrationForDocument(
       url, base::Bind(&ServiceWorkerContextCore::
-                          DidFindRegistrationForCheckHasServiceWorker,
+                          DidFindRegistrationForCheckServiceWorkerStatus,
                       AsWeakPtr(), other_url, callback));
 }
 
 void ServiceWorkerContextCore::UpdateVersionFailureCount(
     int64_t version_id,
     ServiceWorkerStatusCode status) {
   // Don't count these, they aren't start worker failures.
   if (status == SERVICE_WORKER_ERROR_DISALLOWED)
     return;
 
@@ skipping 126 matching lines @@
     return;
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnControlleeRemoved,
                          version->version_id(), provider_host->client_uuid());
 }
 
 ServiceWorkerProcessManager* ServiceWorkerContextCore::process_manager() {
   return wrapper_->process_manager();
 }
 
-void ServiceWorkerContextCore::DidFindRegistrationForCheckHasServiceWorker(
+void ServiceWorkerContextCore::DidFindRegistrationForCheckServiceWorkerStatus(
     const GURL& other_url,
-    const ServiceWorkerContext::CheckHasServiceWorkerCallback callback,
+    const ServiceWorkerContext::CheckServiceWorkerStatusCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   if (status != SERVICE_WORKER_OK) {
-    callback.Run(false);
+    callback.Run(ServiceWorkerStatus::NO_SERVICE_WORKER);
     return;
   }
 
   if (!ServiceWorkerUtils::ScopeMatches(registration->pattern(), other_url)) {
-    callback.Run(false);
+    callback.Run(ServiceWorkerStatus::NO_SERVICE_WORKER);
     return;
   }
 
   if (registration->is_uninstalling() || registration->is_uninstalled()) {
-    callback.Run(false);
+    callback.Run(ServiceWorkerStatus::NO_SERVICE_WORKER);
     return;
   }
 
   if (!registration->active_version() && !registration->waiting_version()) {
     registration->RegisterRegistrationFinishedCallback(
         base::Bind(&ServiceWorkerContextCore::
-                       OnRegistrationFinishedForCheckHasServiceWorker,
+                       OnRegistrationFinishedForCheckServiceWorkerStatus,
                    AsWeakPtr(), callback, registration));
     return;
   }
 
-  callback.Run(true);
+  CheckFetchHandlerOfRegisteredServiceWorker(callback, registration);
 }
 
-void ServiceWorkerContextCore::OnRegistrationFinishedForCheckHasServiceWorker(
-    const ServiceWorkerContext::CheckHasServiceWorkerCallback callback,
-    scoped_refptr<ServiceWorkerRegistration> registration) {
-  callback.Run(registration->active_version() ||
-               registration->waiting_version());
+void ServiceWorkerContextCore::
+    OnRegistrationFinishedForCheckServiceWorkerStatus(
+        const ServiceWorkerContext::CheckServiceWorkerStatusCallback callback,
+        scoped_refptr<ServiceWorkerRegistration> registration) {
+  if (!registration->active_version() && !registration->waiting_version()) {
+    callback.Run(ServiceWorkerStatus::NO_SERVICE_WORKER);
+    return;
+  }
+
+  CheckFetchHandlerOfRegisteredServiceWorker(callback, registration);
 }
 
 }  // namespace content