Provide a way to specify in Finch trials to disable prerender local

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2012 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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
+#include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor_factory.h"
 #include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_link_manager_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_handlers/mime_types_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "components/variations/entropy_provider.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 12 matching lines @@
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
+using chrome_browser_net::NetworkPredictionOptions;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::TestNavigationObserver;
 using content::WebContents;
 using content::WebContentsObserver;
+using net::NetworkChangeNotifier;
 using task_manager::browsertest_util::WaitForTaskManagerRows;
 
 // Prerender tests work as follows:
 //
 // A page with a prefetch link to the test page is loaded.  Once prerendered,
 // its Javascript function DidPrerenderPass() is called, which returns true if
 // the page behaves as expected when prerendered.
 //
 // The prerendered page is then displayed on a tab.  The Javascript function
 // DidDisplayPass() is called, and returns true if the page behaved as it
 // should while being displayed.
 
 namespace prerender {
 
 namespace {
 
+class MockNetworkChangeNotifierWIFI : public NetworkChangeNotifier {
+ public:
+  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+    return NetworkChangeNotifier::CONNECTION_WIFI;
+  }
+};
+
+class MockNetworkChangeNotifier4G : public NetworkChangeNotifier {
+ public:
+  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+    return NetworkChangeNotifier::CONNECTION_4G;
+  }
+};
+
 // Constants used in the test HTML files.
 const char* kReadyTitle = "READY";
 const char* kPassTitle = "PASS";
 
 std::string CreateClientRedirect(const std::string& dest_url) {
   const char* const kClientRedirectBase = "client-redirect?";
   return kClientRedirectBase + net::EscapeQueryParamValue(dest_url, false);
 }
 
 std::string CreateServerRedirect(const std::string& dest_url) {
@@ skipping 925 matching lines @@
     // explicitly registered.
     base::FilePath app_dir;
     PathService::Get(chrome::DIR_APP, &app_dir);
     command_line->AppendSwitchPath(
         switches::kExtraPluginDir,
         app_dir.Append(FILE_PATH_LITERAL("plugins")));
 #endif
     command_line->AppendSwitch(switches::kAlwaysAuthorizePlugins);
   }
 
+  void SetPreference(NetworkPredictionOptions value) {
+    browser()->profile()->GetPrefs()->SetInteger(
+        prefs::kNetworkPredictionOptions, value);
+  }
+
+  void CreateTestFieldTrial(const std::string& name,
+                            const std::string& group_name) {
+    base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
+        name, group_name);
+    trial->group();
+  }
+
+  // Verifies, for the current field trial, whether
+  // ShouldDisableLocalPredictorDueToPreferencesAndNetwork produces the desired
+  // output.
+  void TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
+      bool preference_wifi_network_wifi,
+      bool preference_wifi_network_4g,
+      bool preference_always_network_wifi,
+      bool preference_always_network_4g,
+      bool preference_never_network_wifi,
+      bool preference_never_network_4g) {
+    Profile* profile = browser()->profile();
+
+    // Set real NetworkChangeNotifier singleton aside.
+    scoped_ptr<NetworkChangeNotifier::DisableForTest> disable_for_test(
+        new NetworkChangeNotifier::DisableForTest);
+
+    // Set preference to WIFI_ONLY: prefetch when not on cellular.
+    SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_WIFI_ONLY);
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_wifi_network_wifi);
+    }
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_wifi_network_4g);
+    }
+
+    // Set preference to ALWAYS: always prefetch.
+    SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_ALWAYS);
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_always_network_wifi);
+    }
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_always_network_4g);
+    }
+
+    // Set preference to NEVER: never prefetch.
+    SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_NEVER);
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_never_network_wifi);
+    }
+    {
+      scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
+      EXPECT_EQ(
+          ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
+          preference_never_network_4g);
+    }
+  }
+
   virtual void SetUpOnMainThread() OVERRIDE {
     current_browser()->profile()->GetPrefs()->SetBoolean(
         prefs::kPromptForDownload, false);
     IncreasePrerenderMemory();
     if (autostart_test_server_)
       ASSERT_TRUE(test_server()->Start());
     ChromeResourceDispatcherHostDelegate::
         SetExternalProtocolHandlerDelegateForTesting(
             &external_protocol_handler_delegate_);
 
@@ skipping 579 matching lines @@
   NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
   GURL dest_url_;
   scoped_ptr<net::SpawnedTestServer> https_src_server_;
   bool call_javascript_;
   bool check_load_events_;
   std::string loader_host_override_;
   std::string loader_path_;
   std::string loader_query_;
   Browser* explicitly_set_browser_;
   base::HistogramTester histogram_tester_;
+  scoped_ptr<base::FieldTrialList> field_trial_list_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
@@ skipping 2764 matching lines @@
   prerender->contents()->set_skip_final_checks(true);
 
   // Navigate to the URL entered.
   omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
 
   // Prerender should be running, but abandoned.
   EXPECT_TRUE(
       GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
 }
 
+// Prefetch should be allowed depending on preference and network type.
+// This test is for the bsae case: no Finch overrides should never disable.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       LocalPredictorDisableWorksBaseCase) {
+  TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
+      false /*preference_wifi_network_wifi*/,
+      false /*preference_wifi_network_4g*/,
+      false /*preference_always_network_wifi*/,
+      false /*preference_always_network_4g*/,
+      false /*preference_never_network_wifi*/,
+      false /*preference_never_network_4g*/);
+}
+
+// Prefetch should be allowed depending on preference and network type.
+// LocalPredictorOnCellularOnly should disable all wifi cases.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       LocalPredictorDisableWorksCellularOnly) {
+  CreateTestFieldTrial("PrerenderLocalPredictorSpec",
+                       "LocalPredictorOnCellularOnly=Enabled");
+  TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
+      true /*preference_wifi_network_wifi*/,
+      false /*preference_wifi_network_4g*/,
+      true /*preference_always_network_wifi*/,
+      false /*preference_always_network_4g*/,
+      true /*preference_never_network_wifi*/,
+      false /*preference_never_network_4g*/);
+}
+
+// Prefetch should be allowed depending on preference and network type.
+// LocalPredictorNetworkPredictionEnabledOnly should disable whenever
+// network predictions will not be exercised.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       LocalPredictorDisableWorksNetworkPredictionEnableOnly) {
+  CreateTestFieldTrial("PrerenderLocalPredictorSpec",
+                       "LocalPredictorNetworkPredictionEnabledOnly=Enabled");
+  TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
+      false /*preference_wifi_network_wifi*/,
+      true /*preference_wifi_network_4g*/,
+      false /*preference_always_network_wifi*/,
+      false /*preference_always_network_4g*/,
+      true /*preference_never_network_wifi*/,
+      true /*preference_never_network_4g*/);
+}
+
+// Prefetch should be allowed depending on preference and network type.
+// If LocalPredictorNetworkPredictionEnabledOnly and
+// LocalPredictorOnCellularOnly are both selected, we must disable whenever
+// network predictions are not exercised, or when we are on wifi.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       LocalPredictorDisableWorksBothOptions) {
+  CreateTestFieldTrial("PrerenderLocalPredictorSpec",
+                       "LocalPredictorOnCellularOnly=Enabled:"
+                       "LocalPredictorNetworkPredictionEnabledOnly=Enabled");
+  TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
+      true /*preference_wifi_network_wifi*/,
+      true /*preference_wifi_network_4g*/,
+      true /*preference_always_network_wifi*/,
+      false /*preference_always_network_4g*/,
+      true /*preference_never_network_wifi*/,
+      true /*preference_never_network_4g*/);
+}
+
 }  // namespace prerender