[Offline Pages] Add a timer to BackgroundLoaderOffliner to delay SavePage by 2 seconds.

chrome/browser/android/offline_pages/background_loader_offliner_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/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/offline_pages/content/background_loader/background_loader_contents_stub.h"
 #include "components/offline_pages/core/background/offliner.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/stub_offline_page_model.h"
@@ skipping 46 matching lines @@
 
   bool mock_saving() const { return mock_saving_; }
 
  private:
   bool mock_saving_;
   SavePageCallback save_page_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockOfflinePageModel);
 };
 
-void PumpLoop() {
-  base::RunLoop().RunUntilIdle();
-}
 }  // namespace
 
 // A BackgroundLoader that we can run tests on.
 // Overrides the ResetState so we don't actually try to create any web contents.
 // This is a temporary solution to test core BackgroundLoaderOffliner
 // functionality until we straighten out assumptions made by RequestCoordinator
 // so that the ResetState method is no longer needed.
 class TestBackgroundLoaderOffliner : public BackgroundLoaderOffliner {
  public:
   explicit TestBackgroundLoaderOffliner(
@@ skipping 49 matching lines @@
   bool SaveInProgress() const { return model_->mock_saving(); }
   MockOfflinePageModel* model() const { return model_; }
   const base::HistogramTester& histograms() const { return histogram_tester_; }
 
   void CompleteLoading() {
     // For some reason, setting loading to True will call DidStopLoading
     // on the observers.
     offliner()->web_contents_tester()->TestSetIsLoading(true);
   }
 
+  void PumpLoop() { base::RunLoop().RunUntilIdle(); }
+
  private:
   void OnCompletion(const SavePageRequest& request,
                     Offliner::RequestStatus status);
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<TestBackgroundLoaderOffliner> offliner_;
   MockOfflinePageModel* model_;
   bool completion_callback_called_;
   Offliner::RequestStatus request_status_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundLoaderOfflinerTest);
 };
 
 BackgroundLoaderOfflinerTest::BackgroundLoaderOfflinerTest()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
       completion_callback_called_(false),
       request_status_(Offliner::RequestStatus::UNKNOWN) {}
 
 BackgroundLoaderOfflinerTest::~BackgroundLoaderOfflinerTest() {}
 
 void BackgroundLoaderOfflinerTest::SetUp() {
   model_ = new MockOfflinePageModel();
   offliner_.reset(new TestBackgroundLoaderOffliner(profile(), nullptr, model_));
+  offliner_->SetPageDelayForTest(0L);
 }
 
 void BackgroundLoaderOfflinerTest::OnCompletion(
     const SavePageRequest& request,
     Offliner::RequestStatus status) {
   DCHECK(!completion_callback_called_);  // Expect 1 callback per request.
   completion_callback_called_ = true;
   request_status_ = status;
 }
 
@@ skipping 179 matching lines @@
   offliner()->DidFinishNavigation(handle.get());
   // NavigationHandle is always destroyed after finishing navigation.
   handle.reset();
   offliner()->DidStopLoading();
   PumpLoop();
 
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::LOADING_FAILED_NO_RETRY, request_status());
 }
 
+TEST_F(BackgroundLoaderOfflinerTest, OnlySavesOnceOnMultipleLoads) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
+                          kUserRequested);
+  EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
+  // First load
+  CompleteLoading();
+  // Second load
+  offliner()->DidStopLoading();
+  PumpLoop();
+  model()->CompleteSavingAsSuccess();
+  PumpLoop();
+
+  EXPECT_TRUE(completion_callback_called());
+  EXPECT_EQ(Offliner::RequestStatus::SAVED, request_status());
+  EXPECT_FALSE(offliner()->is_loading());
+  EXPECT_FALSE(SaveInProgress());
+}
+
 }  // namespace offline_pages