content/browser/webui/web_ui_main_frame_observer_unittest.cc - chromium/src.git - Git at Google

 // 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 "content/browser/webui/web_ui_main_frame_observer.h"

 #include <memory>
 #include <string>

 #include "base/gtest_prod_util.h"
 #include "base/memory/raw_ptr.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/task/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "components/crash/content/browser/error_reporting/javascript_error_report.h"  // nogncheck
 #include "components/crash/content/browser/error_reporting/js_error_report_processor.h"  // nogncheck
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/navigation_simulator.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/test/test_web_contents.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)

 namespace content {

 namespace {
 using testing::Eq;
 using testing::Optional;

 class FakeJsErrorReportProcessor : public JsErrorReportProcessor {
  public:
   explicit FakeJsErrorReportProcessor(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : task_runner_(std::move(task_runner)) {}

   // After calling this, expect all SendErrorReport's to use this
   // BrowserContext.
   void SetExpectedBrowserContext(BrowserContext* browser_context) {
     browser_context_ = browser_context;
   }

   void SendErrorReport(JavaScriptErrorReport error_report,
                        base::OnceClosure completion_callback,
                        BrowserContext* browser_context) override {
     CHECK_EQ(browser_context, browser_context_);
     last_error_report_ = std::move(error_report);
     ++error_report_count_;
     task_runner_->PostTask(FROM_HERE, std::move(completion_callback));
   }

   const JavaScriptErrorReport& last_error_report() const {
     return last_error_report_;
   }

   int error_report_count() const { return error_report_count_; }

   // Make public for testing.
   using JsErrorReportProcessor::SetDefault;

  protected:
   ~FakeJsErrorReportProcessor() override = default;

  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   JavaScriptErrorReport last_error_report_;
   int error_report_count_ = 0;
   raw_ptr<BrowserContext> browser_context_ = nullptr;
 };

 class MockWebUIController : public WebUIController {
  public:
   explicit MockWebUIController(WebUI* web_ui) : WebUIController(web_ui) {}

   bool IsJavascriptErrorReportingEnabled() override {
     return enable_javascript_error_reporting_;
   }
   void enable_javascript_error_reporting(
       bool enable_javascript_error_reporting) {
     enable_javascript_error_reporting_ = enable_javascript_error_reporting;
   }

  private:
   bool enable_javascript_error_reporting_ = true;

   WEB_UI_CONTROLLER_TYPE_DECL();
 };

 WEB_UI_CONTROLLER_TYPE_IMPL(MockWebUIController)

 }  // namespace

 class WebUIMainFrameObserverTest : public RenderViewHostTestHarness {
  public:
   void SetUp() override {
     RenderViewHostTestHarness::SetUp();
     site_instance_ = SiteInstance::Create(browser_context());
     SetContents(TestWebContents::Create(browser_context(), site_instance_));
     // Since we just created the web_contents() pointer with
     // TestWebContents::Create, the static_casts are safe.
     web_ui_ = std::make_unique<WebUIImpl>(web_contents());
     web_ui_->SetRenderFrameHost(
         static_cast<TestWebContents*>(web_contents())->GetPrimaryMainFrame());
     web_ui_->SetController(
         std::make_unique<MockWebUIController>(web_ui_.get()));
     process()->Init();

     previous_processor_ = JsErrorReportProcessor::Get();
     processor_ = base::MakeRefCounted<FakeJsErrorReportProcessor>(
         task_environment()->GetMainThreadTaskRunner());
     FakeJsErrorReportProcessor::SetDefault(processor_);
     processor_->SetExpectedBrowserContext(browser_context());
   }

   void TearDown() override {
     FakeJsErrorReportProcessor::SetDefault(previous_processor_);

     // We have to destroy the site_instance_ before
     // RenderViewHostTestHarness::TearDown() destroys the
     // BrowserTaskEnvironment. We've gotten a lot of things that depend directly
     // or indirectly on BrowserTaskEnvironment, so just destroy everything we
     // can.
     previous_processor_.reset();
     processor_.reset();
     web_ui_.reset();
     site_instance_.reset();

     RenderViewHostTestHarness::TearDown();
   }

   // Simulate navigating to the WebUI page. Basically so that
   // WebUIMainFrameObserver::ReadyToCommitNavigation() gets called, since that
   // initializes the error handling.
   void NavigateToPage() {
     NavigationSimulator::NavigateAndCommitFromBrowser(web_contents(),
                                                       GURL(kPageURL8));
   }

   // Calls the observer's OnDidAddMessageToConsole with the given arguments.
   // This is just here so that we don't need to FRIEND_TEST_ALL_PREFIXES for
   // each and every test.
   void CallOnDidAddMessageToConsole(
       RenderFrameHost* source_frame,
       blink::mojom::ConsoleMessageLevel log_level,
       const std::u16string& message,
       int32_t line_no,
       const std::u16string& source_id,
       const std::optional<std::u16string>& stack_trace) {
     web_ui_->GetWebUIMainFrameObserverForTest()->OnDidAddMessageToConsole(
         source_frame, log_level, message, line_no, source_id, stack_trace);
   }

  protected:
   scoped_refptr<SiteInstance> site_instance_;
   std::unique_ptr<WebUIImpl> web_ui_;
   scoped_refptr<FakeJsErrorReportProcessor> processor_;
   scoped_refptr<JsErrorReportProcessor> previous_processor_;

   static constexpr char kMessage8[] = "An Error Is Me";
   static constexpr char16_t kMessage16[] = u"An Error Is Me";
   static constexpr char kSourceURL8[] = "chrome://here.is.error/bad.js";
   static constexpr char16_t kSourceURL16[] = u"chrome://here.is.error/bad.js";
   static constexpr char kPageURL8[] = "chrome://here.is.error/index.html";
   static constexpr char kStackTrace8[] =
       "at badFunction (chrome://page/my.js:20:30)\n"
       "at poorCaller (chrome://page/my.js:50:10)\n";
   static constexpr char16_t kStackTrace16[] =
       u"at badFunction (chrome://page/my.js:20:30)\n"
       u"at poorCaller (chrome://page/my.js:50:10)\n";
 };

 constexpr char WebUIMainFrameObserverTest::kMessage8[];
 constexpr char16_t WebUIMainFrameObserverTest::kMessage16[];
 constexpr char WebUIMainFrameObserverTest::kSourceURL8[];
 constexpr char16_t WebUIMainFrameObserverTest::kSourceURL16[];
 constexpr char WebUIMainFrameObserverTest::kPageURL8[];
 constexpr char WebUIMainFrameObserverTest::kStackTrace8[];
 constexpr char16_t WebUIMainFrameObserverTest::kStackTrace16[];

 TEST_F(WebUIMainFrameObserverTest, ErrorReported) {
   NavigateToPage();
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 1);
   EXPECT_EQ(processor_->last_error_report().message, kMessage8);
   EXPECT_EQ(processor_->last_error_report().url, kSourceURL8);
   EXPECT_EQ(processor_->last_error_report().page_url, kPageURL8);
   EXPECT_EQ(processor_->last_error_report().source_system,
             JavaScriptErrorReport::SourceSystem::kWebUIObserver);
   EXPECT_THAT(processor_->last_error_report().stack_trace,
               Optional(Eq(kStackTrace8)));
   // WebUI should use default product & version.
   EXPECT_EQ(processor_->last_error_report().product, "");
   EXPECT_EQ(processor_->last_error_report().version, "");
   EXPECT_EQ(*processor_->last_error_report().line_number, 5);
   EXPECT_FALSE(processor_->last_error_report().column_number);
   EXPECT_FALSE(processor_->last_error_report().app_locale);
   EXPECT_TRUE(processor_->last_error_report().send_to_production_servers);
 }

 TEST_F(WebUIMainFrameObserverTest, NoStackTrace) {
   NavigateToPage();
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, std::nullopt);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 1);
   EXPECT_EQ(processor_->last_error_report().stack_trace, std::nullopt);
 }

 TEST_F(WebUIMainFrameObserverTest, NonErrorsIgnored) {
   NavigateToPage();
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kWarning,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kInfo,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kVerbose,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 0);
 }

 TEST_F(WebUIMainFrameObserverTest, NoProcessorDoesntCrash) {
   NavigateToPage();
   FakeJsErrorReportProcessor::SetDefault(nullptr);
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
 }

 TEST_F(WebUIMainFrameObserverTest, NotSentIfInvalidURL) {
   NavigateToPage();
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, u"invalid URL", kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 0);
 }

 TEST_F(WebUIMainFrameObserverTest, NotSentIfDisabledForPage) {
   static_cast<MockWebUIController*>(web_ui_->GetController())
       ->enable_javascript_error_reporting(false);
   NavigateToPage();
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 0);
 }

 TEST_F(WebUIMainFrameObserverTest, URLPathIsPreservedOtherPartsRemoved) {
   NavigateToPage();
   struct URLTest {
     const char16_t* const input;
     const char* const expected;
   };
   const URLTest kTests[] = {
       // No path still has no path.
       {u"chrome://version", "chrome://version/"},
       {u"chrome://version/", "chrome://version/"},
       // Path is kept.
       {u"chrome://discards/graph", "chrome://discards/graph"},
       {u"chrome://discards/graph/", "chrome://discards/graph/"},
       // Longer paths are kept.
       {u"chrome://discards/graph/a/b/c/d", "chrome://discards/graph/a/b/c/d"},
       // Queries are removed, with or without a path.
       {u"chrome://bookmarks/?q=chromium", "chrome://bookmarks/"},
       {u"chrome://bookmarks/add?q=chromium", "chrome://bookmarks/add"},
       {u"chrome://bookmarks/add/?q=chromium", "chrome://bookmarks/add/"},
       // Fragments are removed, with or without a path.
       {u"chrome://flags/#tab-groups", "chrome://flags/"},
       {u"chrome://flags/available/#tab-groups", "chrome://flags/available/"},
       // Queries & fragments are removed.
       {u"chrome://bookmarks/add?q=chromium#code", "chrome://bookmarks/add"},
       // User name and password are removed. (It's weird to have a user name or
       // password on a chrome URL, but otherwise we get blocked by the
       // no-non-chrome-URLs check)
       {u"chrome://chronos:test0000@version/Home", "chrome://version/Home"},
   };

   for (const URLTest& test : kTests) {
     int previous_count = processor_->error_report_count();
     CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                  blink::mojom::ConsoleMessageLevel::kError,
                                  kMessage16, 5, test.input, kStackTrace16);
     task_environment()->RunUntilIdle();
     EXPECT_EQ(processor_->error_report_count(), previous_count + 1)
         << "for " << test.input;
     EXPECT_EQ(processor_->last_error_report().url, test.expected)
         << "for " << test.input;
   }
 }

 TEST_F(WebUIMainFrameObserverTest, PageURLAlsoRedacted) {
   constexpr char kPageWithQueryAndFragment[] =
       "chrome://bookmarks/add?q=chromium#code";
   NavigationSimulator::NavigateAndCommitFromBrowser(
       web_contents(), GURL(kPageWithQueryAndFragment));
   CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 1);
   EXPECT_EQ(processor_->last_error_report().page_url, "chrome://bookmarks/add");
 }

 TEST_F(WebUIMainFrameObserverTest, ErrorsNotReportedInOtherFrames) {
   NavigateToPage();
   auto another_contents =
       TestWebContents::Create(browser_context(), site_instance_);
   CHECK(another_contents->GetPrimaryMainFrame());
   CallOnDidAddMessageToConsole(another_contents->GetPrimaryMainFrame(),
                                blink::mojom::ConsoleMessageLevel::kError,
                                kMessage16, 5, kSourceURL16, kStackTrace16);
   task_environment()->RunUntilIdle();
   EXPECT_EQ(processor_->error_report_count(), 0);
 }

 TEST_F(WebUIMainFrameObserverTest, ErrorsNotReportedForNonChromeURLs) {
   NavigateToPage();
   const char16_t* const kNonChromeSourceURLs[] = {
       u"chrome-untrusted://media-app",
       u"chrome-error://chromewebdata/",
       u"chrome-extension://abc123/",
       u"about:blank",
   };

   for (const auto* url : kNonChromeSourceURLs) {
     CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
                                  blink::mojom::ConsoleMessageLevel::kError,
                                  kMessage16, 5, url, kStackTrace16);
     task_environment()->RunUntilIdle();
     EXPECT_EQ(processor_->error_report_count(), 0) << url;
   }
 }

 }  // namespace content

 #endif  // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
	// 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 "content/browser/webui/web_ui_main_frame_observer.h"

	#include <memory>
	#include <string>

	#include "base/gtest_prod_util.h"
	#include "base/memory/raw_ptr.h"
	#include "base/metrics/field_trial_params.h"
	#include "base/task/single_thread_task_runner.h"
	#include "build/build_config.h"
	#include "components/crash/content/browser/error_reporting/javascript_error_report.h" // nogncheck
	#include "components/crash/content/browser/error_reporting/js_error_report_processor.h" // nogncheck
	#include "content/public/browser/site_instance.h"
	#include "content/public/browser/web_ui_controller.h"
	#include "content/public/test/browser_task_environment.h"
	#include "content/public/test/navigation_simulator.h"
	#include "content/public/test/test_browser_context.h"
	#include "content/public/test/test_renderer_host.h"
	#include "content/test/test_web_contents.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	#if BUILDFLAG(IS_LINUX) \|\| BUILDFLAG(IS_CHROMEOS)

	namespace content {

	namespace {
	using testing::Eq;
	using testing::Optional;

	class FakeJsErrorReportProcessor : public JsErrorReportProcessor {
	public:
	explicit FakeJsErrorReportProcessor(
	scoped_refptr<base::SingleThreadTaskRunner> task_runner)
	: task_runner_(std::move(task_runner)) {}

	// After calling this, expect all SendErrorReport's to use this
	// BrowserContext.
	void SetExpectedBrowserContext(BrowserContext* browser_context) {
	browser_context_ = browser_context;
	}

	void SendErrorReport(JavaScriptErrorReport error_report,
	base::OnceClosure completion_callback,
	BrowserContext* browser_context) override {
	CHECK_EQ(browser_context, browser_context_);
	last_error_report_ = std::move(error_report);
	++error_report_count_;
	task_runner_->PostTask(FROM_HERE, std::move(completion_callback));
	}

	const JavaScriptErrorReport& last_error_report() const {
	return last_error_report_;
	}

	int error_report_count() const { return error_report_count_; }

	// Make public for testing.
	using JsErrorReportProcessor::SetDefault;

	protected:
	~FakeJsErrorReportProcessor() override = default;

	private:
	scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
	JavaScriptErrorReport last_error_report_;
	int error_report_count_ = 0;
	raw_ptr<BrowserContext> browser_context_ = nullptr;
	};

	class MockWebUIController : public WebUIController {
	public:
	explicit MockWebUIController(WebUI* web_ui) : WebUIController(web_ui) {}

	bool IsJavascriptErrorReportingEnabled() override {
	return enable_javascript_error_reporting_;
	}
	void enable_javascript_error_reporting(
	bool enable_javascript_error_reporting) {
	enable_javascript_error_reporting_ = enable_javascript_error_reporting;
	}

	private:
	bool enable_javascript_error_reporting_ = true;

	WEB_UI_CONTROLLER_TYPE_DECL();
	};

	WEB_UI_CONTROLLER_TYPE_IMPL(MockWebUIController)

	} // namespace

	class WebUIMainFrameObserverTest : public RenderViewHostTestHarness {
	public:
	void SetUp() override {
	RenderViewHostTestHarness::SetUp();
	site_instance_ = SiteInstance::Create(browser_context());
	SetContents(TestWebContents::Create(browser_context(), site_instance_));
	// Since we just created the web_contents() pointer with
	// TestWebContents::Create, the static_casts are safe.
	web_ui_ = std::make_unique<WebUIImpl>(web_contents());
	web_ui_->SetRenderFrameHost(
	static_cast<TestWebContents*>(web_contents())->GetPrimaryMainFrame());
	web_ui_->SetController(
	std::make_unique<MockWebUIController>(web_ui_.get()));
	process()->Init();

	previous_processor_ = JsErrorReportProcessor::Get();
	processor_ = base::MakeRefCounted<FakeJsErrorReportProcessor>(
	task_environment()->GetMainThreadTaskRunner());
	FakeJsErrorReportProcessor::SetDefault(processor_);
	processor_->SetExpectedBrowserContext(browser_context());
	}

	void TearDown() override {
	FakeJsErrorReportProcessor::SetDefault(previous_processor_);

	// We have to destroy the site_instance_ before
	// RenderViewHostTestHarness::TearDown() destroys the
	// BrowserTaskEnvironment. We've gotten a lot of things that depend directly
	// or indirectly on BrowserTaskEnvironment, so just destroy everything we
	// can.
	previous_processor_.reset();
	processor_.reset();
	web_ui_.reset();
	site_instance_.reset();

	RenderViewHostTestHarness::TearDown();
	}

	// Simulate navigating to the WebUI page. Basically so that
	// WebUIMainFrameObserver::ReadyToCommitNavigation() gets called, since that
	// initializes the error handling.
	void NavigateToPage() {
	NavigationSimulator::NavigateAndCommitFromBrowser(web_contents(),
	GURL(kPageURL8));
	}

	// Calls the observer's OnDidAddMessageToConsole with the given arguments.
	// This is just here so that we don't need to FRIEND_TEST_ALL_PREFIXES for
	// each and every test.
	void CallOnDidAddMessageToConsole(
	RenderFrameHost* source_frame,
	blink::mojom::ConsoleMessageLevel log_level,
	const std::u16string& message,
	int32_t line_no,
	const std::u16string& source_id,
	const std::optional<std::u16string>& stack_trace) {
	web_ui_->GetWebUIMainFrameObserverForTest()->OnDidAddMessageToConsole(
	source_frame, log_level, message, line_no, source_id, stack_trace);
	}

	protected:
	scoped_refptr<SiteInstance> site_instance_;
	std::unique_ptr<WebUIImpl> web_ui_;
	scoped_refptr<FakeJsErrorReportProcessor> processor_;
	scoped_refptr<JsErrorReportProcessor> previous_processor_;

	static constexpr char kMessage8[] = "An Error Is Me";
	static constexpr char16_t kMessage16[] = u"An Error Is Me";
	static constexpr char kSourceURL8[] = "chrome://here.is.error/bad.js";
	static constexpr char16_t kSourceURL16[] = u"chrome://here.is.error/bad.js";
	static constexpr char kPageURL8[] = "chrome://here.is.error/index.html";
	static constexpr char kStackTrace8[] =
	"at badFunction (chrome://page/my.js:20:30)\n"
	"at poorCaller (chrome://page/my.js:50:10)\n";
	static constexpr char16_t kStackTrace16[] =
	u"at badFunction (chrome://page/my.js:20:30)\n"
	u"at poorCaller (chrome://page/my.js:50:10)\n";
	};

	constexpr char WebUIMainFrameObserverTest::kMessage8[];
	constexpr char16_t WebUIMainFrameObserverTest::kMessage16[];
	constexpr char WebUIMainFrameObserverTest::kSourceURL8[];
	constexpr char16_t WebUIMainFrameObserverTest::kSourceURL16[];
	constexpr char WebUIMainFrameObserverTest::kPageURL8[];
	constexpr char WebUIMainFrameObserverTest::kStackTrace8[];
	constexpr char16_t WebUIMainFrameObserverTest::kStackTrace16[];

	TEST_F(WebUIMainFrameObserverTest, ErrorReported) {
	NavigateToPage();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 1);
	EXPECT_EQ(processor_->last_error_report().message, kMessage8);
	EXPECT_EQ(processor_->last_error_report().url, kSourceURL8);
	EXPECT_EQ(processor_->last_error_report().page_url, kPageURL8);
	EXPECT_EQ(processor_->last_error_report().source_system,
	JavaScriptErrorReport::SourceSystem::kWebUIObserver);
	EXPECT_THAT(processor_->last_error_report().stack_trace,
	Optional(Eq(kStackTrace8)));
	// WebUI should use default product & version.
	EXPECT_EQ(processor_->last_error_report().product, "");
	EXPECT_EQ(processor_->last_error_report().version, "");
	EXPECT_EQ(*processor_->last_error_report().line_number, 5);
	EXPECT_FALSE(processor_->last_error_report().column_number);
	EXPECT_FALSE(processor_->last_error_report().app_locale);
	EXPECT_TRUE(processor_->last_error_report().send_to_production_servers);
	}

	TEST_F(WebUIMainFrameObserverTest, NoStackTrace) {
	NavigateToPage();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, std::nullopt);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 1);
	EXPECT_EQ(processor_->last_error_report().stack_trace, std::nullopt);
	}

	TEST_F(WebUIMainFrameObserverTest, NonErrorsIgnored) {
	NavigateToPage();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kWarning,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kInfo,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kVerbose,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 0);
	}

	TEST_F(WebUIMainFrameObserverTest, NoProcessorDoesntCrash) {
	NavigateToPage();
	FakeJsErrorReportProcessor::SetDefault(nullptr);
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	}

	TEST_F(WebUIMainFrameObserverTest, NotSentIfInvalidURL) {
	NavigateToPage();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, u"invalid URL", kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 0);
	}

	TEST_F(WebUIMainFrameObserverTest, NotSentIfDisabledForPage) {
	static_cast<MockWebUIController*>(web_ui_->GetController())
	->enable_javascript_error_reporting(false);
	NavigateToPage();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 0);
	}

	TEST_F(WebUIMainFrameObserverTest, URLPathIsPreservedOtherPartsRemoved) {
	NavigateToPage();
	struct URLTest {
	const char16_t* const input;
	const char* const expected;
	};
	const URLTest kTests[] = {
	// No path still has no path.
	{u"chrome://version", "chrome://version/"},
	{u"chrome://version/", "chrome://version/"},
	// Path is kept.
	{u"chrome://discards/graph", "chrome://discards/graph"},
	{u"chrome://discards/graph/", "chrome://discards/graph/"},
	// Longer paths are kept.
	{u"chrome://discards/graph/a/b/c/d", "chrome://discards/graph/a/b/c/d"},
	// Queries are removed, with or without a path.
	{u"chrome://bookmarks/?q=chromium", "chrome://bookmarks/"},
	{u"chrome://bookmarks/add?q=chromium", "chrome://bookmarks/add"},
	{u"chrome://bookmarks/add/?q=chromium", "chrome://bookmarks/add/"},
	// Fragments are removed, with or without a path.
	{u"chrome://flags/#tab-groups", "chrome://flags/"},
	{u"chrome://flags/available/#tab-groups", "chrome://flags/available/"},
	// Queries & fragments are removed.
	{u"chrome://bookmarks/add?q=chromium#code", "chrome://bookmarks/add"},
	// User name and password are removed. (It's weird to have a user name or
	// password on a chrome URL, but otherwise we get blocked by the
	// no-non-chrome-URLs check)
	{u"chrome://chronos:test0000@version/Home", "chrome://version/Home"},
	};

	for (const URLTest& test : kTests) {
	int previous_count = processor_->error_report_count();
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, test.input, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), previous_count + 1)
	<< "for " << test.input;
	EXPECT_EQ(processor_->last_error_report().url, test.expected)
	<< "for " << test.input;
	}
	}

	TEST_F(WebUIMainFrameObserverTest, PageURLAlsoRedacted) {
	constexpr char kPageWithQueryAndFragment[] =
	"chrome://bookmarks/add?q=chromium#code";
	NavigationSimulator::NavigateAndCommitFromBrowser(
	web_contents(), GURL(kPageWithQueryAndFragment));
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 1);
	EXPECT_EQ(processor_->last_error_report().page_url, "chrome://bookmarks/add");
	}

	TEST_F(WebUIMainFrameObserverTest, ErrorsNotReportedInOtherFrames) {
	NavigateToPage();
	auto another_contents =
	TestWebContents::Create(browser_context(), site_instance_);
	CHECK(another_contents->GetPrimaryMainFrame());
	CallOnDidAddMessageToConsole(another_contents->GetPrimaryMainFrame(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, kSourceURL16, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 0);
	}

	TEST_F(WebUIMainFrameObserverTest, ErrorsNotReportedForNonChromeURLs) {
	NavigateToPage();
	const char16_t* const kNonChromeSourceURLs[] = {
	u"chrome-untrusted://media-app",
	u"chrome-error://chromewebdata/",
	u"chrome-extension://abc123/",
	u"about:blank",
	};

	for (const auto* url : kNonChromeSourceURLs) {
	CallOnDidAddMessageToConsole(web_ui_->GetRenderFrameHost(),
	blink::mojom::ConsoleMessageLevel::kError,
	kMessage16, 5, url, kStackTrace16);
	task_environment()->RunUntilIdle();
	EXPECT_EQ(processor_->error_report_count(), 0) << url;
	}
	}

	} // namespace content

	#endif // BUILDFLAG(IS_LINUX) \|\| BUILDFLAG(IS_CHROMEOS)