Use the previews black list for offline previews

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_experiments.h"
+#include "components/previews/core/previews_decider.h"
+#include "components/previews/core/previews_opt_out_store.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 {
 
 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.
+  // This requires offline previews to be enabled and the URL of the request to
+  // be allowed by previews.
   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.
   FLAKY_NETWORK,
   // Network is in working condition.
   CONNECTED_NETWORK,
   // Force to load the offline page if it is available, though network is in
   // working condition.
   FORCE_OFFLINE_ON_CONNECTED_NETWORK
 };
@@ skipping 49 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);
 };
 
-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,
-                             const OfflinePageHeader& offline_header) {
+                             const OfflinePageHeader& offline_header,
+                             previews::PreviewsDecider* previews_decider) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (offline_header.reason == OfflinePageHeader::Reason::NET_ERROR)
     return NetworkState::FLAKY_NETWORK;
 
   if (net::NetworkChangeNotifier::IsOffline())
     return NetworkState::DISCONNECTED_NETWORK;
-
-  if (IsNetworkProhibitivelySlow(request))
+  // Checks if previews are allowed, the network is slow, and the request is
+  // allowed to be shown for previews.
+  if (previews_decider &&
+      previews_decider->ShouldAllowPreview(*request,
+                                           previews::PreviewsType::OFFLINE)) {
     return NetworkState::PROHIBITIVELY_SLOW_NETWORK;
+  }
 
   // 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
@@ skipping 296 matching lines @@
 void OfflinePageRequestJob::ReportAggregatedRequestResult(
     AggregatedRequestResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.AggregatedRequestResult",
       static_cast<int>(result),
       static_cast<int>(AggregatedRequestResult::AGGREGATED_REQUEST_RESULT_MAX));
 }
 
 // static
 OfflinePageRequestJob* OfflinePageRequestJob::Create(
     net::URLRequest* request,
-    net::NetworkDelegate* network_delegate) {
+    net::NetworkDelegate* network_delegate,
+    previews::PreviewsDecider* previews_decider) {
   const content::ResourceRequestInfo* resource_request_info =
       content::ResourceRequestInfo::ForRequest(request);
   if (!resource_request_info)
     return nullptr;
 
   // Ignore the requests not for the main resource.
   if (resource_request_info->GetResourceType() !=
       content::RESOURCE_TYPE_MAIN_FRAME) {
     return nullptr;
   }
@@ skipping 10 matching lines @@
       OfflinePageRequestInfo::GetFromRequest(request);
   if (info) {
     // Fall back to default which is set when an offline page cannot be served,
     // either page not found or online version desired.
     if (info->use_default())
       return nullptr;
   } else {
     request->SetUserData(&kUserDataKey, new OfflinePageRequestInfo());
   }
 
-  return new OfflinePageRequestJob(request, network_delegate);
+  return new OfflinePageRequestJob(request, network_delegate, previews_decider);
 }
 
 OfflinePageRequestJob::OfflinePageRequestJob(
     net::URLRequest* request,
-    net::NetworkDelegate* network_delegate)
+    net::NetworkDelegate* network_delegate,
+    previews::PreviewsDecider* previews_decider)
     : net::URLRequestFileJob(
           request,
           network_delegate,
           base::FilePath(),
-          content::BrowserThread::GetBlockingPool()->
-              GetTaskRunnerWithShutdownBehavior(
+          content::BrowserThread::GetBlockingPool()
+              ->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
       delegate_(new DefaultDelegate()),
-      weak_ptr_factory_(this) {
-}
+      previews_decider_(previews_decider),
+      weak_ptr_factory_(this) {}
 
 OfflinePageRequestJob::~OfflinePageRequestJob() {
 }
 
 void OfflinePageRequestJob::Start() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&OfflinePageRequestJob::StartAsync,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageRequestJob::StartAsync() {
   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);
+  NetworkState network_state =
+      GetNetworkState(request(), offline_header, previews_decider_);
   if (network_state == NetworkState::CONNECTED_NETWORK) {
     FallbackToDefault();
     return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&SelectPage,
                  request()->url(),
@@ skipping 31 matching lines @@
   file_path_ = offline_file_path;
   URLRequestFileJob::Start();
 }
 
 void OfflinePageRequestJob::SetDelegateForTesting(
     std::unique_ptr<Delegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
 }  // namespace offline_pages