Support getting offline pages also by original URL

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"
@@ skipping 200 matching lines @@
 
 void NotifyOfflineFilePathOnIO(base::WeakPtr<OfflinePageRequestJob> job,
                                const base::FilePath& offline_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (!job)
     return;
   job->OnOfflineFilePathAvailable(offline_file_path);
 }
 
+void NotifyOfflineRedirectOnIO(base::WeakPtr<OfflinePageRequestJob> job,
+                               const GURL& redirected_url) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  if (!job)
+    return;
+  job->OnOfflineRedirectAvailabe(redirected_url);
+}
+
 // Notifies OfflinePageRequestJob about the offline file path. Note that the
 // file path may be empty if not found or on error.
 void NotifyOfflineFilePathOnUI(base::WeakPtr<OfflinePageRequestJob> job,
                                const base::FilePath& offline_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Delegates to IO thread since OfflinePageRequestJob should only be accessed
   // from IO thread.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&NotifyOfflineFilePathOnIO, job, offline_file_path));
 }
 
+// Notifies OfflinePageRequestJob about the redirected URL. Note that
+// redirected_url should not be empty.
+void NotifyOfflineRedirectOnUI(base::WeakPtr<OfflinePageRequestJob> job,
+                               const GURL& redirected_url) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(!redirected_url.is_empty());
+
+  // Delegates to IO thread since OfflinePageRequestJob should only be accessed
+  // from IO thread.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NotifyOfflineRedirectOnIO, job, redirected_url));
+}
+
 // 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);
@@ skipping 34 matching lines @@
       *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 GURL& url,
     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);
 
+  // If the match is for original URL, trigger the redirect.
+  if (offline_page && url == offline_page->original_url) {
+    NotifyOfflineRedirectOnUI(job, offline_page->url);
+    return;
+  }
+
   base::FilePath offline_file_path;
   RequestResult request_result = AccessOfflineFile(
       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,
+// Tries to find the offline page to serve for |url|.
+void SelectPageForURL(
+    const GURL& 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(
+  OfflinePageUtils::SelectPageForURL(
       web_contents->GetBrowserContext(),
-      online_url,
+      url,
+      OfflinePageModel::URLSearchMode::SEARCH_BY_ALL_URLS,
       tab_id,
       base::Bind(&SucceededToFindOfflinePage,
+                 url,
                  offline_header,
                  network_state,
                  job,
                  web_contents_getter));
 }
 
 void FindPageWithOfflineIDDone(
-    const GURL& online_url,
+    const GURL& 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, offline_header, network_state, web_contents_getter,
+  if (!offline_page || offline_page->url != url) {
+    SelectPageForURL(
+        url, offline_header, network_state, web_contents_getter,
         tab_id_getter, job);
     return;
   }
 
   SucceededToFindOfflinePage(
-      offline_header, network_state, job, web_contents_getter, offline_page);
+      url, 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 GURL& 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,
+                 url,
                  offline_header,
                  network_state,
                  web_contents_getter,
                  tab_id_getter,
                  job));
 }
 
-// Tries to find the offline page to serve for |online_url|.
+// Tries to find the offline page to serve for |url|.
 void SelectPage(
-    const GURL& online_url,
+    const GURL& 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);
 
   // If an offline ID is present in the offline header, try to load that
   // particular version.
   if (!offline_header.id.empty()) {
     // if the id string cannot be converted to int64 id, fall through to
-    // select page via online URL.
+    // select page via URL.
     int64_t offline_id;
     if (base::StringToInt64(offline_header.id, &offline_id)) {
-      FindPageWithOfflineID(online_url, offline_header, offline_id,
+      FindPageWithOfflineID(url, offline_header, offline_id,
                             network_state, web_contents_getter, tab_id_getter,
                             job);
       return;
     }
   }
 
-  SelectPageForOnlineURL(online_url, offline_header, network_state,
-                         web_contents_getter, tab_id_getter, job);
+  SelectPageForURL(url, offline_header, network_state, web_contents_getter,
+                   tab_id_getter, job);
 }
 
 }  // namespace
 
 // static
 void OfflinePageRequestJob::ReportAggregatedRequestResult(
     AggregatedRequestResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.AggregatedRequestResult2",
       static_cast<int>(result),
       static_cast<int>(AggregatedRequestResult::AGGREGATED_REQUEST_RESULT_MAX));
@@ skipping 109 matching lines @@
   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();
+}
+
 void OfflinePageRequestJob::SetDelegateForTesting(
     std::unique_ptr<Delegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
 }  // namespace offline_pages