Make GetBestPageForOnlineURL async

chrome/browser/android/offline_pages/offline_page_tab_helper.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_tab_helper.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/offline_page_utils.h"
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/offline_pages/client_namespace_constants.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "components/previews/previews_experiments.h"
@@ skipping 36 matching lines @@
       nqe_service->GetEffectiveConnectionType();
   return effective_connection_type >= net::EFFECTIVE_CONNECTION_TYPE_OFFLINE &&
          effective_connection_type <= net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G;
 }
 
 class DefaultDelegate : public OfflinePageTabHelper::Delegate {
  public:
   DefaultDelegate() {}
   // offline_pages::OfflinePageTabHelper::Delegate implementation:
   bool GetTabId(content::WebContents* web_contents,
-                std::string* tab_id) const override {
-    int temp_tab_id;
-    if (!OfflinePageUtils::GetTabId(web_contents, &temp_tab_id))
-      return false;
-    *tab_id = base::IntToString(temp_tab_id);
-    return true;
+                int* tab_id) const override {
+    return OfflinePageUtils::GetTabId(web_contents, tab_id);
   }
   base::Time Now() const override { return base::Time::Now(); }
 };
 }  // namespace
 
 OfflinePageTabHelper::OfflinePageTabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       delegate_(new DefaultDelegate()),
       weak_ptr_factory_(this) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 28 matching lines @@
   // TODO(dimich): Not sure this is needed. Clarify and remove. Bug 624216.
   const content::NavigationController& controller =
       web_contents()->GetController();
   if (controller.GetEntryCount() > 0 &&
       controller.GetCurrentEntryIndex() != -1 &&
       controller.GetCurrentEntryIndex() < controller.GetEntryCount() - 1) {
     return;
   }
 
   if (net::NetworkChangeNotifier::IsOffline()) {
-    GetPagesForRedirectToOffline(
+    GetBestPageForRedirectToOffline(
         RedirectResult::REDIRECTED_ON_DISCONNECTED_NETWORK, navigated_url);
     return;
   }
 
   content::BrowserContext* context = web_contents()->GetBrowserContext();
   if (ShouldUseOfflineForSlowNetwork(context)) {
-    GetPagesForRedirectToOffline(
+    GetBestPageForRedirectToOffline(
         RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK,
         navigated_url);
     return;
   }
 
   OfflinePageModel* offline_page_model =
       OfflinePageModelFactory::GetForBrowserContext(context);
   if (!offline_page_model)
     return;
 
@@ skipping 38 matching lines @@
 
   // Don't actually want to redirect on a forward/back nav.
   // TODO(dimich): Clarify and possibly redirect as well. Bug 624216.
   if (ui::PageTransitionTypeIncludingQualifiersIs(
           navigation_handle->GetPageTransition(),
           ui::PAGE_TRANSITION_FORWARD_BACK)) {
     ReportRedirectResultUMA(RedirectResult::IGNORED_FLAKY_NETWORK_FORWARD_BACK);
     return;
   }
 
-  GetPagesForRedirectToOffline(
+  GetBestPageForRedirectToOffline(
       RedirectResult::REDIRECTED_ON_FLAKY_NETWORK, navigated_url);
 }
 
 void OfflinePageTabHelper::RedirectToOnline(
     const GURL& navigated_url,
     const OfflinePageItem* offline_page) {
   // Bails out if no redirection is needed. No UMA reporting since all regular
   // navigations will be here and it'll dwarf the useful reporting.
   if (!offline_page)
     return;
 
   GURL redirect_url = offline_page->url;
   if (IsInRedirectLoop(redirect_url)) {
     ReportRedirectResultUMA(RedirectResult::REDIRECT_LOOP_ONLINE);
     return;
   }
 
   Redirect(navigated_url, redirect_url);
   // Clear the offline page since we are redirecting to online.
   offline_page_ = nullptr;
 
   ReportRedirectResultUMA(RedirectResult::REDIRECTED_ON_CONNECTED_NETWORK);
 }
 
-void OfflinePageTabHelper::GetPagesForRedirectToOffline(
+void OfflinePageTabHelper::GetBestPageForRedirectToOffline(
     RedirectResult result, const GURL& online_url) {
-  OfflinePageModel* offline_page_model =
-      OfflinePageModelFactory::GetForBrowserContext(
-          web_contents()->GetBrowserContext());
-  if (!offline_page_model)
-    return;
-
-  offline_page_model->GetPagesByOnlineURL(
-      online_url,
-      base::Bind(&OfflinePageTabHelper::SelectBestPageForRedirectToOffline,
-                 weak_ptr_factory_.GetWeakPtr(), result, online_url));
-}
-
-void OfflinePageTabHelper::SelectBestPageForRedirectToOffline(
-    RedirectResult result,
-    const GURL& online_url,
-    const MultipleOfflinePageItemResult& pages) {
-  DCHECK(result == RedirectResult::REDIRECTED_ON_FLAKY_NETWORK ||
-         result == RedirectResult::REDIRECTED_ON_DISCONNECTED_NETWORK ||
-         result == RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK);
-
   // When there is no valid tab android there is nowhere to show the offline
   // page, so we can leave.
-  std::string tab_id;
+  int tab_id;
   if (!delegate_->GetTabId(web_contents(), &tab_id)) {
     ReportRedirectResultUMA(RedirectResult::NO_TAB_ID);
     return;
   }
 
-  const OfflinePageItem* selected_page = nullptr;
-  for (const auto& offline_page : pages) {
-    if ((offline_page.client_id.name_space == kBookmarkNamespace) ||
-        (offline_page.client_id.name_space == kAsyncNamespace) ||
-        (offline_page.client_id.name_space == kLastNNamespace &&
-         offline_page.client_id.id == tab_id)) {
-      if (!selected_page ||
-          offline_page.creation_time > selected_page->creation_time) {
-        selected_page = &offline_page;
-      }
-    }
-  }
+  OfflinePageUtils::SelectPageForOnlineURL(
+      web_contents()->GetBrowserContext(),
+      online_url,
+      tab_id,
+      base::Bind(&OfflinePageTabHelper::SelectPageForOnlineURLDone,
+                 weak_ptr_factory_.GetWeakPtr(), result, online_url));
+}
 
-  if (!selected_page) {
+void OfflinePageTabHelper::SelectPageForOnlineURLDone(
+    RedirectResult result,
+    const GURL& online_url,
+    const OfflinePageItem* offline_page) {
+  DCHECK(result == RedirectResult::REDIRECTED_ON_FLAKY_NETWORK ||
+         result == RedirectResult::REDIRECTED_ON_DISCONNECTED_NETWORK ||
+         result == RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK);
+
+  if (!offline_page) {
     switch (result) {
       case RedirectResult::REDIRECTED_ON_FLAKY_NETWORK:
         ReportRedirectResultUMA(
             RedirectResult::PAGE_NOT_FOUND_ON_FLAKY_NETWORK);
         return;
       case RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK:
         ReportRedirectResultUMA(
             RedirectResult::PAGE_NOT_FOUND_ON_PROHIBITIVELY_SLOW_NETWORK);
         return;
       case RedirectResult::REDIRECTED_ON_DISCONNECTED_NETWORK:
         ReportRedirectResultUMA(
             RedirectResult::PAGE_NOT_FOUND_ON_DISCONNECTED_NETWORK);
         return;
       default:
         NOTREACHED();
         return;
     }
   }
 
   // If the page is being loaded on a slow network, only use the offline page
   // if it was created within the past 7 days.
   if (result == RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK &&
-      delegate_->Now() - selected_page->creation_time >
+      delegate_->Now() - offline_page->creation_time >
           base::TimeDelta::FromDays(7)) {
     ReportRedirectResultUMA(
         RedirectResult::PAGE_NOT_FRESH_ON_PROHIBITIVELY_SLOW_NETWORK);
     return;
   }
 
-  TryRedirectToOffline(result, online_url, *selected_page);
+  TryRedirectToOffline(result, online_url, *offline_page);
 }
 
 void OfflinePageTabHelper::TryRedirectToOffline(
     RedirectResult result,
     const GURL& from_url,
     const OfflinePageItem& offline_page) {
   GURL redirect_url = offline_page.GetOfflineURL();
   if (!redirect_url.is_valid())
     return;
 
@@ skipping 24 matching lines @@
          entry->GetRedirectChain().back() == to_url;
 }
 
 void OfflinePageTabHelper::ReportRedirectResultUMA(RedirectResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.RedirectResult",
       static_cast<int>(result),
       static_cast<int>(RedirectResult::REDIRECT_RESULT_MAX));
 }
 
 }  // namespace offline_pages