chrome/browser/long_screenshots/long_screenshots_tab_service_unittest.cc

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/long_screenshots/long_screenshots_tab_service.h"

#include <memory>
#include <utility>
#include <vector>

#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/test/task_environment.h"
#include "chrome/test/base/chrome_render_view_host_test_harness.h"
#include "components/paint_preview/common/mock_paint_preview_recorder.h"
#include "components/paint_preview/common/mojom/paint_preview_recorder.mojom.h"
#include "components/paint_preview/common/mojom/paint_preview_types.mojom.h"
#include "content/public/test/navigation_simulator.h"
#include "content/public/test/test_utils.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"

namespace long_screenshots {

using paint_preview::DirectoryKey;
using paint_preview::FileManager;

namespace {
constexpr char kFeatureName[] = "tab_service_test";

// Override PaintPreviewRecorder with a mock version where the status and
// response can be manipulated based on the expected response.
class LaxMockPaintPreviewRecorder
    : public paint_preview::MockPaintPreviewRecorder {
 public:
  LaxMockPaintPreviewRecorder() = default;
  ~LaxMockPaintPreviewRecorder() override = default;

 protected:
  void CheckParams(const paint_preview::mojom::PaintPreviewCaptureParamsPtr&
                       params) override {}
};

std::vector<base::FilePath> ListDir(const base::FilePath& path) {
  base::FileEnumerator enumerator(
      path, false,
      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES,
      FILE_PATH_LITERAL("*.skp"));  // Ignore the proto.pb files.
  std::vector<base::FilePath> files;
  for (base::FilePath name = enumerator.Next(); !name.empty();
       name = enumerator.Next()) {
    files.push_back(name);
  }
  return files;
}

}  // namespace

class LongScreenshotsTabServiceTest : public ChromeRenderViewHostTestHarness {
 public:
  LongScreenshotsTabServiceTest()
      : ChromeRenderViewHostTestHarness(
            base::test::TaskEnvironment::TimeSource::MOCK_TIME,
            base::test::TaskEnvironment::ThreadPoolExecutionMode::QUEUED) {}
  ~LongScreenshotsTabServiceTest() override = default;

  LongScreenshotsTabServiceTest(const LongScreenshotsTabServiceTest&) = delete;
  LongScreenshotsTabServiceTest& operator=(
      const LongScreenshotsTabServiceTest&) = delete;

 protected:
  void SetUp() override {
    ChromeRenderViewHostTestHarness::SetUp();
    NavigateAndCommit(GURL("https://www.example.com/"),
                      ui::PageTransition::PAGE_TRANSITION_FIRST);
    task_environment()->RunUntilIdle();
    EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
    service_ = std::make_unique<LongScreenshotsTabService>(
        std::make_unique<paint_preview::PaintPreviewFileMixin>(
            temp_dir_.GetPath(), kFeatureName),
        nullptr, false);
    task_environment()->RunUntilIdle();
  }

  void TearDown() override { ChromeRenderViewHostTestHarness::TearDown(); }

  LongScreenshotsTabService* GetService() { return service_.get(); }

  bool TabService_IsAmpUrl(const GURL& url) { return service_->IsAmpUrl(url); }

  content::RenderFrameHost* TabService_GetRootRenderFrameHost(
      content::RenderFrameHost* frame,
      const GURL& url) {
    return service_->GetRootRenderFrameHost(frame, url);
  }

  void OverrideInterface(LaxMockPaintPreviewRecorder* recorder) {
    blink::AssociatedInterfaceProvider* remote_interfaces =
        web_contents()->GetPrimaryMainFrame()->GetRemoteAssociatedInterfaces();
    remote_interfaces->OverrideBinderForTesting(
        paint_preview::mojom::PaintPreviewRecorder::Name_,
        base::BindRepeating(&LaxMockPaintPreviewRecorder::BindRequest,
                            base::Unretained(recorder)));
  }

  const base::FilePath& GetPath() const { return temp_dir_.GetPath(); }

 private:
  std::unique_ptr<LongScreenshotsTabService> service_;
  base::ScopedTempDir temp_dir_;
};

// Test a successful capturing of a tab.
TEST_F(LongScreenshotsTabServiceTest, CaptureTab) {
  const int kTabId = 1U;

  LaxMockPaintPreviewRecorder recorder;
  recorder.SetResponse();
  OverrideInterface(&recorder);

  auto* service = GetService();
  service->CaptureTab(kTabId, GURL::EmptyGURL(), web_contents(), 0, 0, 1000,
                      1000, false,
                      paint_preview::mojom::ClipCoordOverride::kNone,
                      paint_preview::mojom::ClipCoordOverride::kNone);
  task_environment()->RunUntilIdle();

  auto file_manager = service->GetFileMixin()->GetFileManager();
  auto key = file_manager->CreateKey(kTabId);
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&paint_preview::FileManager::DirectoryExists, file_manager,
                     key),
      base::BindOnce([](bool exists) { EXPECT_TRUE(exists); }));
  task_environment()->RunUntilIdle();

  service->DeleteAllLongScreenshotFiles();
  task_environment()->RunUntilIdle();
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_FALSE(exists); }));
  task_environment()->RunUntilIdle();
}

// Test a successful capturing of a tab in memory.
TEST_F(LongScreenshotsTabServiceTest, CaptureTabInMemory) {
  const int kTabId = 1U;

  LaxMockPaintPreviewRecorder recorder;
  paint_preview::mojom::PaintPreviewCaptureResponsePtr response =
      paint_preview::mojom::PaintPreviewCaptureResponse::New();
  response->geometry_metadata =
      paint_preview::mojom::GeometryMetadataResponse::New();
  response->skp.emplace(mojo_base::BigBuffer());
  recorder.SetResponse(std::move(response));
  OverrideInterface(&recorder);

  auto* service = GetService();
  service->CaptureTab(kTabId, GURL::EmptyGURL(), web_contents(), 0, 0, 1000,
                      1000, true,
                      paint_preview::mojom::ClipCoordOverride::kNone,
                      paint_preview::mojom::ClipCoordOverride::kNone);
  task_environment()->RunUntilIdle();

  // No file should have been created.
  auto file_manager = service->GetFileMixin()->GetFileManager();
  auto key = file_manager->CreateKey(kTabId);
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&paint_preview::FileManager::DirectoryExists, file_manager,
                     key),
      base::BindOnce([](bool exists) { EXPECT_FALSE(exists); }));
  task_environment()->RunUntilIdle();
}

// Test a successful capturing a tab multiple times.
TEST_F(LongScreenshotsTabServiceTest, CaptureTabTwice) {
  const int kTabId = 1U;

  LaxMockPaintPreviewRecorder recorder;
  recorder.SetResponse();
  OverrideInterface(&recorder);

  auto* service = GetService();
  service->CaptureTab(kTabId, GURL::EmptyGURL(), web_contents(), 0, 0, 1000,
                      1000, false,
                      paint_preview::mojom::ClipCoordOverride::kNone,
                      paint_preview::mojom::ClipCoordOverride::kNone);

  task_environment()->RunUntilIdle();
  auto file_manager = service->GetFileMixin()->GetFileManager();
  auto key = file_manager->CreateKey(kTabId);
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_TRUE(exists); }));
  task_environment()->RunUntilIdle();
  base::FilePath path_1;
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::CreateOrGetDirectory, file_manager, key,
                     false),
      base::BindOnce(
          [](base::FilePath* out, const std::optional<base::FilePath>& path) {
            EXPECT_TRUE(path.has_value());
            *out = path.value();
          },
          &path_1));
  task_environment()->RunUntilIdle();
  auto files_1 = ListDir(path_1);
  ASSERT_EQ(1U, files_1.size());

  recorder.SetResponse();
  service->CaptureTab(kTabId, GURL::EmptyGURL(), web_contents(), 1000, 1000,
                      2000, 2000, false,
                      paint_preview::mojom::ClipCoordOverride::kNone,
                      paint_preview::mojom::ClipCoordOverride::kNone);
  task_environment()->RunUntilIdle();

  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_TRUE(exists); }));
  base::FilePath path_2;
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::CreateOrGetDirectory, file_manager, key,
                     false),
      base::BindOnce(
          [](base::FilePath* out, const std::optional<base::FilePath>& path) {
            EXPECT_TRUE(path.has_value());
            *out = path.value();
          },
          &path_2));
  task_environment()->RunUntilIdle();
  EXPECT_EQ(path_2, path_1);
  auto files_2 = ListDir(path_2);
  ASSERT_EQ(1U, files_2.size());
  // The embedding token is used in the filename of the captured SkPicture.
  // Since the embedding token is the same the filenames should also be the
  // same.
  EXPECT_EQ(files_1, files_2);

  service->DeleteAllLongScreenshotFiles();
  task_environment()->RunUntilIdle();
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_FALSE(exists); }));
  task_environment()->RunUntilIdle();
}

// Test when PaintPreviewRecorder returns a failure status code.
TEST_F(LongScreenshotsTabServiceTest, CaptureTabFailed) {
  const int kTabId = 1U;

  LaxMockPaintPreviewRecorder recorder;
  recorder.SetResponse(
      base::unexpected(paint_preview::mojom::PaintPreviewStatus::kFailed));
  OverrideInterface(&recorder);

  auto* service = GetService();
  service->CaptureTab(kTabId, GURL::EmptyGURL(), web_contents(), 0, 0, 1000,
                      1000, false,
                      paint_preview::mojom::ClipCoordOverride::kNone,
                      paint_preview::mojom::ClipCoordOverride::kNone);
  task_environment()->RunUntilIdle();

  auto file_manager = service->GetFileMixin()->GetFileManager();
  auto key = file_manager->CreateKey(kTabId);
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_TRUE(exists); }));
  task_environment()->RunUntilIdle();

  service->DeleteAllLongScreenshotFiles();
  task_environment()->RunUntilIdle();
  service->GetFileMixin()->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::DirectoryExists, file_manager, key),
      base::BindOnce([](bool exists) { EXPECT_FALSE(exists); }));
  task_environment()->RunUntilIdle();
}

TEST_F(LongScreenshotsTabServiceTest, AmpPageDetection) {
  GURL amp_url("https://www.google.com/amp/s/example");
  GURL amp_cahe_url(
      "https://www-example-com.cdn.ampproject.org/c/www.example.com");
  GURL google_news_url("https://news.google.com/articles/foo");
  GURL non_amp_url("https://foo.com/amp/bar/");

  ASSERT_TRUE(TabService_IsAmpUrl(amp_url));
  ASSERT_TRUE(TabService_IsAmpUrl(amp_cahe_url));
  ASSERT_TRUE(TabService_IsAmpUrl(google_news_url));
  ASSERT_FALSE(TabService_IsAmpUrl(non_amp_url));

  auto* rfh = main_rfh();
  ASSERT_EQ(rfh, TabService_GetRootRenderFrameHost(rfh, non_amp_url));
  // The main frame has no child frame so main frame should be returned.
  ASSERT_EQ(rfh, TabService_GetRootRenderFrameHost(rfh, amp_url));
  auto* rfh_tester = content::RenderFrameHostTester::For(rfh);
  auto* subframe = rfh_tester->AppendChild("child 1");
  // Child frame should be returned.
  ASSERT_EQ(subframe, TabService_GetRootRenderFrameHost(rfh, amp_url));
  // main frame has more than one child frame. Main frame should be returned.
  rfh_tester->AppendChild("child 2");
  ASSERT_EQ(rfh, TabService_GetRootRenderFrameHost(rfh, amp_url));
}

}  // namespace long_screenshots