Load live version when reloading an offline page on connected network

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/strings/string_tokenizer.h"
-#include "base/strings/string_util.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_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/nqe/network_quality_estimator.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace offline_pages {
 
-const char kOfflinePageHeader[] = "X-Chrome-offline";
-const char kOfflinePageHeaderReasonKey[] = "reason";
-const char kOfflinePageHeaderReasonValueDueToNetError[] = "error";
-const char kOfflinePageHeaderReasonValueFromDownload[] = "download";
-const char kOfflinePageHeaderPersistKey[] = "persist";
-const char kOfflinePageHeaderIDKey[] = "id";
-
 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.
   PROHIBITIVELY_SLOW_NETWORK,
   // Network error received due to bad network, i.e. connected to a hotspot or
   // proxy that does not have a working network.
@@ skipping 56 matching lines @@
   }
 
  private:
   static bool GetTabId(content::WebContents* web_contents, int* tab_id) {
     return OfflinePageUtils::GetTabId(web_contents, tab_id);
   }
 
   DISALLOW_COPY_AND_ASSIGN(DefaultDelegate);
 };
 
-// Used to parse the extra request header string that defines offline page
-// loading behaviors.
-class OfflinePageHeader {
- public:
-  enum class Reason {
-    NET_ERROR,
-    DOWNLOAD,
-    UNKNOWN
-  };
-
-  explicit OfflinePageHeader(const std::string& header_string);
-  ~OfflinePageHeader() {}
-
-  bool successfully_parsed() const { return successfully_parsed_; }
-  bool need_to_persist() const { return need_to_persist_; }
-  Reason reason() const { return reason_; }
-  const std::string& id() const { return id_; }
-
- private:
-  // True if the header is present and parsed successfully.
-  bool successfully_parsed_;
-  // Flag to indicate if the header should be persisted across session restore.
-  bool need_to_persist_;
-  // Describes the reason to load offline page.
-  Reason reason_;
-  // The offline ID of the page to load.
-  std::string id_;
-
-  DISALLOW_COPY_AND_ASSIGN(OfflinePageHeader);
-};
-
-OfflinePageHeader::OfflinePageHeader(const std::string& header_string)
-    : successfully_parsed_(false),
-      need_to_persist_(false),
-      reason_(Reason::UNKNOWN) {
-  // If the offline header is not present, treat it as not parsed successfully.
-  if (header_string.empty())
-    return;
-
-  base::StringTokenizer tokenizer(header_string, ", ");
-  while (tokenizer.GetNext()) {
-    std::string pair = tokenizer.token();
-    std::size_t pos = pair.find('=');
-    if (pos == std::string::npos)
-      return;
-    std::string key = base::ToLowerASCII(pair.substr(0, pos));
-    std::string value = base::ToLowerASCII(pair.substr(pos + 1));
-    if (key == kOfflinePageHeaderPersistKey) {
-      need_to_persist_ = (value == "1");
-    } else if (key == kOfflinePageHeaderReasonKey) {
-      if (value == kOfflinePageHeaderReasonValueDueToNetError)
-        reason_ = Reason::NET_ERROR;
-      else if (value == kOfflinePageHeaderReasonValueFromDownload)
-        reason_ = Reason::DOWNLOAD;
-      else
-        reason_ = Reason::UNKNOWN;
-    } else if (key == kOfflinePageHeaderIDKey) {
-      id_ = value;
-    }
-  }
-
-  successfully_parsed_ = true;
-}
-
 bool IsNetworkProhibitivelySlow(net::URLRequest* request) {
   // NetworkQualityEstimator only works when it is enabled.
   if (!previews::IsOfflinePreviewsEnabled())
     return false;
 
   if (!request->context())
     return false;
 
   net::NetworkQualityEstimator* network_quality_estimator =
       request->context()->network_quality_estimator();
   if (!network_quality_estimator)
     return false;
 
   net::EffectiveConnectionType effective_connection_type =
       network_quality_estimator->GetEffectiveConnectionType();
   return effective_connection_type >= net::EFFECTIVE_CONNECTION_TYPE_OFFLINE &&
          effective_connection_type <= net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G;
 }
 
-NetworkState GetNetworkState(net::URLRequest* request) {
+NetworkState GetNetworkState(net::URLRequest* request,
+                             const OfflinePageHeader& offline_header) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  std::string offline_header_string;
-  request->extra_request_headers().GetHeader(
-      kOfflinePageHeader, &offline_header_string);
-  OfflinePageHeader offline_header(offline_header_string);
-  if (offline_header.reason() == OfflinePageHeader::Reason::NET_ERROR)
+  if (offline_header.reason == OfflinePageHeader::Reason::NET_ERROR)
     return NetworkState::FLAKY_NETWORK;
 
   if (net::NetworkChangeNotifier::IsOffline())
     return NetworkState::DISCONNECTED_NETWORK;
 
   if (IsNetworkProhibitivelySlow(request))
     return NetworkState::PROHIBITIVELY_SLOW_NETWORK;
 
-  // If custom offline header is present, the offline page should be forced to
-  // load even when the network is connected.
-  return offline_header.successfully_parsed()
+  // If offline header contains a reason other than RELOAD, the offline page
+  // should be forced to load even when the network is connected.
+  return (offline_header.reason != OfflinePageHeader::Reason::NONE &&
+          offline_header.reason != OfflinePageHeader::Reason::RELOAD)
              ? NetworkState::FORCE_OFFLINE_ON_CONNECTED_NETWORK
              : NetworkState::CONNECTED_NETWORK;
 }
 
 OfflinePageRequestJob::AggregatedRequestResult
 RequestResultToAggregatedRequestResult(
     RequestResult request_result, NetworkState network_state) {
   if (request_result == RequestResult::NO_TAB_ID)
     return OfflinePageRequestJob::AggregatedRequestResult::NO_TAB_ID;
 
@@ skipping 84 matching lines @@
   // from IO thread.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&NotifyOfflineFilePathOnIO, job, offline_file_path));
 }
 
 // Finds the offline file path based on the select page result and network
 // state and marks it as accessed.
 RequestResult AccessOfflineFile(
+    const OfflinePageHeader& offline_header,
     NetworkState network_state,
     base::WeakPtr<OfflinePageRequestJob> job,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     const OfflinePageItem* offline_page,
     base::FilePath* offline_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!offline_page)
     return RequestResult::OFFLINE_PAGE_NOT_FOUND;
 
@@ skipping 20 matching lines @@
   // will not be created under incognito mode.
   DCHECK(offline_page_model);
   offline_page_model->MarkPageAccessed(offline_page->offline_id);
 
   // Save an cached copy of OfflinePageItem such that Tab code can get
   // the loaded offline page immediately.
   OfflinePageTabHelper* tab_helper =
       OfflinePageTabHelper::FromWebContents(web_contents);
   DCHECK(tab_helper);
   tab_helper->SetOfflinePage(
-      *offline_page, network_state == NetworkState::PROHIBITIVELY_SLOW_NETWORK);
+      *offline_page,
+      offline_header,
+      network_state == NetworkState::PROHIBITIVELY_SLOW_NETWORK);
 
   *offline_file_path = offline_page->file_path;
   return RequestResult::OFFLINE_PAGE_SERVED;
 }
 
 // Handles the result of finding an offline page.
 void SucceededToFindOfflinePage(
+    const OfflinePageHeader& offline_header,
     NetworkState network_state,
     base::WeakPtr<OfflinePageRequestJob> job,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     const OfflinePageItem* offline_page) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   base::FilePath offline_file_path;
   RequestResult request_result = AccessOfflineFile(
-      network_state, job, web_contents_getter, offline_page,
+      offline_header, network_state, job, web_contents_getter, offline_page,
       &offline_file_path);
 
   ReportRequestResult(request_result, network_state);
 
   // NotifyOfflineFilePathOnUI should always be called regardless the failure
   // result and empty file path such that OfflinePageRequestJob will be notified
   // on failure.
   NotifyOfflineFilePathOnUI(job, offline_file_path);
 }
 
 void FailedToFindOfflinePage(base::WeakPtr<OfflinePageRequestJob> job) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Proceed with empty file path in order to notify the OfflinePageRequestJob
   // about the failure.
   base::FilePath empty_file_path;
   NotifyOfflineFilePathOnUI(job, empty_file_path);
 }
 
 // Tries to find the offline page to serve for |online_url|.
 void SelectPageForOnlineURL(
     const GURL& online_url,
+    const OfflinePageHeader& offline_header,
     NetworkState network_state,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     OfflinePageRequestJob::Delegate::TabIdGetter tab_id_getter,
     base::WeakPtr<OfflinePageRequestJob> job) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   content::WebContents* web_contents = web_contents_getter.Run();
   if (!web_contents){
     ReportRequestResult(RequestResult::NO_WEB_CONTENTS, network_state);
     FailedToFindOfflinePage(job);
     return;
   }
   int tab_id;
   if (!tab_id_getter.Run(web_contents, &tab_id)) {
     ReportRequestResult(RequestResult::NO_TAB_ID, network_state);
     FailedToFindOfflinePage(job);
     return;
   }
 
   OfflinePageUtils::SelectPageForOnlineURL(
       web_contents->GetBrowserContext(),
       online_url,
       tab_id,
       base::Bind(&SucceededToFindOfflinePage,
+                 offline_header,
                  network_state,
                  job,
                  web_contents_getter));
 }
 
 void FindPageWithOfflineIDDone(
     const GURL& online_url,
+    const OfflinePageHeader& offline_header,
     NetworkState network_state,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     OfflinePageRequestJob::Delegate::TabIdGetter tab_id_getter,
     base::WeakPtr<OfflinePageRequestJob> job,
     const OfflinePageItem* offline_page) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // If the found offline page does not has same URL as the request URL, fall
   // back to find the offline page based on the URL.
   if (!offline_page || offline_page->url != online_url) {
     SelectPageForOnlineURL(
-        online_url, network_state, web_contents_getter, tab_id_getter, job);
+        online_url, offline_header, network_state, web_contents_getter,
+        tab_id_getter, job);
     return;
   }
 
   SucceededToFindOfflinePage(
-      network_state, job, web_contents_getter, offline_page);
+      offline_header, network_state, job, web_contents_getter, offline_page);
 }
 
 // Tries to find an offline page associated with |offline_id|.
 void FindPageWithOfflineID(
     const GURL& online_url,
+    const OfflinePageHeader& offline_header,
     int64_t offline_id,
     NetworkState network_state,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     OfflinePageRequestJob::Delegate::TabIdGetter tab_id_getter,
     base::WeakPtr<OfflinePageRequestJob> job) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   OfflinePageModel* offline_page_model =
       GetOfflinePageModel(web_contents_getter);
   if (!offline_page_model) {
     FailedToFindOfflinePage(job);
     return;
   }
 
   offline_page_model->GetPageByOfflineId(
       offline_id,
       base::Bind(&FindPageWithOfflineIDDone,
                  online_url,
+                 offline_header,
                  network_state,
                  web_contents_getter,
                  tab_id_getter,
                  job));
 }
 
 // Tries to find the offline page to serve for |online_url|.
 void SelectPage(
     const GURL& online_url,
-    const std::string& offline_header_string,
+    const OfflinePageHeader& offline_header,
     NetworkState network_state,
     content::ResourceRequestInfo::WebContentsGetter web_contents_getter,
     OfflinePageRequestJob::Delegate::TabIdGetter tab_id_getter,
     base::WeakPtr<OfflinePageRequestJob> job) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  OfflinePageHeader offline_header(offline_header_string);
-
   // If an offline ID is present in the offline header, try to load that
   // particular version.
-  if (!offline_header.id().empty()) {
+  if (!offline_header.id.empty()) {
     // if the id string cannot be converted to int64 id, fall through to
     // select page via online URL.
     int64_t offline_id;
-    if (base::StringToInt64(offline_header.id(), &offline_id)) {
-      FindPageWithOfflineID(online_url, offline_id, network_state,
-                            web_contents_getter, tab_id_getter, job);
+    if (base::StringToInt64(offline_header.id, &offline_id)) {
+      FindPageWithOfflineID(online_url, offline_header, offline_id,
+                            network_state, web_contents_getter, tab_id_getter,
+                            job);
       return;
     }
   }
 
-  SelectPageForOnlineURL(online_url, network_state, web_contents_getter,
-                         tab_id_getter, job);
+  SelectPageForOnlineURL(online_url, offline_header, network_state,
+                         web_contents_getter, tab_id_getter, job);
 }
 
 }  // namespace
 
 // static
 void OfflinePageRequestJob::ReportAggregatedRequestResult(
     AggregatedRequestResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.AggregatedRequestResult",
       static_cast<int>(result),
       static_cast<int>(AggregatedRequestResult::AGGREGATED_REQUEST_RESULT_MAX));
@@ skipping 53 matching lines @@
 OfflinePageRequestJob::~OfflinePageRequestJob() {
 }
 
 void OfflinePageRequestJob::Start() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&OfflinePageRequestJob::StartAsync,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageRequestJob::StartAsync() {
-  NetworkState network_state = GetNetworkState(request());
+  std::string offline_header_value;
+  request()->extra_request_headers().GetHeader(
+      kOfflinePageHeader, &offline_header_value);
+  // Note that |offline_header| will be empty if parsing from the header value
+  // fails.
+  OfflinePageHeader offline_header(offline_header_value);
+
+  NetworkState network_state = GetNetworkState(request(), offline_header);
   if (network_state == NetworkState::CONNECTED_NETWORK) {
     FallbackToDefault();
     return;
   }
 
-  std::string offline_header_string;
-  request()->extra_request_headers().GetHeader(kOfflinePageHeader,
-                                               &offline_header_string);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&SelectPage,
                  request()->url(),
-                 offline_header_string,
+                 offline_header,
                  network_state,
                  delegate_->GetWebContentsGetter(request()),
                  delegate_->GetTabIdGetter(),
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageRequestJob::Kill() {
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
@@ skipping 20 matching lines @@
   file_path_ = offline_file_path;
   URLRequestFileJob::Start();
 }
 
 void OfflinePageRequestJob::SetDelegateForTesting(
     std::unique_ptr<Delegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
 }  // namespace offline_pages