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>
 
@@ skipping 198 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));
   }
 
+  void SetIsLowEndDevice(bool is_low_end_device) {
+    is_low_end_device_ = is_low_end_device;
+  }
+
+ protected:
+  bool IsLowEndDevice() override { return is_low_end_device_; }

[mmenke, 2016/08/03 15:10:58]

Doesn't really matter, but this can be private

[pasko, 2016/08/03 15:30:18]

Done.

+
  private:
   DummyPrerenderContents* SetNextPrerenderContents(
       std::unique_ptr<DummyPrerenderContents> prerender_contents) {
     CHECK(!next_prerender_contents_);
     DummyPrerenderContents* contents_ptr = prerender_contents.get();
     next_prerender_contents_ = std::move(prerender_contents);
     return contents_ptr;
   }
 
   std::unique_ptr<PrerenderContents> CreatePrerenderContents(
       const GURL& url,
       const Referrer& referrer,
       Origin origin) override {
     CHECK(next_prerender_contents_);
     EXPECT_EQ(url, next_prerender_contents_->prerender_url());
     EXPECT_EQ(origin, next_prerender_contents_->origin());
     return std::move(next_prerender_contents_);
   }
 
   // Maintain a map from route pairs to PrerenderContents for
   // GetPrerenderContentsForRoute.
   using PrerenderContentsMap =
       std::map<std::pair<int, int>, PrerenderContents*>;
   PrerenderContentsMap prerender_contents_map_;
 
   Time time_;
   TimeTicks time_ticks_;
   std::unique_ptr<PrerenderContents> next_prerender_contents_;
+  bool is_low_end_device_;
 };
 
 class RestorePrerenderMode {
  public:
   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
   }
 
   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
 
  private:
@@ skipping 58 matching lines @@
         switches::kPrerenderFromOmnibox,
         switches::kPrerenderFromOmniboxSwitchValueEnabled);
   }
 
   ~PrerenderTest() override {
     prerender_link_manager_->OnChannelClosing(kDefaultChildId);
     prerender_link_manager_->Shutdown();
     prerender_manager_->Shutdown();
   }
 
+  void SetUp() override { prerender_manager()->SetIsLowEndDevice(false); }

[mmenke, 2016/08/03 15:10:58]

Can just put this in the constructor.  Each test iteration uses its own instance
of the test fixture (Which means SetUp is mostly just useful for interleaving
subclass and superclass initialization)

[pasko, 2016/08/03 15:30:17]

Ah, there is some stuff already in the constructor, putting it there then, will
look more consistent. I forgot that TEST_F re-creates the fixture (shame shame).

Though, how does this align with general perception of doing work in
constructors being more error prone?
https://google.github.io/styleguide/cppguide.html#Doing_Work_in_Constructors

[mmenke, 2016/08/03 15:36:43]

We aren't doing any virtual calls to the test fixture, and we can't fail (If we
could fail, EXPECTs work fine in the constructor, ASSERTs would have to go here,
though).

My feeling is that in test fixtures, it's best just to do all the work in the
constructor/destructor, to have everything all in one place.

+
   UnitTestPrerenderManager* prerender_manager() {
     return prerender_manager_.get();
   }
 
   PrerenderLinkManager* prerender_link_manager() {
     return prerender_link_manager_.get();
   }
 
   Profile* profile() { return &profile_; }
 
@@ skipping 95 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());
+  prerender_manager()->SetIsLowEndDevice(true);
+  EXPECT_FALSE(AddSimplePrerender(url));
+}
+
+TEST_F(PrerenderTest, OfflinePrerenderPossibleOnLowEndDevice) {
+  GURL url("http://www.google.com/");
+  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+
+  prerender_manager()->SetIsLowEndDevice(true);
+
+  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