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(
+    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);
+  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