Adds a basic offline check to InstallableManager.

content/public/browser/service_worker_context.h

 // Copyright 2014 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_SERVICE_WORKER_CONTEXT_H_
 #define CONTENT_PUBLIC_BROWSER_SERVICE_WORKER_CONTEXT_H_
 
 #include <set>
 #include <string>
 
 #include "base/callback_forward.h"
 #include "content/public/browser/service_worker_usage_info.h"
 #include "url/gurl.h"
 
 namespace blink {
 enum class WebNavigationHintType;
 }
 
 namespace content {
 
+enum class ServiceWorkerStatus {

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

I'm a bit worried we have too many types named "Status", and this is a pretty
generic name. It's hard to distinguish this from
content::ServiceWorkerStatusCode by name.

How about ServiceWorkerExistence?

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

It's not just about existence but about the extent to which it can handle
offline requests, so I'm not sold on 'existence'. At least that's the current
intention and we expect to extend this check in the future. I don't know the
codebase well enough yet, but I expected that status is probably overloaded
already. Some other options: ServiceWorker{Capability/Capacity/Class/Type/Kind}.

I went for ServiceWorkerCapability, please comment if you would prefer this to
change.

[falken, 2017/03/21 01:53:24]

SGTM.

+  NO_SERVICE_WORKER,
+  SERVICE_WORKER_NO_FETCH_HANDLER,
+  SERVICE_WORKER_WITH_FETCH_HANDLER,
+};
+
 // Represents the per-StoragePartition ServiceWorker data.
 class ServiceWorkerContext {
  public:
   // https://rawgithub.com/slightlyoff/ServiceWorker/master/spec/service_worker/index.html#url-scope:
   // roughly, must be of the form "<origin>/<path>/*".
   using Scope = GURL;
 
   using ResultCallback = base::Callback<void(bool success)>;
 
   using GetUsageInfoCallback = base::Callback<void(
       const std::vector<ServiceWorkerUsageInfo>& usage_info)>;
 
-  using CheckHasServiceWorkerCallback =
-      base::Callback<void(bool has_service_worker)>;
+  using CheckServiceWorkerStatusCallback =
+      base::Callback<void(ServiceWorkerStatus status)>;
 
   using CountExternalRequestsCallback =
       base::Callback<void(size_t external_request_count)>;
 
   // Registers the header name which should not be passed to the ServiceWorker.
   // Must be called from the IO thread.
   CONTENT_EXPORT static void AddExcludedHeadersForFetchEvent(
       const std::set<std::string>& header_names);
 
   // Returns true if the header name should not be passed to the ServiceWorker.
@@ skipping 53 matching lines @@
   virtual void GetAllOriginsInfo(const GetUsageInfoCallback& callback) = 0;
 
   // This function can be called from any thread, but the callback will always
   // be called on the IO thread.
   virtual void DeleteForOrigin(const GURL& origin_url,
                                const ResultCallback& callback) = 0;
 
   // Returns true if a Service Worker registration exists that matches |url|,
   // and if |other_url| falls inside the scope of the same registration. Note
   // this still returns true even if there is a Service Worker registration
   // which has a longer match for |other_url|.

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

It'd be worth clarifying in this comment what the function does in case of a
registration with only a .installing worker.

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

Good point, I've rewritten it a bit as well, as I should have updated it. Take a
look!

   //
   // This function can be called from any thread, but the callback will always
   // be called on the UI thread.
-  virtual void CheckHasServiceWorker(
+  virtual void CheckServiceWorkerStatus(

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

I think the original name may be clearer.

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

Reverted, Done.

       const GURL& url,
       const GURL& other_url,
-      const CheckHasServiceWorkerCallback& callback) = 0;
+      const CheckServiceWorkerStatusCallback& callback) = 0;
 
   // Returns the pending external request count for the worker with the
   // specified |origin| via |callback|.
   virtual void CountExternalRequestsForTest(
       const GURL& origin,
       const CountExternalRequestsCallback& callback) = 0;
 
   // Stops all running workers on the given |origin|.
   //
   // This function can be called from any thread.
@@ skipping 20 matching lines @@
       const ResultCallback& callback) = 0;
 
  protected:
   ServiceWorkerContext() {}
   virtual ~ServiceWorkerContext() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_SERVICE_WORKER_CONTEXT_H_