chrome/browser/android/offline_pages/offline_page_web_contents_observer_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/files/file_path.h"
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/run_loop.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
  13 #include "chrome/browser/android/offline_pages/offline_page_web_contents_observer.h"
  14 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  15 #include "content/public/browser/navigation_details.h"
  16 #include "content/public/test/test_renderer_host.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace offline_pages {
  20
  21 namespace {
  22
  23 const GURL kTestURL("http://example.com/");
  24 const base::FilePath::CharType kTestFilePath[] = FILE_PATH_LITERAL(
  25     "/archive_dir/offline_page.mhtml");
  26 const int64 kTestFileSize = 123456LL;
  27
  28 class TestMHTMLArchiver : public OfflinePageMHTMLArchiver {
  29  public:
  30   TestMHTMLArchiver(
  31       content::WebContents* web_contents,
  32       const GURL& url,
  33       const base::FilePath& archive_dir);
  34   ~TestMHTMLArchiver() override;
  35
  36  private:
  37   void DoGenerateMHTML() override;
  38
  39   const GURL url_;
  40
  41   DISALLOW_COPY_AND_ASSIGN(TestMHTMLArchiver);
  42 };
  43
  44 TestMHTMLArchiver::TestMHTMLArchiver(content::WebContents* web_contents,
  45                                      const GURL& url,
  46                                      const base::FilePath& archive_dir)
  47     : OfflinePageMHTMLArchiver(web_contents, archive_dir), url_(url) {
  48 }
  49
  50 TestMHTMLArchiver::~TestMHTMLArchiver() {
  51 }
  52
  53 void TestMHTMLArchiver::DoGenerateMHTML() {
  54   base::ThreadTaskRunnerHandle::Get()->PostTask(
  55       FROM_HERE,
  56       base::Bind(&TestMHTMLArchiver::OnGenerateMHTMLDone,
  57                  base::Unretained(this),
  58                  url_,
  59                  base::FilePath(kTestFilePath),
  60                  kTestFileSize));
  61 }
  62
  63 }  // namespace
  64
  65 class OfflinePageWebContentsObserverTest :
  66     public ChromeRenderViewHostTestHarness  {
  67  public:
  68   OfflinePageWebContentsObserverTest();
  69   ~OfflinePageWebContentsObserverTest() override;
  70
  71   void SetUp() override;
  72   void TearDown() override;
  73
  74   // Helper to create an archiver and call its CreateArchive.
  75   void CreateArchive(const GURL& url);
  76
  77   // Test tooling methods.
  78   void PumpLoop();
  79
  80   OfflinePageWebContentsObserver* web_contents_observer() const {
  81     return web_contents_observer_;
  82   }
  83
  84   OfflinePageArchiver::ArchiverResult last_result() const {
  85     return last_result_;
  86   }
  87
  88  private:
  89   void OnCreateArchiveDone(OfflinePageArchiver* archiver,
  90                            OfflinePageArchiver::ArchiverResult result,
  91                            const GURL& url,
  92                            const base::FilePath& file_path,
  93                            int64 file_size);
  94
  95   OfflinePageWebContentsObserver* web_contents_observer_;  // Not owned.
  96   scoped_ptr<TestMHTMLArchiver> archiver_;
  97   OfflinePageArchiver::ArchiverResult last_result_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(OfflinePageWebContentsObserverTest);
 100 };
 101
 102 OfflinePageWebContentsObserverTest::OfflinePageWebContentsObserverTest()
 103     : last_result_(OfflinePageArchiver::ArchiverResult::
 104                        ERROR_ARCHIVE_CREATION_FAILED) {
 105 }
 106
 107 OfflinePageWebContentsObserverTest::~OfflinePageWebContentsObserverTest() {
 108 }
 109
 110 void OfflinePageWebContentsObserverTest::SetUp() {
 111   content::RenderViewHostTestHarness::SetUp();
 112   OfflinePageWebContentsObserver::CreateForWebContents(web_contents());
 113   web_contents_observer_ =
 114       OfflinePageWebContentsObserver::FromWebContents(web_contents());
 115   ASSERT_FALSE(web_contents_observer_->is_document_loaded_in_main_frame());
 116 }
 117
 118 void OfflinePageWebContentsObserverTest::TearDown() {
 119   archiver_.reset();
 120   content::RenderViewHostTestHarness::TearDown();
 121 }
 122
 123 void OfflinePageWebContentsObserverTest::CreateArchive(const GURL& url) {
 124   archiver_.reset(new TestMHTMLArchiver(web_contents(), url,
 125                                         base::FilePath(kTestFilePath)));
 126   archiver_->CreateArchive(
 127       base::Bind(&OfflinePageWebContentsObserverTest::OnCreateArchiveDone,
 128                  base::Unretained(this)));
 129 }
 130
 131 void OfflinePageWebContentsObserverTest::OnCreateArchiveDone(
 132     OfflinePageArchiver* archiver,
 133     OfflinePageArchiver::ArchiverResult result,
 134     const GURL& url,
 135     const base::FilePath& file_path,
 136     int64 file_size) {
 137   last_result_ = result;
 138 }
 139
 140 void OfflinePageWebContentsObserverTest::PumpLoop() {
 141   base::RunLoop().RunUntilIdle();
 142 }
 143
 144 TEST_F(OfflinePageWebContentsObserverTest, LoadMainFrameBeforeCreateArchive) {
 145   // Navigate in main frame. Document was not loaded yet.
 146   content::LoadCommittedDetails details = content::LoadCommittedDetails();
 147   details.is_main_frame = true;
 148   details.is_in_page = false;
 149   content::FrameNavigateParams params = content::FrameNavigateParams();
 150   web_contents_observer()->DidNavigateMainFrame(details, params);
 151   ASSERT_FALSE(web_contents_observer()->is_document_loaded_in_main_frame());
 152
 153   // Load document in main frame.
 154   web_contents_observer()->DocumentLoadedInFrame(main_rfh());
 155   ASSERT_TRUE(web_contents_observer()->is_document_loaded_in_main_frame());
 156
 157   // Create an archive.
 158   CreateArchive(kTestURL);
 159
 160   PumpLoop();
 161   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 162             last_result());
 163 }
 164
 165 TEST_F(OfflinePageWebContentsObserverTest, LoadMainFrameAfterCreateArchive) {
 166   // Navigate in main frame. Document was not loaded yet.
 167   content::LoadCommittedDetails details = content::LoadCommittedDetails();
 168   details.is_main_frame = true;
 169   details.is_in_page = false;
 170   content::FrameNavigateParams params = content::FrameNavigateParams();
 171   web_contents_observer()->DidNavigateMainFrame(details, params);
 172   ASSERT_FALSE(web_contents_observer()->is_document_loaded_in_main_frame());
 173
 174   // Create an archive. Waiting for document loaded in main frame.
 175   CreateArchive(kTestURL);
 176
 177   PumpLoop();
 178   EXPECT_NE(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 179             last_result());
 180
 181   // Load document in main frame.
 182   web_contents_observer()->DocumentLoadedInFrame(main_rfh());
 183   ASSERT_TRUE(web_contents_observer()->is_document_loaded_in_main_frame());
 184
 185   PumpLoop();
 186   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 187             last_result());
 188 }
 189
 190 TEST_F(OfflinePageWebContentsObserverTest, ResetOnPageNavigation) {
 191   // Navigate in main frame. Document was not loaded yet.
 192   content::LoadCommittedDetails details = content::LoadCommittedDetails();
 193   details.is_main_frame = true;
 194   details.is_in_page = false;
 195   content::FrameNavigateParams params = content::FrameNavigateParams();
 196   web_contents_observer()->DidNavigateMainFrame(details, params);
 197   ASSERT_FALSE(web_contents_observer()->is_document_loaded_in_main_frame());
 198
 199   // Load document in main frame.
 200   web_contents_observer()->DocumentLoadedInFrame(main_rfh());
 201   ASSERT_TRUE(web_contents_observer()->is_document_loaded_in_main_frame());
 202
 203   // Another navigation should result in waiting for a page load.
 204   web_contents_observer()->DidNavigateMainFrame(details, params);
 205   ASSERT_FALSE(web_contents_observer()->is_document_loaded_in_main_frame());
 206
 207   // Create an archive. Waiting for document loaded in main frame.
 208   CreateArchive(kTestURL);
 209
 210   PumpLoop();
 211   EXPECT_NE(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 212             last_result());
 213
 214   // Load document in main frame.
 215   web_contents_observer()->DocumentLoadedInFrame(main_rfh());
 216   ASSERT_TRUE(web_contents_observer()->is_document_loaded_in_main_frame());
 217
 218   PumpLoop();
 219   EXPECT_EQ(OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
 220             last_result());
 221 }
 222
 223 }  // namespace offline_pages