Teach CrOS's OfflineResourceThrottle about ServiceWorkers so it know longer presents its offline in…

content/browser/service_worker/service_worker_context_wrapper.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_wrapper.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
+#include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/service_worker_context.h"
+#include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
 namespace {
 
 typedef std::set<std::string> HeaderNameSet;
 base::LazyInstance<HeaderNameSet> g_excluded_header_name_set =
     LAZY_INSTANCE_INITIALIZER;
+
+void RunSoon(const base::Closure& closure) {
+  base::MessageLoop::current()->PostTask(FROM_HERE, closure);
 }
 
+}  // namespace
+
 void ServiceWorkerContext::AddExcludedHeadersForFetchEvent(
     const std::set<std::string>& header_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   g_excluded_header_name_set.Get().insert(header_names.begin(),
                                           header_names.end());
 }
 
 bool ServiceWorkerContext::IsExcludedHeaderNameForFetchEvent(
     const std::string& header_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return g_excluded_header_name_set.Get().find(header_name) !=
          g_excluded_header_name_set.Get().end();
 }
 
+ServiceWorkerContext* ServiceWorkerContext::GetServiceWorkerContext(
+    net::URLRequest* request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerRequestHandler* handler =
+      ServiceWorkerRequestHandler::GetHandler(request);
+  if (!handler || !handler->context())
+    return nullptr;
+  return handler->context()->wrapper_;
+}
+
 ServiceWorkerContextWrapper::ServiceWorkerContextWrapper(
     BrowserContext* browser_context)
     : observer_list_(
           new ObserverListThreadSafe<ServiceWorkerContextObserver>()),
       process_manager_(new ServiceWorkerProcessManager(browser_context)),
       is_incognito_(false) {
 }
 
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
 }
@@ skipping 111 matching lines @@
         FROM_HERE,
         base::Bind(continuation, false));
     return;
   }
 
   context()->UnregisterServiceWorker(
       pattern,
       base::Bind(&FinishUnregistrationOnIO, continuation));
 }
 
+static void DidFindRegistrationForDocument(

[falken, 2014/12/16 08:16:49]

nit: chromium codebase tends to put these in unnamed namespace instead of as
static functions

[michaeln, 2015/01/09 01:47:36]

True, but this class file isn't following that convention atm, so when in
rome...

[falken, 2015/01/09 02:27:44]

oops didn't notice, sorry

+    const net::CompletionCallback& callback,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  int rv = registration ? net::OK : net::ERR_CACHE_MISS;
+  // Use RunSoon here because FindRegistrationForDocument can complete
+  // immediately but CanHandleMainResourceOffline must be async.
+  RunSoon(base::Bind(callback, rv));
+}
+
+void ServiceWorkerContextWrapper::CanHandleMainResourceOffline(
+      const GURL& url,
+      const GURL& first_party,
+      const net::CompletionCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!url.SchemeIsSecure()) {

[falken, 2014/12/16 08:16:49]

Is this needed? Can FindRegistrationForDocument return true for a non-secure
URL?

[michaeln, 2015/01/09 01:47:36]

Done

+    RunSoon(base::Bind(callback, net::ERR_CACHE_MISS));
+    return;
+  }
+  // TODO(michaeln): Use GetContentClient()->browser()->AllowServiceWorker to
+  // check for 3rd party cookie usage.

[falken, 2014/12/16 08:16:50]

I'm wondering what is the consequence of not doing this check? I guess the
offline interstitial doesn't get displayed when it could, but later on the
request handler fails and the user sees some offline message then... which
doesn't seem so bad. Why does Chrome OS have this special offline page? 

[michaeln, 2015/01/09 01:47:36]

I've removed the todo. They can't be registered when !AllowServiceWorker, so
Find would be expected to find nothing. There's a corner case where the setting
is changed sometime after a registration is done, but as you noticed the failure
modes are mild.
Idk.

[falken, 2015/01/09 02:27:44]

+oshima: do you know why this is CrOS-specific?

+  context()->storage()->FindRegistrationForDocument(
+      url,
+      base::Bind(&DidFindRegistrationForDocument, callback));
+}
+
 void ServiceWorkerContextWrapper::GetAllOriginsInfo(
     const GetUsageInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!context_core_.get()) {
     LOG(ERROR) << "ServiceWorkerContextCore is no longer alive.";
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback, std::vector<ServiceWorkerUsageInfo>()));
     return;
@@ skipping 127 matching lines @@
     context_core_.reset();
     return;
   }
   context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
   DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
 
   observer_list_->Notify(&ServiceWorkerContextObserver::OnStorageWiped);
 }
 
 }  // namespace content