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;
+  }
+
  private:
+  bool IsLowEndDevice() const override { return is_low_end_device_; }
+
   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 46 matching lines @@
   static const int kDefaultChildId = -1;
   static const int kDefaultRenderViewRouteId = -1;
 
   PrerenderTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         prerender_manager_(new UnitTestPrerenderManager(&profile_)),
         prerender_link_manager_(
             new PrerenderLinkManager(prerender_manager_.get())),
         last_prerender_id_(0),
         field_trial_list_(nullptr) {
+    prerender_manager()->SetIsLowEndDevice(false);
+
     // Enable omnibox prerendering.
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrerenderFromOmnibox,
         switches::kPrerenderFromOmniboxSwitchValueEnabled);
   }
 
   ~PrerenderTest() override {
     prerender_link_manager_->OnChannelClosing(kDefaultChildId);
     prerender_link_manager_->Shutdown();
     prerender_manager_->Shutdown();
@@ skipping 107 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