Update prerender policy for custom tabs

chrome/browser/prerender/prerender_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
@@ skipping 14 matching lines @@
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/prerender_types.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_browser_thread.h"
+#include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::Referrer;
 
@@ skipping 175 matching lines @@
                                      PrerenderContents* prerender_contents) {
     prerender_contents_map_[std::make_pair(child_id, route_id)] =
         prerender_contents;
   }
 
   void DummyPrerenderContentsDestroyed(int child_id,
                                        int route_id) {
     prerender_contents_map_.erase(std::make_pair(child_id, route_id));
   }
 
+

[pasko, 2016/03/21 12:00:58]

nit: don't we use only one vertical whitespace in this case

[Yusuf, 2016/03/21 16:59:56]

Done.

  private:
   void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) {
     CHECK(!next_prerender_contents_.get());
     next_prerender_contents_.reset(prerender_contents);
     if (prerender_contents->expected_final_status() == FINAL_STATUS_USED)
       used_prerender_contents_.push_back(prerender_contents);
   }
 
   PrerenderContents* CreatePrerenderContents(const GURL& url,
                                              const Referrer& referrer,
                                              Origin origin) override {
     CHECK(next_prerender_contents_.get());
     EXPECT_EQ(url, next_prerender_contents_->prerender_url());
     EXPECT_EQ(origin, next_prerender_contents_->origin());
     return next_prerender_contents_.release();
   }
 
   // Maintain a map from route pairs to PrerenderContents for
   // GetPrerenderContentsForRoute.
   typedef std::map<std::pair<int,int>, PrerenderContents*> PrerenderContentsMap;
   PrerenderContentsMap prerender_contents_map_;
 
   Time time_;
   TimeTicks time_ticks_;
+
   scoped_ptr<PrerenderContents> next_prerender_contents_;
   // PrerenderContents with an |expected_final_status| of FINAL_STATUS_USED,
   // tracked so they will be automatically deleted.
   ScopedVector<PrerenderContents> used_prerender_contents_;
 };
 
 class RestorePrerenderMode {
  public:
   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
   }
 
   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
  private:
   PrerenderManager::PrerenderManagerMode prev_mode_;
 };
 
+class MockNetworkChangeNotifier4G : public net::NetworkChangeNotifier {
+ public:
+  ConnectionType GetCurrentConnectionType() const override {
+    return NetworkChangeNotifier::CONNECTION_4G;
+  }
+};
+
 DummyPrerenderContents::DummyPrerenderContents(
     UnitTestPrerenderManager* test_prerender_manager,
     const GURL& url,
     Origin origin,
     FinalStatus expected_final_status)
     : PrerenderContents(test_prerender_manager,
                         NULL, url, Referrer(), origin),
       route_id_(g_next_route_id_++),
       test_prerender_manager_(test_prerender_manager),
       expected_final_status_(expected_final_status) {
@@ skipping 95 matching lines @@
         content::Referrer(), kSize, kDefaultRenderViewRouteId);
     return LauncherHasRunningPrerender(kDefaultChildId, last_prerender_id());
   }
 
   void DisablePrerender() {
     profile_.GetPrefs()->SetInteger(
         prefs::kNetworkPredictionOptions,
         chrome_browser_net::NETWORK_PREDICTION_NEVER);
   }
 
+  void EnablePrerender() {
+    profile_.GetPrefs()->SetInteger(
+        prefs::kNetworkPredictionOptions,
+        chrome_browser_net::NETWORK_PREDICTION_WIFI_ONLY);

[pasko, 2016/03/21 12:00:58]

since NETWORK_PREDICTION_WIFI_ONLY is deprecated, can NETWORK_PREDICTION_ALWAYS
be used here instead?

[Yusuf, 2016/03/21 16:59:56]

Done.

+  }
+
  private:
   // Needed to pass PrerenderManager's DCHECKs.
   base::MessageLoop message_loop_;
   TestingProfile profile_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<UnitTestPrerenderManager> prerender_manager_;
   scoped_ptr<PrerenderLinkManager> prerender_link_manager_;
   int last_prerender_id_;
   base::FieldTrialList field_trial_list_;
 };
@@ skipping 656 matching lines @@
   EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox(
       GURL("http://www.example.com"), NULL, gfx::Size()));
 }
 
 TEST_F(PrerenderTest, LinkRelNotAllowedWhenDisabled) {
   DisablePrerender();
   EXPECT_FALSE(AddSimplePrerender(
       GURL("http://www.example.com")));
 }
 
+TEST_F(PrerenderTest,PrerenderNotAllowedOnCellular) {

[pasko, 2016/03/21 12:00:58]

nit: s/,/, /
same below

[Yusuf, 2016/03/21 16:59:57]

Done.

[pasko, 2016/03/31 15:30:44]

Thank you. I just noticed it was not done for tests below. I think I should have
explicitly said something "also below"...

+  EnablePrerender();
+  scoped_ptr<net::NetworkChangeNotifier> mock(
+      new MockNetworkChangeNotifier4G);
+  EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
+      net::NetworkChangeNotifier::GetConnectionType()));
+  EXPECT_FALSE(AddSimplePrerender(
+      GURL("http://www.example.com")));
+}
+
+TEST_F(PrerenderTest,PrerenderNotAllowedOnCellularWithExternalOrigin) {
+  EnablePrerender();
+  scoped_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,
+          ORIGIN_EXTERNAL_REQUEST,
+          FINAL_STATUS_MANAGER_SHUTDOWN);
+  scoped_ptr<PrerenderHandle> prerender_handle(
+      prerender_manager()->AddPrerenderFromExternalRequest(
+          url, content::Referrer(), NULL, kSize));
+  CHECK(!prerender_handle.get());
+  EXPECT_FALSE(prerender_contents->prerendering_has_started());
+}
+
+TEST_F(PrerenderTest,PrerenderAllowedOnCellularWithForcedOrigin) {
+  EnablePrerender();
+  scoped_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,
+          ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
+          FINAL_STATUS_USED);
+  scoped_ptr<PrerenderHandle> prerender_handle(
+      prerender_manager()->AddPrerenderOnCellularFromExternalRequest(
+          url, content::Referrer(), NULL, kSize));
+  CHECK(prerender_handle.get());
+  EXPECT_TRUE(prerender_handle->IsPrerendering());
+  EXPECT_TRUE(prerender_contents->prerendering_has_started());
+  EXPECT_EQ(prerender_contents, prerender_handle->contents());
+  EXPECT_EQ(ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
+      prerender_handle->contents()->origin());
+  ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
+}
+
 TEST_F(PrerenderTest, LinkManagerCancel) {
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   GURL url("http://www.myexample.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_CANCELLED);
 
   EXPECT_TRUE(AddSimplePrerender(url));
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
@@ skipping 508 matching lines @@
   CHECK(prerender_handle.get());
   EXPECT_TRUE(prerender_handle->IsPrerendering());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender