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(
+    const ServiceWorkerContext::CheckServiceWorkerStatusCallback callback,
+    scoped_refptr<ServiceWorkerRegistration> registration) {
+  ServiceWorkerVersion* sw_version = registration->active_version()
+                                         ? registration->active_version()
+                                         : registration->waiting_version();
+
+  DCHECK(sw_version);
+
+  ServiceWorkerVersion::FetchHandlerExistence existence =
+      sw_version->fetch_handler_existence();
+
+  DCHECK(existence != ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
+
+  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);
+  content::CheckFetchHandlerOfRegisteredServiceWorker(callback, registration);

[dominickn, 2017/03/16 06:21:57]

Nit: this is all inside the content namespace, so I think you don't need the
content:: qualifier.

[piotrs, 2017/03/17 02:21:38]

Done.

 }
 
-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;
+  }
+
+  content::CheckFetchHandlerOfRegisteredServiceWorker(callback, registration);

[dominickn, 2017/03/16 06:21:57]

Nit: this is all inside the content namespace, so I think you don't need the
content:: qualifier.

[piotrs, 2017/03/17 02:21:38]

Done.

 }
 
 }  // namespace content