Last_n: disable on Svelte devices.

chrome/browser/android/offline_pages/recent_tab_helper_unittest.cc

 // Copyright 2016 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 "chrome/browser/android/offline_pages/recent_tab_helper.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 34 matching lines @@
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       int tab_id,
       bool tab_id_result);
   ~TestDelegate() override {}
 
   std::unique_ptr<OfflinePageArchiver> CreatePageArchiver(
         content::WebContents* web_contents) override;
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override;
     // There is no expectations that tab_id is always present.
   bool GetTabId(content::WebContents* web_contents, int* tab_id) override;
+  bool IsLowEndDevice() override { return is_low_end_device_; }
 
   void set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult result) {
     archive_result_ = result;
   }
 
   void set_archive_size(int64_t size) { archive_size_ = size; }
 
+  void SetAsLowEndDevice() { is_low_end_device_ = true; }
+
  private:
   OfflinePageTestArchiver::Observer* observer_;  // observer owns this.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   int tab_id_;
   bool tab_id_result_;
 
   // These values can be updated so that new OfflinePageTestArchiver instances
   // will return different results.
   offline_pages::OfflinePageArchiver::ArchiverResult archive_result_ =
       offline_pages::OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED;
   int64_t archive_size_ = kArchiveSizeToReport;
+  bool is_low_end_device_ = false;
 };
 
 class RecentTabHelperTest
     : public ChromeRenderViewHostTestHarness,
       public OfflinePageModel::Observer,
       public OfflinePageTestArchiver::Observer {
  public:
   RecentTabHelperTest();
   ~RecentTabHelperTest() override {}
 
@@ skipping 13 matching lines @@
   // and when reusing the same URL that will be considered a same page
   // navigation.
   void NavigateAndCommitTyped(const GURL& url);
 
   ClientId NewDownloadClientId();
 
   RecentTabHelper* recent_tab_helper() const { return recent_tab_helper_; }
 
   OfflinePageModel* model() const { return model_; }
 
+  TestDelegate* default_test_delegate() { return default_test_delegate_; }
+
   // Returns a OfflinePageItem pointer from |all_pages| that matches the
   // provided |offline_id|. If a match is not found returns nullptr.
   const OfflinePageItem* FindPageForOfflineId(int64_t offline_id) {
     for (const OfflinePageItem& page : GetAllPages()) {
       if (page.offline_id == offline_id)
         return &page;
     }
     return nullptr;
   }
 
@@ skipping 17 matching lines @@
     model_removed_count_++;
     all_pages_needs_updating_ = true;
   }
 
   // OfflinePageTestArchiver::Observer
   void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override {}
 
  private:
   void OnGetAllPagesDone(const std::vector<OfflinePageItem>& result);
 
-  RecentTabHelper* recent_tab_helper_;  // Owned by WebContents.
-  OfflinePageModel* model_;  // Keyed service
+  RecentTabHelper* recent_tab_helper_;   // Owned by WebContents.
+  OfflinePageModel* model_;              // Keyed service.
+  TestDelegate* default_test_delegate_;  // Created at SetUp.
   size_t page_added_count_;
   size_t model_removed_count_;
   std::vector<OfflinePageItem> all_pages_;
   bool all_pages_needs_updating_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::test::ScopedFeatureList scoped_feature_list_;
 
   base::WeakPtrFactory<RecentTabHelperTest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentTabHelperTest);
@@ skipping 24 matching lines @@
 }
   // There is no expectations that tab_id is always present.
 bool TestDelegate::GetTabId(content::WebContents* web_contents, int* tab_id) {
   *tab_id = tab_id_;
   return tab_id_result_;
 }
 
 RecentTabHelperTest::RecentTabHelperTest()
     : recent_tab_helper_(nullptr),
       model_(nullptr),
+      default_test_delegate_(nullptr),
       page_added_count_(0),
       model_removed_count_(0),
       all_pages_needs_updating_(true),
       task_runner_(new base::TestMockTimeTaskRunner),
       weak_ptr_factory_(this) {}
 
 void RecentTabHelperTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
 
   scoped_feature_list_.InitAndEnableFeature(kOffliningRecentPagesFeature);
   // Sets up the factories for testing.
   OfflinePageModelFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), BuildTestOfflinePageModel);
   RunUntilIdle();
   RequestCoordinatorFactory::GetInstance()->SetTestingFactoryAndUse(
       browser_context(), BuildTestRequestCoordinator);
   RunUntilIdle();
 
   RecentTabHelper::CreateForWebContents(web_contents());
   recent_tab_helper_ = RecentTabHelper::FromWebContents(web_contents());
 
-  recent_tab_helper_->SetDelegate(base::MakeUnique<TestDelegate>(
-      this, task_runner(), kTabId, true));
+  std::unique_ptr<TestDelegate> test_delegate(
+      new TestDelegate(this, task_runner(), kTabId, true));
+  default_test_delegate_ = test_delegate.get();
+  recent_tab_helper_->SetDelegate(std::move(test_delegate));
 
   model_ = OfflinePageModelFactory::GetForBrowserContext(browser_context());
   model_->AddObserver(this);
 }
 
 void RecentTabHelperTest::FailLoad(const GURL& url) {
   controller().LoadURL(url, content::Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
   content::RenderFrameHostTester::For(main_rfh())->SimulateNavigationStart(url);
   content::RenderFrameHostTester::For(main_rfh())->
@@ skipping 103 matching lines @@
   recent_tab_helper()->WasHidden();
   recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
                                                      123L);
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   // No page should be captured.
   EXPECT_EQ(0U, page_added_count());
   ASSERT_EQ(0U, GetAllPages().size());
 }
 
+// Checks that last_n is disabled if the device is low-end (aka svelte) but that
+// download requests still work.
+TEST_F(RecentTabHelperTest, LastNDisabledOnSvelte) {
+  // Simulates a low end device.
+  default_test_delegate()->SetAsLowEndDevice();
+
+  // Navigate and finish loading then hide the tab. Nothing should be saved.
+  NavigateAndCommit(kTestPageUrl);
+  recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
+  FastForwardSnapshotController();
+  recent_tab_helper()->WasHidden();
+  RunUntilIdle();
+  EXPECT_TRUE(model()->is_loaded());
+  EXPECT_EQ(0U, page_added_count());
+  ASSERT_EQ(0U, GetAllPages().size());
+
+  // But the following download request should work normally
+  recent_tab_helper()->ObserveAndDownloadCurrentPage(NewDownloadClientId(),
+                                                     123L);
+  RunUntilIdle();
+  EXPECT_EQ(1U, page_added_count());
+  ASSERT_EQ(1U, GetAllPages().size());
+}
+
 // Triggers two last_n snapshot captures during a single page load. Should end
 // up with one snapshot, the 1st being replaced by the 2nd.
 TEST_F(RecentTabHelperTest, TwoCapturesSamePageLoad) {
   NavigateAndCommit(kTestPageUrl);
   // Set page loading state to the 1st snapshot-able stage. No capture so far.
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
   RunUntilIdle();
   EXPECT_TRUE(model()->is_loaded());
   EXPECT_EQ(0U, page_added_count());
@@ skipping 37 matching lines @@
   recent_tab_helper()->DocumentAvailableInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
   int64_t first_offline_id = GetAllPages()[0].offline_id;
 
-  // Sets a new delegate that will make the second snapshot fail.
-  TestDelegate* failing_delegate =
-      new TestDelegate(this, task_runner(), kTabId, true);
-  failing_delegate->set_archive_size(-1);
-  failing_delegate->set_archive_result(
+  // Updates the delegate so that will make the second snapshot fail.
+  default_test_delegate()->set_archive_size(-1);
+  default_test_delegate()->set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult::
           ERROR_ARCHIVE_CREATION_FAILED);
-  recent_tab_helper()->SetDelegate(
-      std::unique_ptr<TestDelegate>(failing_delegate));
 
   // Advance loading to the 2nd and final stage and then hide the tab. A new
   // capture is requested but its creation will fail. The exact same snapshot
   // from before should still be available.
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
@@ skipping 44 matching lines @@
   NavigateAndCommit(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(1U, GetAllPages().size());
   EXPECT_EQ(kTestPageUrl, GetAllPages()[0].url);
 
-  // Sets a new delegate that will make the second snapshot fail.
-  TestDelegate* failing_delegate =
-      new TestDelegate(this, task_runner(), kTabId, true);
-  failing_delegate->set_archive_size(-1);
-  failing_delegate->set_archive_result(
+  // Updates the delegate so that will make the second snapshot fail.
+  default_test_delegate()->set_archive_size(-1);
+  default_test_delegate()->set_archive_result(
       offline_pages::OfflinePageArchiver::ArchiverResult::
           ERROR_ARCHIVE_CREATION_FAILED);
-  recent_tab_helper()->SetDelegate(
-      std::unique_ptr<TestDelegate>(failing_delegate));
 
   // Fully load the page once more then hide the tab again. A capture happens
   // and fails but no snapshot should remain.
   NavigateAndCommitTyped(kTestPageUrl);
   recent_tab_helper()->DocumentOnLoadCompletedInMainFrame();
   FastForwardSnapshotController();
   recent_tab_helper()->WasHidden();
   RunUntilIdle();
   EXPECT_EQ(1U, page_added_count());
   EXPECT_EQ(1U, model_removed_count());
@@ skipping 299 matching lines @@
   EXPECT_EQ(2U, page_added_count());
   EXPECT_EQ(0U, model_removed_count());
   ASSERT_EQ(2U, GetAllPages().size());
   const OfflinePageItem* second_page = FindPageForOfflineId(offline_id_3);
   ASSERT_TRUE(second_page);
   EXPECT_EQ(client_id_3, second_page->client_id);
   EXPECT_EQ(offline_id_3, second_page->offline_id);
 }
 
 }  // namespace offline_pages