Serve offline page for online URL on disconnected or bad networks

chrome/browser/profiles/profile_impl_io_data.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/profiles/profile_impl_io_data.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 51 matching lines @@
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 #if defined(OS_ANDROID)
-#include "chrome/browser/android/offline_pages/offline_page_request_handler.h"
+#include "chrome/browser/android/offline_pages/offline_page_request_interceptor.h"
 #endif  // defined(OS_ANDROID)
 
 namespace {
 
 net::BackendType ChooseCacheBackendType() {
 #if !defined(OS_ANDROID)
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUseSimpleCacheBackend)) {
     const std::string opt_value =
@@ skipping 442 matching lines @@
   ftp_factory_.reset(
       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
   std::unique_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 
   // Install the Offline Page Interceptor.
 #if defined(OS_ANDROID)
-  std::unique_ptr<net::URLRequestInterceptor> offline_page_interceptor =
-      offline_pages::OfflinePageRequestHandler::CreateInterceptor(
-          profile_params->profile);
-  if (offline_page_interceptor)
-    request_interceptors.push_back(std::move(offline_page_interceptor));
+  request_interceptors.push_back(std::unique_ptr<net::URLRequestInterceptor>(

[mmenke, 2016/08/19 15:04:09]

Potential Bug:  ServiceWorker.  We don't want offline pages to go through a
site's ServiceWorker code, which can result in Bad Things (A site caching the
offline version of the page, for instance).  I'm not all that familiar with
ServiceWorker code, so not sure the best way to avoid it.

The way ServiceWorker works is a we create a request as normal, but then
ServiceWorker's interceptor intercepts that request, sends it to a a renderer,
which then may (Or may not) issue another request for the resource, which goes
over the network.  If we can intercept the initial  request, that's fine.  If we
intercept the second request, we're in trouble.

I think ServiceWorker will pass the ResourceType on through, so checking that
isn't sufficient, but I'm not positive.

[jianli, 2016/08/19 19:34:56]

I think ServiceWorker's interceptor will kick in before offline page
interceptor. The 2nd request should have ResourceType set which will be used to
filter out from offline interception.

I will run some tests to verify this is the case.

[mmenke, 2016/08/19 19:43:01]

I think the ResourceType will be the same as the original - i.e., if we think
it's for the main frame, it will still be RESOURCE_TYPE_MAIN_FRAME (Note that
RESOURCE_TYPE_SERVICE_WORKER is just for the service worker's JS).

Anyhow, manual testing sounds good to me, but I think we should also have
browser tests for it.

+      new offline_pages::OfflinePageRequestInterceptor(
+          profile_params->profile)));
 #endif
 
   // The data reduction proxy interceptor should be as close to the network
   // as possible.
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
   main_job_factory_ = SetUpJobFactoryDefaults(
       std::move(main_job_factory), std::move(request_interceptors),
       std::move(profile_params->protocol_handler_interceptor),
@@ skipping 244 matching lines @@
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }