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

chrome/browser/renderer_host/offline_resource_throttle.cc

 // Copyright (c) 2012 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 "chrome/browser/renderer_host/offline_resource_throttle.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/chromeos/offline/offline_load_page.h"
 #include "content/public/browser/appcache_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
+#include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "url/url_constants.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
@@ skipping 24 matching lines @@
       (new chromeos::OfflineLoadPage(web_contents, url, callback))->Show();
   }
 }
 
 }  // namespace
 
 OfflineResourceThrottle::OfflineResourceThrottle(
     net::URLRequest* request,
     content::AppCacheService* appcache_service)
     : request_(request),
-      appcache_service_(appcache_service) {
+      appcache_service_(appcache_service),
+      pending_callbacks_(0) {
   DCHECK(appcache_service);
 }
 
 OfflineResourceThrottle::~OfflineResourceThrottle() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!appcache_completion_callback_.IsCancelled())
     appcache_completion_callback_.Cancel();
+  if (!service_worker_completion_callback_.IsCancelled())
+    service_worker_completion_callback_.Cancel();
 }
 
 void OfflineResourceThrottle::WillStartRequest(bool* defer) {
   if (!ShouldShowOfflinePage(request_->url()))
     return;
 
   DVLOG(1) << "WillStartRequest: this=" << this << ", url=" << request_->url();
 
   const GURL* url = &(request_->url());
   const GURL* first_party = &(request_->first_party_for_cookies());
 
   // Anticipate a client-side HSTS based redirect from HTTP to HTTPS, and
   // ask the appcache about the HTTPS url instead of the HTTP url.
   GURL redirect_url;
   if (request_->GetHSTSRedirect(&redirect_url)) {
     if (url->GetOrigin() == first_party->GetOrigin())
       first_party = &redirect_url;
     url = &redirect_url;
   }
 
+  pending_callbacks_ = 1;
+
   DCHECK(appcache_completion_callback_.IsCancelled());
-
   appcache_completion_callback_.Reset(
       base::Bind(&OfflineResourceThrottle::OnCanHandleOfflineComplete,
                  AsWeakPtr()));
   appcache_service_->CanHandleMainResourceOffline(
       *url, *first_party,
       appcache_completion_callback_.callback());
 
+  DCHECK(service_worker_completion_callback_.IsCancelled());
+  content::ServiceWorkerContext* service_worker_context =
+      content::ServiceWorkerContext::GetServiceWorkerContext(request_);
+  if (service_worker_context) {
+    pending_callbacks_ = 2;
+    service_worker_completion_callback_.Reset(
+        base::Bind(&OfflineResourceThrottle::OnCanHandleOfflineComplete,
+                   AsWeakPtr()));
+    service_worker_context->CanHandleMainResourceOffline(
+        *url, *first_party,
+        service_worker_completion_callback_.callback());
+  }
   *defer = true;
 }
 
 const char* OfflineResourceThrottle::GetNameForLogging() const {
   return "OfflineResourceThrottle";
 }
 
 void OfflineResourceThrottle::OnBlockingPageComplete(bool proceed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 10 matching lines @@
                                            url.SchemeIs(url::kHttpsScheme));
 }
 
 bool OfflineResourceThrottle::ShouldShowOfflinePage(const GURL& url) const {
   // If the network is disconnected while loading other resources, we'll simply
   // show broken link/images.
   return IsRemote(url) && net::NetworkChangeNotifier::IsOffline();
 }
 
 void OfflineResourceThrottle::OnCanHandleOfflineComplete(int rv) {
-  appcache_completion_callback_.Cancel();
+  --pending_callbacks_;
 
   if (rv == net::OK) {
+    appcache_completion_callback_.Cancel();
+    service_worker_completion_callback_.Cancel();
     controller()->Resume();
-  } else {
+  } else if (!pending_callbacks_) {
+    appcache_completion_callback_.Cancel();
+    service_worker_completion_callback_.Cancel();

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

Would it improve readability to set pending_callbacks_ = 0 here and above, then
DCHECK(!pending_callbacks_) in WillStartRequest, and then use
++pending_callbacks_ there instead of setting to 1 and 2 directly? Just a
suggestion, WDYT.

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

Done, kinda

     const content::ResourceRequestInfo* info =
         content::ResourceRequestInfo::ForRequest(request_);
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(
             &ShowOfflinePage,
             info->GetChildID(),
             info->GetRouteID(),
             request_->url(),
             base::Bind(
                 &OfflineResourceThrottle::OnBlockingPageComplete,
                 AsWeakPtr())));
   }
 }