Prerender: Allow on low end devices for ORIGIN_OFFLINE

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>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
+#include "base/sys_info.h"
+#include "base/test/mock_entropy_provider.h"
 #include "base/time/time.h"
 #include "chrome/browser/net/prediction_options.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_manager.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ skipping 402 matching lines @@
           url, ORIGIN_OFFLINE, FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize));
   EXPECT_TRUE(prerender_handle);
   EXPECT_TRUE(prerender_handle->IsPrerendering());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_OFFLINE, prerender_handle->contents()->origin());
 }
 
+TEST_F(PrerenderTest, PrerenderDisabledOnLowEndDevice) {
+  GURL url("http://www.google.com/");
+  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+
+  // Instantiate the low end device trial.
+  base::FieldTrialList::CreateFieldTrial("MemoryReduction", "Enabled");
+  ASSERT_TRUE(base::SysInfo::IsLowEndDevice());
+
+  EXPECT_FALSE(AddSimplePrerender(url));

[mmenke, 2016/07/29 15:57:09]

I assume most of the other tests now fail on low end devices.  We should make
the other tests pass on them, right?

[pasko, 2016/07/29 16:10:00]

This test "fakes" running on low end (i.e. svelte) with the FieldTrial, it is
not intended to run on svelte.

I believe we do not run unit_tests on actual svelte devices. I know that we test
the svelte configuration by modifying flags on non-svelte devices. Svelte perf
bots were also removed not long ago. I think we do not run *anything* on svelte
devices right now :(

Could be my wrong interpretation.

[mmenke, 2016/07/29 16:12:27]

Just because none of the bots run on svelte devices surely doesn't mean we
shouldn't support running unit tests on them, no?

[pasko, 2016/07/29 17:25:03]

I disagree.

Chrome is a large project such that when some configuration is not covered by
regular testing, we are almost sure it is broken in numerous ways, many of these
ways are usually unrelated to what the tests actually check for. Given that, the
policy has been: "If there is a configuration we care about, it must be
regularly tested on chrome infra bots."

In particular, with testing on Svelte there would be flakiness problems caused
by the system evicting our processes more aggressively, not all tests fitting in
memory, etc.

Deciding whether we need svelte bots "enough" is outside of the scope of this
change, I argued for more svelte bots for perf in the past, and my arguments
were not heard.

Here I am not willing to fix the potential stack of problems with Svelte, and I
do not want to add complexity to the code without being able to test it. Even if
I do it properly with my local device and everything, it will rot faster than I
will return to play with this test again.

+}
+
+TEST_F(PrerenderTest, OfflinePrerenderPossibleOnLowEndDevice) {
+  GURL url("http://www.google.com/");
+  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+
+  // Instantiate the low end device trial.
+  base::FieldTrialList::CreateFieldTrial("MemoryReduction", "Enabled");
+  ASSERT_TRUE(base::SysInfo::IsLowEndDevice());
+
+  DummyPrerenderContents* prerender_contents =
+      prerender_manager()->CreateNextPrerenderContents(
+          url, ORIGIN_OFFLINE, FINAL_STATUS_MANAGER_SHUTDOWN);
+  std::unique_ptr<PrerenderHandle> prerender_handle(
+      prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize));
+  EXPECT_TRUE(prerender_handle);
+  EXPECT_TRUE(prerender_handle->IsPrerendering());
+  EXPECT_TRUE(prerender_contents->prerendering_has_started());
+}
+
 TEST_F(PrerenderTest, FoundTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
@@ skipping 1178 matching lines @@
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
   ASSERT_EQ(prerender_contents, entry.get());
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender