[Prerender] Remove cellular network checks.

Removes all references to cellular network checks since they're no
longer controlling access to preload/prerender features.

Removes the enum value from NetworkPredictionStatus and
FINAL_STATUS_CELLULAR_NETWORK from prerender final status.

Change-Id: I18d55917579d02f596615743c2736b6173e559c3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2368361Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Commit-Queue: Mugdha Lakhani <nator@chromium.org>
Cr-Commit-Position: refs/heads/master@{#801163}

chrome/browser/flags/android/chrome_feature_list.cc

@@ -86,7 +86,6 @@ const base::Feature* kFeaturesExposedToJava[] = {
     &features::kInstallableAmbientBadgeInfoBar,
     &features::kNetworkServiceInProcess,
     &features::kOverscrollHistoryNavigation,
-    &features::kPredictivePrefetchingAllowedOnAllConnectionTypes,
     &features::kPrivacyElevatedAndroid,
     &features::kPrivacyReorderedAndroid,
     &features::kPrioritizeBootstrapTasks,

chrome/browser/net/prediction_options.cc

@@ -23,13 +23,7 @@ NetworkPredictionStatus CanPrefetchAndPrerender(
   switch (network_prediction_options) {
     case NETWORK_PREDICTION_ALWAYS:
     case NETWORK_PREDICTION_WIFI_ONLY:
-      if (base::FeatureList::IsEnabled(
-              features::kPredictivePrefetchingAllowedOnAllConnectionTypes) ||
-          !net::NetworkChangeNotifier::IsConnectionCellular(
-              net::NetworkChangeNotifier::GetConnectionType())) {
         return NetworkPredictionStatus::ENABLED;
-      }
-      return NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK;
     default:
       DCHECK_EQ(NETWORK_PREDICTION_NEVER, network_prediction_options);
       return NetworkPredictionStatus::DISABLED_ALWAYS;

chrome/browser/net/prediction_options.h

@@ -28,7 +28,6 @@ enum NetworkPredictionOptions {
 enum class NetworkPredictionStatus {
   ENABLED,
   DISABLED_ALWAYS,
-  DISABLED_DUE_TO_NETWORK,
 };
 
 void RegisterPredictionOptionsProfilePrefs(

chrome/browser/prerender/chrome_prerender_manager_delegate.cc

@@ -58,26 +58,16 @@ bool ChromePrerenderManagerDelegate::IsPredictionEnabled(Origin origin) {
          chrome_browser_net::NetworkPredictionStatus::ENABLED;
 }
 
-bool ChromePrerenderManagerDelegate::IsPredictionDisabledDueToNetwork(
-    Origin origin) {
-  return GetPredictionStatusForOrigin(origin) ==
-         chrome_browser_net::NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK;
-}
-
 bool ChromePrerenderManagerDelegate::IsPredictionEnabled() {
   return GetPredictionStatus() ==
          chrome_browser_net::NetworkPredictionStatus::ENABLED;
 }
 
 std::string ChromePrerenderManagerDelegate::GetReasonForDisablingPrediction() {
-  std::string disabled_note;
-  if (GetPredictionStatus() ==
-      chrome_browser_net::NetworkPredictionStatus::DISABLED_ALWAYS)
-    disabled_note = "Disabled by user setting";
-  if (GetPredictionStatus() ==
-      chrome_browser_net::NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK)
-    disabled_note = "Disabled on cellular connection by default";
-  return disabled_note;
+  return (GetPredictionStatus() ==
+          chrome_browser_net::NetworkPredictionStatus::DISABLED_ALWAYS)
+             ? "Disabled by user setting"
+             : "";
 }
 
 chrome_browser_net::NetworkPredictionStatus
@@ -105,11 +95,6 @@ ChromePrerenderManagerDelegate::GetPredictionStatusForOrigin(
   // the DISABLED_ALWAYS selected via privacy settings.
   chrome_browser_net::NetworkPredictionStatus prediction_status =
       chrome_browser_net::CanPrefetchAndPrerenderUI(profile_->GetPrefs());
-  if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER &&
-      prediction_status == chrome_browser_net::NetworkPredictionStatus::
-                               DISABLED_DUE_TO_NETWORK) {
-    return chrome_browser_net::NetworkPredictionStatus::ENABLED;
-  }
   return prediction_status;
 }
 

chrome/browser/prerender/chrome_prerender_manager_delegate.h

@@ -28,7 +28,6 @@ class ChromePrerenderManagerDelegate : public PrerenderManagerDelegate {
       override;
   bool IsPredictionEnabled(Origin origin) override;
   bool IsPredictionEnabled() override;
-  bool IsPredictionDisabledDueToNetwork(Origin origin) override;
   std::string GetReasonForDisablingPrediction() override;
 
  private:

chrome/browser/prerender/prerender_unittest.cc

@@ -1301,37 +1301,11 @@ TEST_F(PrerenderTest, LinkRelAllowedOnCellular) {
   ASSERT_EQ(prerender_contents, entry.get());
 }
 
-// Verify that the external prerender requests are not allowed on cellular
-// connection when kPredictivePrefetchingAllowedOnAllConnectionTypes feature is
-// not enabled.
-TEST_F(PrerenderTest, PrerenderNotAllowedOnCellularWithExternalOrigin) {
-  EnablePrerender();
-  std::unique_ptr<net::NetworkChangeNotifier> mock(
-      new MockNetworkChangeNotifier4G);
-  EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
-      net::NetworkChangeNotifier::GetConnectionType()));
-  GURL url("http://www.google.com/");
-  DummyPrerenderContents* prerender_contents =
-      prerender_manager()->CreateNextPrerenderContents(
-          url, base::nullopt, ORIGIN_EXTERNAL_REQUEST,
-          FINAL_STATUS_PROFILE_DESTROYED);
-  std::unique_ptr<PrerenderHandle> prerender_handle(
-      prerender_manager()->AddPrerenderFromExternalRequest(
-          url, content::Referrer(), nullptr, gfx::Rect(kDefaultViewSize)));
-  EXPECT_TRUE(prerender_handle);
-  EXPECT_TRUE(prerender_contents->prerendering_has_started());
-  histogram_tester().ExpectTotalCount("Prerender.FinalStatus", 0);
-}
-
-// Verify that the external prerender requests are allowed on cellular
-// connection when kPredictivePrefetchingAllowedOnAllConnectionTypes feature is
-// enabled.
+// Verify that the external prerender requests are allowed on cellular networks.
 TEST_F(
     PrerenderTest,
     PrerenderAllowedOnCellularWithExternalOrigin_PredictivePrefetchingAllowedOnAllConnectionTypes) {
   base::test::ScopedFeatureList scoped_feature_list;
-  scoped_feature_list.InitAndEnableFeature(
-      features::kPredictivePrefetchingAllowedOnAllConnectionTypes);
   EnablePrerender();
   std::unique_ptr<net::NetworkChangeNotifier> mock(
       new MockNetworkChangeNotifier4G);

chrome/common/chrome_features.cc

@@ -603,11 +603,6 @@ const base::Feature kPerAppTimeLimits{"PerAppTimeLimits",
 const base::Feature kPluginVm{"PluginVm", base::FEATURE_DISABLED_BY_DEFAULT};
 #endif
 
-// Allows prediction operations (e.g., prefetching) on all connection types.
-const base::Feature kPredictivePrefetchingAllowedOnAllConnectionTypes{
-    "PredictivePrefetchingAllowedOnAllConnectionTypes",
-    base::FEATURE_ENABLED_BY_DEFAULT};
-
 // Allows Chrome to do preconnect when prerender fails.
 const base::Feature kPrerenderFallbackToPreconnect{
     "PrerenderFallbackToPreconnect", base::FEATURE_ENABLED_BY_DEFAULT};

components/prerender/browser/prerender_manager.cc

@@ -542,11 +542,8 @@ PrerenderManager::AddPrerenderWithPreconnectFallback(
   }
 
   if (!delegate_->IsPredictionEnabled(origin)) {
-    FinalStatus final_status =
-        delegate_->IsPredictionDisabledDueToNetwork(origin)
-            ? FINAL_STATUS_CELLULAR_NETWORK
-            : FINAL_STATUS_PRERENDERING_DISABLED;
-    SkipPrerenderContentsAndMaybePreconnect(url, origin, final_status);
+    SkipPrerenderContentsAndMaybePreconnect(url, origin,
+                                            FINAL_STATUS_PRERENDERING_DISABLED);
     return nullptr;
   }
 
@@ -957,7 +954,6 @@ void PrerenderManager::SkipPrerenderContentsAndMaybePreconnect(
   }
 
   if (final_status == FINAL_STATUS_LOW_END_DEVICE ||
-      final_status == FINAL_STATUS_CELLULAR_NETWORK ||
       final_status == FINAL_STATUS_DUPLICATE ||
       final_status == FINAL_STATUS_TOO_MANY_PROCESSES) {
     MaybePreconnect(origin, url);

components/prerender/browser/prerender_manager_delegate.cc

@@ -18,10 +18,6 @@ bool PrerenderManagerDelegate::IsPredictionEnabled() {
   return true;
 }
 
-bool PrerenderManagerDelegate::IsPredictionDisabledDueToNetwork(Origin origin) {
-  return false;
-}
-
 std::string PrerenderManagerDelegate::GetReasonForDisablingPrediction() {
   return std::string();
 }

components/prerender/browser/prerender_manager_delegate.h

@@ -40,9 +40,6 @@ class PrerenderManagerDelegate {
   // Check whether predictive loading of web pages is enabled.
   virtual bool IsPredictionEnabled();
 
-  // Check whether predictive loading of web pages is disabled due to network.
-  virtual bool IsPredictionDisabledDueToNetwork(Origin origin);
-
   // Gets the reason why predictive loading of web pages was disabld.
   virtual std::string GetReasonForDisablingPrediction();
 };

components/prerender/common/prerender_final_status.h

@@ -70,7 +70,7 @@ enum FinalStatus {
   // Obsolete: FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE = 50,
   FINAL_STATUS_NAVIGATION_INTERCEPTED = 51,
   FINAL_STATUS_PRERENDERING_DISABLED = 52,
-  FINAL_STATUS_CELLULAR_NETWORK = 53,
+  // Obsolete: FINAL_STATUS_CELLULAR_NETWORK = 53,
   FINAL_STATUS_BLOCK_THIRD_PARTY_COOKIES = 54,
   // Obsolete: FINAL_STATUS_CREDENTIAL_MANAGER_API = 55,
   FINAL_STATUS_NOSTATE_PREFETCH_FINISHED = 56,