Trigger redirect for offline pages

chrome/browser/android/offline_pages/offline_page_request_job.cc

 // Copyright 2016 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/android/offline_pages/offline_page_request_job.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/offline_page_tab_helper.h"
 #include "chrome/browser/android/offline_pages/offline_page_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "components/offline_pages/request_header/offline_page_header.h"
 #include "components/previews/core/previews_decider.h"
 #include "components/previews/core/previews_experiments.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/resource_type.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_redirect_job.h"
+#include "url/gurl.h"
 
 namespace offline_pages {
 
 namespace {
 
 enum class NetworkState {
   // No network connection.
   DISCONNECTED_NETWORK,
   // Prohibitively slow means that the NetworkQualityEstimator reported a
   // connection slow enough to warrant showing an offline page if available.
@@ skipping 519 matching lines @@
                  delegate_->GetWebContentsGetter(request()),
                  delegate_->GetTabIdGetter(),
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageRequestJob::Kill() {
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
+bool OfflinePageRequestJob::IsRedirectResponse(GURL* location,
+                                               int* http_status_code) {
+  // OfflinePageRequestJob derives from URLRequestFileJob which derives from
+  // URLRequestJob. We need to invoke the implementation of IsRedirectResponse
+  // in URLRequestJob directly since URLRequestFileJob overrode it with the
+  // logic we don't want.
+  return URLRequestJob::IsRedirectResponse(location, http_status_code);
+}
+
+void OfflinePageRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
+  if (!fake_headers_for_redirect_) {
+    URLRequestFileJob::GetResponseInfo(info);
+    return;
+  }
+
+  info->headers = fake_headers_for_redirect_;
+  info->request_time = redirect_response_time_;
+  info->response_time = redirect_response_time_;
+}
+
+void OfflinePageRequestJob::GetLoadTimingInfo(
+    net::LoadTimingInfo* load_timing_info) const {
+  // Set send_start and send_end to receive_redirect_headers_end_ to be
+  // consistent with network cache behavior.
+  load_timing_info->send_start = receive_redirect_headers_end_;
+  load_timing_info->send_end = receive_redirect_headers_end_;
+  load_timing_info->receive_headers_end = receive_redirect_headers_end_;
+}
+
+bool OfflinePageRequestJob::CopyFragmentOnRedirect(const GURL& location) const {
+  return false;
+}
+
+int OfflinePageRequestJob::GetResponseCode() const {
+  if (!fake_headers_for_redirect_)
+    return URLRequestFileJob::GetResponseCode();
+
+  return net::URLRequestRedirectJob::REDIRECT_302_FOUND;
+}
+
 void OfflinePageRequestJob::FallbackToDefault() {
   OfflinePageRequestInfo* info =
       OfflinePageRequestInfo::GetFromRequest(request());
   DCHECK(info);
   info->set_use_default(true);
 
   URLRequestJob::NotifyRestartRequired();
 }
 
 void OfflinePageRequestJob::OnOfflineFilePathAvailable(
     const base::FilePath& offline_file_path) {
   // If offline file path is empty, it means that offline page cannot be found
   // and we want to restart the job to fall back to the default handling.
   if (offline_file_path.empty()) {
     FallbackToDefault();
     return;
   }
 
   // Sets the file path and lets URLRequestFileJob start to read from the file.
   file_path_ = offline_file_path;
   URLRequestFileJob::Start();
 }
 
 void OfflinePageRequestJob::OnOfflineRedirectAvailabe(
     const GURL& redirected_url) {
-  // TODO(jianli): kicks off the redirect. For now, use the default.
-  FallbackToDefault();
+  receive_redirect_headers_end_ = base::TimeTicks::Now();
+  redirect_response_time_ = base::Time::Now();
+
+  std::string header_string =
+      base::StringPrintf("HTTP/1.1 %i Internal Redirect\n"
+                             // Clear referrer to avoid leak when going online.
+                             "Referrer-Policy: no-referrer\n"
+                             "Location: %s\n"
+                             "Non-Authoritative-Reason: offline redirects",
+                         // 302 is used to remove response bodies in order to
+                         // avoid leak when going online.
+                         net::URLRequestRedirectJob::REDIRECT_302_FOUND,
+                         redirected_url.spec().c_str());
+
+  fake_headers_for_redirect_ = new net::HttpResponseHeaders(
+      net::HttpUtil::AssembleRawHeaders(header_string.c_str(),
+                                        header_string.length()));
+  DCHECK(fake_headers_for_redirect_->IsRedirect(nullptr));
+
+  URLRequestJob::NotifyHeadersComplete();
 }
 
 void OfflinePageRequestJob::SetDelegateForTesting(
     std::unique_ptr<Delegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
 }  // namespace offline_pages