From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- dom/reporting/CrashReport.cpp | 59 ++ dom/reporting/CrashReport.h | 23 + dom/reporting/DeprecationReportBody.cpp | 81 +++ dom/reporting/DeprecationReportBody.h | 55 ++ dom/reporting/EndpointForReportChild.cpp | 30 + dom/reporting/EndpointForReportChild.h | 32 + dom/reporting/EndpointForReportParent.cpp | 44 ++ dom/reporting/EndpointForReportParent.h | 42 ++ dom/reporting/FeaturePolicyViolationReportBody.cpp | 79 +++ dom/reporting/FeaturePolicyViolationReportBody.h | 53 ++ dom/reporting/PEndpointForReport.ipdl | 20 + dom/reporting/Report.cpp | 47 ++ dom/reporting/Report.h | 59 ++ dom/reporting/ReportBody.cpp | 27 + dom/reporting/ReportBody.h | 44 ++ dom/reporting/ReportDeliver.cpp | 410 +++++++++++ dom/reporting/ReportDeliver.h | 65 ++ dom/reporting/ReportingHeader.cpp | 779 +++++++++++++++++++++ dom/reporting/ReportingHeader.h | 142 ++++ dom/reporting/ReportingObserver.cpp | 152 ++++ dom/reporting/ReportingObserver.h | 77 ++ dom/reporting/ReportingUtils.cpp | 45 ++ dom/reporting/ReportingUtils.h | 28 + dom/reporting/TestingDeprecatedInterface.cpp | 48 ++ dom/reporting/TestingDeprecatedInterface.h | 50 ++ dom/reporting/moz.build | 51 ++ dom/reporting/tests/browser.ini | 6 + dom/reporting/tests/browser_cleanup.js | 276 ++++++++ dom/reporting/tests/common_deprecated.js | 214 ++++++ dom/reporting/tests/delivering.sjs | 113 +++ dom/reporting/tests/empty.html | 1 + dom/reporting/tests/gtest/TestReportToParser.cpp | 418 +++++++++++ dom/reporting/tests/gtest/moz.build | 13 + dom/reporting/tests/iframe_delivering.html | 92 +++ dom/reporting/tests/mochitest.ini | 15 + dom/reporting/tests/test_delivering.html | 45 ++ dom/reporting/tests/test_deprecated.html | 51 ++ dom/reporting/tests/test_memoryPressure.html | 33 + dom/reporting/tests/worker_delivering.js | 5 + dom/reporting/tests/worker_deprecated.js | 28 + 40 files changed, 3852 insertions(+) create mode 100644 dom/reporting/CrashReport.cpp create mode 100644 dom/reporting/CrashReport.h create mode 100644 dom/reporting/DeprecationReportBody.cpp create mode 100644 dom/reporting/DeprecationReportBody.h create mode 100644 dom/reporting/EndpointForReportChild.cpp create mode 100644 dom/reporting/EndpointForReportChild.h create mode 100644 dom/reporting/EndpointForReportParent.cpp create mode 100644 dom/reporting/EndpointForReportParent.h create mode 100644 dom/reporting/FeaturePolicyViolationReportBody.cpp create mode 100644 dom/reporting/FeaturePolicyViolationReportBody.h create mode 100644 dom/reporting/PEndpointForReport.ipdl create mode 100644 dom/reporting/Report.cpp create mode 100644 dom/reporting/Report.h create mode 100644 dom/reporting/ReportBody.cpp create mode 100644 dom/reporting/ReportBody.h create mode 100644 dom/reporting/ReportDeliver.cpp create mode 100644 dom/reporting/ReportDeliver.h create mode 100644 dom/reporting/ReportingHeader.cpp create mode 100644 dom/reporting/ReportingHeader.h create mode 100644 dom/reporting/ReportingObserver.cpp create mode 100644 dom/reporting/ReportingObserver.h create mode 100644 dom/reporting/ReportingUtils.cpp create mode 100644 dom/reporting/ReportingUtils.h create mode 100644 dom/reporting/TestingDeprecatedInterface.cpp create mode 100644 dom/reporting/TestingDeprecatedInterface.h create mode 100644 dom/reporting/moz.build create mode 100644 dom/reporting/tests/browser.ini create mode 100644 dom/reporting/tests/browser_cleanup.js create mode 100644 dom/reporting/tests/common_deprecated.js create mode 100644 dom/reporting/tests/delivering.sjs create mode 100644 dom/reporting/tests/empty.html create mode 100644 dom/reporting/tests/gtest/TestReportToParser.cpp create mode 100644 dom/reporting/tests/gtest/moz.build create mode 100644 dom/reporting/tests/iframe_delivering.html create mode 100644 dom/reporting/tests/mochitest.ini create mode 100644 dom/reporting/tests/test_delivering.html create mode 100644 dom/reporting/tests/test_deprecated.html create mode 100644 dom/reporting/tests/test_memoryPressure.html create mode 100644 dom/reporting/tests/worker_delivering.js create mode 100644 dom/reporting/tests/worker_deprecated.js (limited to 'dom/reporting') diff --git a/dom/reporting/CrashReport.cpp b/dom/reporting/CrashReport.cpp new file mode 100644 index 0000000000..9cfd5340d5 --- /dev/null +++ b/dom/reporting/CrashReport.cpp @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/CrashReport.h" + +#include "mozilla/dom/Navigator.h" +#include "mozilla/dom/ReportingHeader.h" +#include "mozilla/dom/ReportDeliver.h" +#include "mozilla/JSONStringWriteFuncs.h" +#include "nsIPrincipal.h" +#include "nsIURIMutator.h" +#include "nsString.h" + +namespace mozilla::dom { + +/* static */ +bool CrashReport::Deliver(nsIPrincipal* aPrincipal, bool aIsOOM) { + MOZ_ASSERT(aPrincipal); + + nsAutoCString endpoint_url; + ReportingHeader::GetEndpointForReport(u"default"_ns, aPrincipal, + endpoint_url); + if (endpoint_url.IsEmpty()) { + return false; + } + + nsCString safe_origin_spec; + aPrincipal->GetExposableSpec(safe_origin_spec); + + ReportDeliver::ReportData data; + data.mType = u"crash"_ns; + data.mGroupName = u"default"_ns; + CopyUTF8toUTF16(safe_origin_spec, data.mURL); + data.mCreationTime = TimeStamp::Now(); + + Navigator::GetUserAgent(nullptr, nullptr, Nothing(), data.mUserAgent); + data.mPrincipal = aPrincipal; + data.mFailures = 0; + data.mEndpointURL = endpoint_url; + + JSONStringWriteFunc body; + JSONWriter writer{body}; + + writer.Start(); + if (aIsOOM) { + writer.StringProperty("reason", "oom"); + } + writer.End(); + + data.mReportBodyJSON = std::move(body).StringRRef(); + + ReportDeliver::Fetch(data); + return true; +} + +} // namespace mozilla::dom diff --git a/dom/reporting/CrashReport.h b/dom/reporting/CrashReport.h new file mode 100644 index 0000000000..3a2ec64b05 --- /dev/null +++ b/dom/reporting/CrashReport.h @@ -0,0 +1,23 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_CrashReport_h +#define mozilla_dom_CrashReport_h + +#include "nsCOMPtr.h" + +class nsIPrincipal; + +namespace mozilla::dom { + +class CrashReport { + public: + static bool Deliver(nsIPrincipal* aPrincipal, bool aIsOOM); +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_CrashReport_h diff --git a/dom/reporting/DeprecationReportBody.cpp b/dom/reporting/DeprecationReportBody.cpp new file mode 100644 index 0000000000..1154121484 --- /dev/null +++ b/dom/reporting/DeprecationReportBody.cpp @@ -0,0 +1,81 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/DeprecationReportBody.h" +#include "mozilla/dom/ReportingBinding.h" +#include "mozilla/JSONWriter.h" + +namespace mozilla::dom { + +DeprecationReportBody::DeprecationReportBody( + nsIGlobalObject* aGlobal, const nsAString& aId, + const Nullable& aDate, const nsAString& aMessage, + const nsAString& aSourceFile, const Nullable& aLineNumber, + const Nullable& aColumnNumber) + : ReportBody(aGlobal), + mId(aId), + mDate(aDate), + mMessage(aMessage), + mSourceFile(aSourceFile), + mLineNumber(aLineNumber), + mColumnNumber(aColumnNumber) { + MOZ_ASSERT(aGlobal); +} + +DeprecationReportBody::~DeprecationReportBody() = default; + +JSObject* DeprecationReportBody::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) { + return DeprecationReportBody_Binding::Wrap(aCx, this, aGivenProto); +} + +void DeprecationReportBody::GetId(nsAString& aId) const { aId = mId; } + +Nullable DeprecationReportBody::GetAnticipatedRemoval() const { + return mDate; +} + +void DeprecationReportBody::GetMessage(nsAString& aMessage) const { + aMessage = mMessage; +} + +void DeprecationReportBody::GetSourceFile(nsAString& aSourceFile) const { + aSourceFile = mSourceFile; +} + +Nullable DeprecationReportBody::GetLineNumber() const { + return mLineNumber; +} + +Nullable DeprecationReportBody::GetColumnNumber() const { + return mColumnNumber; +} + +void DeprecationReportBody::ToJSON(JSONWriter& aWriter) const { + aWriter.StringProperty("id", NS_ConvertUTF16toUTF8(mId)); + // TODO: anticipatedRemoval? https://github.com/w3c/reporting/issues/132 + aWriter.StringProperty("message", NS_ConvertUTF16toUTF8(mMessage)); + + if (mSourceFile.IsEmpty()) { + aWriter.NullProperty("sourceFile"); + } else { + aWriter.StringProperty("sourceFile", NS_ConvertUTF16toUTF8(mSourceFile)); + } + + if (mLineNumber.IsNull()) { + aWriter.NullProperty("lineNumber"); + } else { + aWriter.IntProperty("lineNumber", mLineNumber.Value()); + } + + if (mColumnNumber.IsNull()) { + aWriter.NullProperty("columnNumber"); + } else { + aWriter.IntProperty("columnNumber", mColumnNumber.Value()); + } +} + +} // namespace mozilla::dom diff --git a/dom/reporting/DeprecationReportBody.h b/dom/reporting/DeprecationReportBody.h new file mode 100644 index 0000000000..9476899b12 --- /dev/null +++ b/dom/reporting/DeprecationReportBody.h @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_DeprecationReportBody_h +#define mozilla_dom_DeprecationReportBody_h + +#include "mozilla/dom/Nullable.h" +#include "mozilla/dom/ReportBody.h" +#include "nsString.h" + +namespace mozilla::dom { + +class DeprecationReportBody final : public ReportBody { + public: + DeprecationReportBody(nsIGlobalObject* aGlobal, const nsAString& aId, + const Nullable& aDate, + const nsAString& aMessage, const nsAString& aSourceFile, + const Nullable& aLineNumber, + const Nullable& aColumnNumber); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + void GetId(nsAString& aId) const; + + Nullable GetAnticipatedRemoval() const; + + void GetMessage(nsAString& aMessage) const; + + void GetSourceFile(nsAString& aSourceFile) const; + + Nullable GetLineNumber() const; + + Nullable GetColumnNumber() const; + + protected: + void ToJSON(JSONWriter& aJSONWriter) const override; + + private: + ~DeprecationReportBody(); + + const nsString mId; + const Nullable mDate; + const nsString mMessage; + const nsString mSourceFile; + const Nullable mLineNumber; + const Nullable mColumnNumber; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_DeprecationReportBody_h diff --git a/dom/reporting/EndpointForReportChild.cpp b/dom/reporting/EndpointForReportChild.cpp new file mode 100644 index 0000000000..ba10e077b1 --- /dev/null +++ b/dom/reporting/EndpointForReportChild.cpp @@ -0,0 +1,30 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/EndpointForReportChild.h" + +namespace mozilla::dom { + +EndpointForReportChild::EndpointForReportChild() = default; + +EndpointForReportChild::~EndpointForReportChild() = default; + +void EndpointForReportChild::Initialize( + const ReportDeliver::ReportData& aData) { + mReportData = aData; +} + +mozilla::ipc::IPCResult EndpointForReportChild::Recv__delete__( + const nsCString& aEndpointURL) { + if (!aEndpointURL.IsEmpty()) { + mReportData.mEndpointURL = aEndpointURL; + ReportDeliver::Fetch(mReportData); + } + + return IPC_OK(); +} + +} // namespace mozilla::dom diff --git a/dom/reporting/EndpointForReportChild.h b/dom/reporting/EndpointForReportChild.h new file mode 100644 index 0000000000..bdc2d9c819 --- /dev/null +++ b/dom/reporting/EndpointForReportChild.h @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_EndpointForReportChild_h +#define mozilla_dom_EndpointForReportChild_h + +#include "mozilla/dom/ReportDeliver.h" +#include "mozilla/dom/PEndpointForReportChild.h" + +namespace mozilla::dom { + +class EndpointForReport; + +class EndpointForReportChild final : public PEndpointForReportChild { + public: + EndpointForReportChild(); + ~EndpointForReportChild(); + + void Initialize(const ReportDeliver::ReportData& aReportData); + + mozilla::ipc::IPCResult Recv__delete__(const nsCString& aEndpointURL); + + private: + ReportDeliver::ReportData mReportData; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_EndpointForReportChild_h diff --git a/dom/reporting/EndpointForReportParent.cpp b/dom/reporting/EndpointForReportParent.cpp new file mode 100644 index 0000000000..445cbf1818 --- /dev/null +++ b/dom/reporting/EndpointForReportParent.cpp @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/EndpointForReportParent.h" +#include "mozilla/dom/ReportingHeader.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "mozilla/Unused.h" +#include "nsIThread.h" +#include "nsThreadUtils.h" + +namespace mozilla::dom { + +EndpointForReportParent::EndpointForReportParent() + : mPBackgroundThread(NS_GetCurrentThread()), mActive(true) {} + +EndpointForReportParent::~EndpointForReportParent() = default; + +void EndpointForReportParent::ActorDestroy(ActorDestroyReason aWhy) { + mActive = false; +} + +void EndpointForReportParent::Run( + const nsAString& aGroupName, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo) { + RefPtr self = this; + + NS_DispatchToMainThread(NS_NewRunnableFunction( + "EndpointForReportParent::Run", + [self, aGroupName = nsString(aGroupName), aPrincipalInfo]() { + nsAutoCString uri; + ReportingHeader::GetEndpointForReport(aGroupName, aPrincipalInfo, uri); + self->mPBackgroundThread->Dispatch(NS_NewRunnableFunction( + "EndpointForReportParent::Answer", [self, uri]() { + if (self->mActive) { + Unused << self->Send__delete__(self, uri); + } + })); + })); +} + +} // namespace mozilla::dom diff --git a/dom/reporting/EndpointForReportParent.h b/dom/reporting/EndpointForReportParent.h new file mode 100644 index 0000000000..42d5cce526 --- /dev/null +++ b/dom/reporting/EndpointForReportParent.h @@ -0,0 +1,42 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_EndpointForReportParent_h +#define mozilla_dom_EndpointForReportParent_h + +#include "mozilla/dom/PEndpointForReportParent.h" + +namespace mozilla { +namespace ipc { +class PrincipalInfo; +} + +namespace dom { + +class EndpointForReport; + +class EndpointForReportParent final : public PEndpointForReportParent { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(EndpointForReportParent) + + EndpointForReportParent(); + + void Run(const nsAString& aGroupName, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo); + + private: + ~EndpointForReportParent(); + + void ActorDestroy(ActorDestroyReason aWhy) override; + + nsCOMPtr mPBackgroundThread; + bool mActive; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_EndpointForReportParent_h diff --git a/dom/reporting/FeaturePolicyViolationReportBody.cpp b/dom/reporting/FeaturePolicyViolationReportBody.cpp new file mode 100644 index 0000000000..a8c46bf6ed --- /dev/null +++ b/dom/reporting/FeaturePolicyViolationReportBody.cpp @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/FeaturePolicyViolationReportBody.h" + +#include "mozilla/JSONWriter.h" +#include "mozilla/dom/FeaturePolicyBinding.h" + +namespace mozilla::dom { + +FeaturePolicyViolationReportBody::FeaturePolicyViolationReportBody( + nsIGlobalObject* aGlobal, const nsAString& aFeatureId, + const nsAString& aSourceFile, const Nullable& aLineNumber, + const Nullable& aColumnNumber, const nsAString& aDisposition) + : ReportBody(aGlobal), + mFeatureId(aFeatureId), + mSourceFile(aSourceFile), + mLineNumber(aLineNumber), + mColumnNumber(aColumnNumber), + mDisposition(aDisposition) {} + +FeaturePolicyViolationReportBody::~FeaturePolicyViolationReportBody() = default; + +JSObject* FeaturePolicyViolationReportBody::WrapObject( + JSContext* aCx, JS::Handle aGivenProto) { + return FeaturePolicyViolationReportBody_Binding::Wrap(aCx, this, aGivenProto); +} + +void FeaturePolicyViolationReportBody::GetFeatureId( + nsAString& aFeatureId) const { + aFeatureId = mFeatureId; +} + +void FeaturePolicyViolationReportBody::GetSourceFile( + nsAString& aSourceFile) const { + aSourceFile = mSourceFile; +} + +Nullable FeaturePolicyViolationReportBody::GetLineNumber() const { + return mLineNumber; +} + +Nullable FeaturePolicyViolationReportBody::GetColumnNumber() const { + return mColumnNumber; +} + +void FeaturePolicyViolationReportBody::GetDisposition( + nsAString& aDisposition) const { + aDisposition = mDisposition; +} + +void FeaturePolicyViolationReportBody::ToJSON(JSONWriter& aWriter) const { + aWriter.StringProperty("featureId", NS_ConvertUTF16toUTF8(mFeatureId)); + + if (mSourceFile.IsEmpty()) { + aWriter.NullProperty("sourceFile"); + } else { + aWriter.StringProperty("sourceFile", NS_ConvertUTF16toUTF8(mSourceFile)); + } + + if (mLineNumber.IsNull()) { + aWriter.NullProperty("lineNumber"); + } else { + aWriter.IntProperty("lineNumber", mLineNumber.Value()); + } + + if (mColumnNumber.IsNull()) { + aWriter.NullProperty("columnNumber"); + } else { + aWriter.IntProperty("columnNumber", mColumnNumber.Value()); + } + + aWriter.StringProperty("disposition", NS_ConvertUTF16toUTF8(mDisposition)); +} + +} // namespace mozilla::dom diff --git a/dom/reporting/FeaturePolicyViolationReportBody.h b/dom/reporting/FeaturePolicyViolationReportBody.h new file mode 100644 index 0000000000..bf6f749256 --- /dev/null +++ b/dom/reporting/FeaturePolicyViolationReportBody.h @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_FeaturePolicyViolationReportBody_h +#define mozilla_dom_FeaturePolicyViolationReportBody_h + +#include "mozilla/dom/ReportBody.h" +#include "mozilla/dom/Nullable.h" +#include "nsString.h" + +namespace mozilla::dom { + +class FeaturePolicyViolationReportBody final : public ReportBody { + public: + FeaturePolicyViolationReportBody(nsIGlobalObject* aGlobal, + const nsAString& aFeatureId, + const nsAString& aSourceFile, + const Nullable& aLineNumber, + const Nullable& aColumnNumber, + const nsAString& aDisposition); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + void GetFeatureId(nsAString& aFeatureId) const; + + void GetSourceFile(nsAString& aSourceFile) const; + + Nullable GetLineNumber() const; + + Nullable GetColumnNumber() const; + + void GetDisposition(nsAString& aDisposition) const; + + protected: + void ToJSON(JSONWriter& aJSONWriter) const override; + + private: + ~FeaturePolicyViolationReportBody(); + + const nsString mFeatureId; + const nsString mSourceFile; + const Nullable mLineNumber; + const Nullable mColumnNumber; + const nsString mDisposition; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_FeaturePolicyViolationReportBody_h diff --git a/dom/reporting/PEndpointForReport.ipdl b/dom/reporting/PEndpointForReport.ipdl new file mode 100644 index 0000000000..e04897402b --- /dev/null +++ b/dom/reporting/PEndpointForReport.ipdl @@ -0,0 +1,20 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +include protocol PBackground; + +namespace mozilla { +namespace dom { + +[ManualDealloc] +protocol PEndpointForReport +{ + manager PBackground; + +child: + async __delete__(nsCString endpointURL); +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/reporting/Report.cpp b/dom/reporting/Report.cpp new file mode 100644 index 0000000000..3fae46709a --- /dev/null +++ b/dom/reporting/Report.cpp @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/Report.h" +#include "mozilla/dom/ReportBody.h" +#include "mozilla/dom/ReportingBinding.h" +#include "nsIGlobalObject.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Report, mGlobal, mBody) +NS_IMPL_CYCLE_COLLECTING_ADDREF(Report) +NS_IMPL_CYCLE_COLLECTING_RELEASE(Report) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Report) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +Report::Report(nsIGlobalObject* aGlobal, const nsAString& aType, + const nsAString& aURL, ReportBody* aBody) + : mGlobal(aGlobal), mType(aType), mURL(aURL), mBody(aBody) { + MOZ_ASSERT(aGlobal); +} + +Report::~Report() = default; + +already_AddRefed Report::Clone() { + RefPtr report = new Report(mGlobal, mType, mURL, mBody); + return report.forget(); +} + +JSObject* Report::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) { + return Report_Binding::Wrap(aCx, this, aGivenProto); +} + +void Report::GetType(nsAString& aType) const { aType = mType; } + +void Report::GetUrl(nsAString& aURL) const { aURL = mURL; } + +ReportBody* Report::GetBody() const { return mBody; } + +} // namespace mozilla::dom diff --git a/dom/reporting/Report.h b/dom/reporting/Report.h new file mode 100644 index 0000000000..e139e27858 --- /dev/null +++ b/dom/reporting/Report.h @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_Report_h +#define mozilla_dom_Report_h + +#include "js/TypeDecls.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/RefPtr.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsISupports.h" +#include "nsString.h" +#include "nsWrapperCache.h" + +class nsIGlobalObject; + +namespace mozilla::dom { + +class ReportBody; + +class Report final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(Report) + + Report(nsIGlobalObject* aGlobal, const nsAString& aType, + const nsAString& aURL, ReportBody* aBody); + + already_AddRefed Clone(); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + nsIGlobalObject* GetParentObject() const { return mGlobal; } + + void GetType(nsAString& aType) const; + + void GetUrl(nsAString& aURL) const; + + ReportBody* GetBody() const; + + private: + ~Report(); + + nsCOMPtr mGlobal; + + const nsString mType; + const nsString mURL; + RefPtr mBody; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_Report_h diff --git a/dom/reporting/ReportBody.cpp b/dom/reporting/ReportBody.cpp new file mode 100644 index 0000000000..ef4330916e --- /dev/null +++ b/dom/reporting/ReportBody.cpp @@ -0,0 +1,27 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/ReportBody.h" +#include "nsIGlobalObject.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ReportBody, mGlobal) +NS_IMPL_CYCLE_COLLECTING_ADDREF(ReportBody) +NS_IMPL_CYCLE_COLLECTING_RELEASE(ReportBody) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReportBody) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +ReportBody::ReportBody(nsIGlobalObject* aGlobal) : mGlobal(aGlobal) { + MOZ_ASSERT(aGlobal); +} + +ReportBody::~ReportBody() = default; + +} // namespace mozilla::dom diff --git a/dom/reporting/ReportBody.h b/dom/reporting/ReportBody.h new file mode 100644 index 0000000000..9043dba16d --- /dev/null +++ b/dom/reporting/ReportBody.h @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ReportBody_h +#define mozilla_dom_ReportBody_h + +#include "mozilla/Assertions.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsISupports.h" +#include "nsWrapperCache.h" + +class nsIGlobalObject; + +namespace mozilla { + +class JSONWriter; + +namespace dom { + +class ReportBody : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ReportBody) + + explicit ReportBody(nsIGlobalObject* aGlobal); + + nsIGlobalObject* GetParentObject() const { return mGlobal; } + + virtual void ToJSON(JSONWriter& aJSONWriter) const = 0; + + protected: + virtual ~ReportBody(); + + nsCOMPtr mGlobal; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ReportBody_h diff --git a/dom/reporting/ReportDeliver.cpp b/dom/reporting/ReportDeliver.cpp new file mode 100644 index 0000000000..08a31e57ee --- /dev/null +++ b/dom/reporting/ReportDeliver.cpp @@ -0,0 +1,410 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/JSONStringWriteFuncs.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/dom/EndpointForReportChild.h" +#include "mozilla/dom/Fetch.h" +#include "mozilla/dom/Navigator.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/ReportBody.h" +#include "mozilla/dom/ReportDeliver.h" +#include "mozilla/dom/Request.h" +#include "mozilla/dom/RequestBinding.h" +#include "mozilla/dom/Response.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "nsGlobalWindowInner.h" +#include "nsIGlobalObject.h" +#include "nsIXPConnect.h" +#include "nsNetUtil.h" +#include "nsStringStream.h" + +namespace mozilla::dom { + +namespace { + +StaticRefPtr gReportDeliver; + +class ReportFetchHandler final : public PromiseNativeHandler { + public: + NS_DECL_ISUPPORTS + + explicit ReportFetchHandler( + const nsTArray& aReportData) + : mReports(aReportData.Clone()) {} + + void ResolvedCallback(JSContext* aCx, JS::Handle aValue, + ErrorResult& aRv) override { + if (!gReportDeliver) { + return; + } + + if (NS_WARN_IF(!aValue.isObject())) { + return; + } + + JS::Rooted obj(aCx, &aValue.toObject()); + MOZ_ASSERT(obj); + + { + Response* response = nullptr; + if (NS_WARN_IF(NS_FAILED(UNWRAP_OBJECT(Response, &obj, response)))) { + return; + } + + if (response->Status() == 410) { + mozilla::ipc::PBackgroundChild* actorChild = + mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread(); + + for (const auto& report : mReports) { + mozilla::ipc::PrincipalInfo principalInfo; + nsresult rv = + PrincipalToPrincipalInfo(report.mPrincipal, &principalInfo); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + actorChild->SendRemoveEndpoint(report.mGroupName, report.mEndpointURL, + principalInfo); + } + } + } + } + + void RejectedCallback(JSContext* aCx, JS::Handle aValue, + ErrorResult& aRv) override { + if (gReportDeliver) { + for (auto& report : mReports) { + ++report.mFailures; + gReportDeliver->AppendReportData(report); + } + } + } + + private: + ~ReportFetchHandler() = default; + + nsTArray mReports; +}; + +NS_IMPL_ISUPPORTS0(ReportFetchHandler) + +class ReportJSONWriter final : public JSONWriter { + public: + explicit ReportJSONWriter(JSONStringWriteFunc& aOutput) + : JSONWriter(aOutput) {} + + void JSONProperty(const Span& aProperty, + const Span& aJSON) { + Separator(); + PropertyNameAndColon(aProperty); + mWriter.Write(aJSON); + } +}; + +void SendReports(nsTArray& aReports, + const nsCString& aEndPointUrl, nsIPrincipal* aPrincipal) { + if (NS_WARN_IF(aReports.IsEmpty())) { + return; + } + + nsIXPConnect* xpc = nsContentUtils::XPConnect(); + MOZ_ASSERT(xpc, "This should never be null!"); + + nsCOMPtr globalObject; + { + AutoJSAPI jsapi; + jsapi.Init(); + + JSContext* cx = jsapi.cx(); + JS::Rooted sandbox(cx); + nsresult rv = xpc->CreateSandbox(cx, aPrincipal, sandbox.address()); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + // The JSContext is not in a realm, so CreateSandbox returned an unwrapped + // global. + MOZ_ASSERT(JS_IsGlobalObject(sandbox)); + + globalObject = xpc::NativeGlobal(sandbox); + } + + if (NS_WARN_IF(!globalObject)) { + return; + } + + // The body + JSONStringWriteFunc body; + ReportJSONWriter w(body); + + w.StartArrayElement(); + for (const auto& report : aReports) { + MOZ_ASSERT(report.mPrincipal == aPrincipal); + MOZ_ASSERT(report.mEndpointURL == aEndPointUrl); + w.StartObjectElement(); + w.IntProperty("age", + (TimeStamp::Now() - report.mCreationTime).ToMilliseconds()); + w.StringProperty("type", NS_ConvertUTF16toUTF8(report.mType)); + w.StringProperty("url", NS_ConvertUTF16toUTF8(report.mURL)); + w.StringProperty("user_agent", NS_ConvertUTF16toUTF8(report.mUserAgent)); + w.JSONProperty(MakeStringSpan("body"), + Span(report.mReportBodyJSON.Data(), + report.mReportBodyJSON.Length())); + w.EndObject(); + } + w.EndArray(); + + // The body as stream + nsCOMPtr streamBody; + nsresult rv = + NS_NewCStringInputStream(getter_AddRefs(streamBody), body.StringCRef()); + + // Headers + IgnoredErrorResult error; + RefPtr internalHeaders = + new InternalHeaders(HeadersGuardEnum::Request); + internalHeaders->Set("Content-Type"_ns, "application/reports+json"_ns, error); + if (NS_WARN_IF(error.Failed())) { + return; + } + + // URL and fragments + nsCOMPtr uri; + rv = NS_NewURI(getter_AddRefs(uri), aEndPointUrl); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsCOMPtr uriClone; + rv = NS_GetURIWithoutRef(uri, getter_AddRefs(uriClone)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsAutoCString uriSpec; + rv = uriClone->GetSpec(uriSpec); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsAutoCString uriFragment; + rv = uri->GetRef(uriFragment); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + auto internalRequest = MakeSafeRefPtr(uriSpec, uriFragment); + + internalRequest->SetMethod("POST"_ns); + internalRequest->SetBody(streamBody, body.StringCRef().Length()); + internalRequest->SetHeaders(internalHeaders); + internalRequest->SetSkipServiceWorker(); + // TODO: internalRequest->SetContentPolicyType(TYPE_REPORT); + internalRequest->SetMode(RequestMode::Cors); + internalRequest->SetCredentialsMode(RequestCredentials::Include); + + RefPtr request = + new Request(globalObject, std::move(internalRequest), nullptr); + + RequestOrUSVString fetchInput; + fetchInput.SetAsRequest() = request; + + RootedDictionary requestInit(RootingCx()); + RefPtr promise = FetchRequest(globalObject, fetchInput, requestInit, + CallerType::NonSystem, error); + if (error.Failed()) { + for (auto& report : aReports) { + ++report.mFailures; + if (gReportDeliver) { + gReportDeliver->AppendReportData(report); + } + } + return; + } + + RefPtr handler = new ReportFetchHandler(aReports); + promise->AppendNativeHandler(handler); +} + +} // namespace + +/* static */ +void ReportDeliver::Record(nsPIDOMWindowInner* aWindow, const nsAString& aType, + const nsAString& aGroupName, const nsAString& aURL, + ReportBody* aBody) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aBody); + + JSONStringWriteFunc reportBodyJSON; + ReportJSONWriter w(reportBodyJSON); + + w.Start(); + aBody->ToJSON(w); + w.End(); + + nsCOMPtr principal = + nsGlobalWindowInner::Cast(aWindow)->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + return; + } + + mozilla::ipc::PrincipalInfo principalInfo; + nsresult rv = PrincipalToPrincipalInfo(principal, &principalInfo); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + mozilla::ipc::PBackgroundChild* actorChild = + mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread(); + + PEndpointForReportChild* actor = + actorChild->SendPEndpointForReportConstructor(nsString(aGroupName), + principalInfo); + if (NS_WARN_IF(!actor)) { + return; + } + + ReportData data; + data.mType = aType; + data.mGroupName = aGroupName; + data.mURL = aURL; + data.mCreationTime = TimeStamp::Now(); + data.mReportBodyJSON = std::move(reportBodyJSON).StringRRef(); + data.mPrincipal = principal; + data.mFailures = 0; + + Navigator* navigator = aWindow->Navigator(); + MOZ_ASSERT(navigator); + + IgnoredErrorResult error; + navigator->GetUserAgent(data.mUserAgent, CallerType::NonSystem, error); + if (NS_WARN_IF(error.Failed())) { + return; + } + + static_cast(actor)->Initialize(data); +} + +/* static */ +void ReportDeliver::Fetch(const ReportData& aReportData) { + if (!gReportDeliver) { + RefPtr rd = new ReportDeliver(); + + nsCOMPtr obs = services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return; + } + + obs->AddObserver(rd, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + gReportDeliver = rd; + } + + gReportDeliver->AppendReportData(aReportData); +} + +void ReportDeliver::AppendReportData(const ReportData& aReportData) { + if (aReportData.mFailures > + StaticPrefs::dom_reporting_delivering_maxFailures()) { + return; + } + + if (NS_WARN_IF(!mReportQueue.AppendElement(aReportData, fallible))) { + return; + } + + while (mReportQueue.Length() > + StaticPrefs::dom_reporting_delivering_maxReports()) { + mReportQueue.RemoveElementAt(0); + } + + if (!mTimer) { + uint32_t timeout = StaticPrefs::dom_reporting_delivering_timeout() * 1000; + nsresult rv = NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, timeout, + nsITimer::TYPE_ONE_SHOT); + Unused << NS_WARN_IF(NS_FAILED(rv)); + } +} + +NS_IMETHODIMP +ReportDeliver::Notify(nsITimer* aTimer) { + mTimer = nullptr; + + nsTArray reports = std::move(mReportQueue); + + // group reports by endpoint and nsIPrincipal + std::map>, nsTArray> + reportsByPrincipal; + for (ReportData& report : reports) { + auto already_seen = + reportsByPrincipal.find({report.mEndpointURL, report.mPrincipal}); + if (already_seen == reportsByPrincipal.end()) { + reportsByPrincipal.emplace( + std::make_pair(report.mEndpointURL, report.mPrincipal), + nsTArray({report})); + } else { + already_seen->second.AppendElement(report); + } + } + + for (auto& iter : reportsByPrincipal) { + std::pair> key = iter.first; + nsTArray& value = iter.second; + nsCString url = key.first; + nsCOMPtr principal = key.second; + nsAutoCString u(url); + SendReports(value, url, principal); + } + + return NS_OK; +} + +NS_IMETHODIMP +ReportDeliver::GetName(nsACString& aName) { + aName.AssignLiteral("ReportDeliver"); + return NS_OK; +} + +NS_IMETHODIMP +ReportDeliver::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)); + + nsCOMPtr obs = services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return NS_OK; + } + + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } + + gReportDeliver = nullptr; + return NS_OK; +} + +ReportDeliver::ReportDeliver() = default; + +ReportDeliver::~ReportDeliver() = default; + +NS_INTERFACE_MAP_BEGIN(ReportDeliver) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsITimerCallback) + NS_INTERFACE_MAP_ENTRY(nsINamed) +NS_INTERFACE_MAP_END + +NS_IMPL_ADDREF(ReportDeliver) +NS_IMPL_RELEASE(ReportDeliver) + +} // namespace mozilla::dom diff --git a/dom/reporting/ReportDeliver.h b/dom/reporting/ReportDeliver.h new file mode 100644 index 0000000000..f5d3f0ab6e --- /dev/null +++ b/dom/reporting/ReportDeliver.h @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ReportDeliver_h +#define mozilla_dom_ReportDeliver_h + +#include "nsIObserver.h" +#include "nsITimer.h" +#include "nsString.h" +#include "nsTArray.h" + +// XXX Avoid including this here by moving function bodies to the cpp file +#include "nsIPrincipal.h" + +class nsIPrincipal; +class nsPIDOMWindowInner; + +namespace mozilla::dom { + +class ReportBody; + +class ReportDeliver final : public nsIObserver, + public nsITimerCallback, + public nsINamed { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + + struct ReportData { + nsString mType; + nsString mGroupName; + nsString mURL; + nsCString mEndpointURL; + nsString mUserAgent; + TimeStamp mCreationTime; + nsCString mReportBodyJSON; + nsCOMPtr mPrincipal; + uint32_t mFailures; + }; + + static void Record(nsPIDOMWindowInner* aWindow, const nsAString& aType, + const nsAString& aGroupName, const nsAString& aURL, + ReportBody* aBody); + + static void Fetch(const ReportData& aReportData); + + void AppendReportData(const ReportData& aReportData); + + private: + ReportDeliver(); + ~ReportDeliver(); + + nsTArray mReportQueue; + + nsCOMPtr mTimer; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_ReportDeliver_h diff --git a/dom/reporting/ReportingHeader.cpp b/dom/reporting/ReportingHeader.cpp new file mode 100644 index 0000000000..66a7c93e1e --- /dev/null +++ b/dom/reporting/ReportingHeader.cpp @@ -0,0 +1,779 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/ReportingHeader.h" + +#include "js/Array.h" // JS::GetArrayLength, JS::IsArrayObject +#include "js/JSON.h" +#include "js/PropertyAndElement.h" // JS_GetElement +#include "mozilla/dom/ReportingBinding.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/SimpleGlobalObject.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/OriginAttributes.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/StaticPtr.h" +#include "nsCOMPtr.h" +#include "nsContentUtils.h" +#include "nsIEffectiveTLDService.h" +#include "nsIHttpChannel.h" +#include "nsIHttpProtocolHandler.h" +#include "nsIObserverService.h" +#include "nsIPrincipal.h" +#include "nsIRandomGenerator.h" +#include "nsIScriptError.h" +#include "nsNetUtil.h" +#include "nsXULAppAPI.h" + +#define REPORTING_PURGE_ALL "reporting:purge-all" +#define REPORTING_PURGE_HOST "reporting:purge-host" + +namespace mozilla::dom { + +namespace { + +StaticRefPtr gReporting; + +} // namespace + +/* static */ +void ReportingHeader::Initialize() { + MOZ_ASSERT(!gReporting); + MOZ_ASSERT(NS_IsMainThread()); + + if (!XRE_IsParentProcess()) { + return; + } + + RefPtr service = new ReportingHeader(); + + nsCOMPtr obs = services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return; + } + + obs->AddObserver(service, NS_HTTP_ON_EXAMINE_RESPONSE_TOPIC, false); + obs->AddObserver(service, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + obs->AddObserver(service, "clear-origin-attributes-data", false); + obs->AddObserver(service, REPORTING_PURGE_HOST, false); + obs->AddObserver(service, REPORTING_PURGE_ALL, false); + + gReporting = service; +} + +/* static */ +void ReportingHeader::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + + if (!gReporting) { + return; + } + + RefPtr service = gReporting; + gReporting = nullptr; + + if (service->mCleanupTimer) { + service->mCleanupTimer->Cancel(); + service->mCleanupTimer = nullptr; + } + + nsCOMPtr obs = services::GetObserverService(); + if (NS_WARN_IF(!obs)) { + return; + } + + obs->RemoveObserver(service, NS_HTTP_ON_EXAMINE_RESPONSE_TOPIC); + obs->RemoveObserver(service, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + obs->RemoveObserver(service, "clear-origin-attributes-data"); + obs->RemoveObserver(service, REPORTING_PURGE_HOST); + obs->RemoveObserver(service, REPORTING_PURGE_ALL); +} + +ReportingHeader::ReportingHeader() = default; +ReportingHeader::~ReportingHeader() = default; + +NS_IMETHODIMP +ReportingHeader::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + Shutdown(); + return NS_OK; + } + + // Pref disabled. + if (!StaticPrefs::dom_reporting_header_enabled()) { + return NS_OK; + } + + if (!strcmp(aTopic, NS_HTTP_ON_EXAMINE_RESPONSE_TOPIC)) { + nsCOMPtr channel = do_QueryInterface(aSubject); + if (NS_WARN_IF(!channel)) { + return NS_OK; + } + + ReportingFromChannel(channel); + return NS_OK; + } + + if (!strcmp(aTopic, REPORTING_PURGE_HOST)) { + RemoveOriginsFromHost(nsDependentString(aData)); + return NS_OK; + } + + if (!strcmp(aTopic, "clear-origin-attributes-data")) { + OriginAttributesPattern pattern; + if (!pattern.Init(nsDependentString(aData))) { + NS_ERROR("Cannot parse origin attributes pattern"); + return NS_ERROR_FAILURE; + } + + RemoveOriginsFromOriginAttributesPattern(pattern); + return NS_OK; + } + + if (!strcmp(aTopic, REPORTING_PURGE_ALL)) { + RemoveOrigins(); + return NS_OK; + } + + return NS_ERROR_FAILURE; +} + +void ReportingHeader::ReportingFromChannel(nsIHttpChannel* aChannel) { + MOZ_ASSERT(aChannel); + + if (!StaticPrefs::dom_reporting_header_enabled()) { + return; + } + + // We want to use the final URI to check if Report-To should be allowed or + // not. + nsCOMPtr uri; + nsresult rv = aChannel->GetURI(getter_AddRefs(uri)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + if (!IsSecureURI(uri)) { + return; + } + + if (NS_UsePrivateBrowsing(aChannel)) { + return; + } + + nsAutoCString headerValue; + rv = aChannel->GetResponseHeader("Report-To"_ns, headerValue); + if (NS_FAILED(rv)) { + return; + } + + nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); + if (NS_WARN_IF(!ssm)) { + return; + } + + nsCOMPtr principal; + rv = ssm->GetChannelURIPrincipal(aChannel, getter_AddRefs(principal)); + if (NS_WARN_IF(NS_FAILED(rv)) || !principal) { + return; + } + + nsAutoCString origin; + rv = principal->GetOrigin(origin); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + UniquePtr client = ParseHeader(aChannel, uri, headerValue); + if (!client) { + return; + } + + // Here we override the previous data. + mOrigins.InsertOrUpdate(origin, std::move(client)); + + MaybeCreateCleanupTimer(); +} + +/* static */ UniquePtr ReportingHeader::ParseHeader( + nsIHttpChannel* aChannel, nsIURI* aURI, const nsACString& aHeaderValue) { + MOZ_ASSERT(aURI); + // aChannel can be null in gtest + + AutoJSAPI jsapi; + + JSObject* cleanGlobal = + SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::BindingDetail); + if (NS_WARN_IF(!cleanGlobal)) { + return nullptr; + } + + if (NS_WARN_IF(!jsapi.Init(cleanGlobal))) { + return nullptr; + } + + // WebIDL dictionary parses single items. Let's create a object to parse the + // header. + nsAutoString json; + json.AppendASCII("{ \"items\": ["); + json.Append(NS_ConvertUTF8toUTF16(aHeaderValue)); + json.AppendASCII("]}"); + + JSContext* cx = jsapi.cx(); + JS::Rooted jsonValue(cx); + bool ok = JS_ParseJSON(cx, json.BeginReading(), json.Length(), &jsonValue); + if (!ok) { + LogToConsoleInvalidJSON(aChannel, aURI); + return nullptr; + } + + dom::ReportingHeaderValue data; + if (!data.Init(cx, jsonValue)) { + LogToConsoleInvalidJSON(aChannel, aURI); + return nullptr; + } + + if (!data.mItems.WasPassed() || data.mItems.Value().IsEmpty()) { + return nullptr; + } + + UniquePtr client = MakeUnique(); + + for (const dom::ReportingItem& item : data.mItems.Value()) { + nsAutoString groupName; + + if (item.mGroup.isUndefined()) { + groupName.AssignLiteral("default"); + } else if (!item.mGroup.isString()) { + LogToConsoleInvalidNameItem(aChannel, aURI); + continue; + } else { + JS::Rooted groupStr(cx, item.mGroup.toString()); + MOZ_ASSERT(groupStr); + + nsAutoJSString string; + if (NS_WARN_IF(!string.init(cx, groupStr))) { + continue; + } + + groupName = string; + } + + if (!item.mMax_age.isNumber() || !item.mEndpoints.isObject()) { + LogToConsoleIncompleteItem(aChannel, aURI, groupName); + continue; + } + + JS::Rooted endpoints(cx, &item.mEndpoints.toObject()); + MOZ_ASSERT(endpoints); + + bool isArray = false; + if (!JS::IsArrayObject(cx, endpoints, &isArray) || !isArray) { + LogToConsoleIncompleteItem(aChannel, aURI, groupName); + continue; + } + + uint32_t endpointsLength; + if (!JS::GetArrayLength(cx, endpoints, &endpointsLength) || + endpointsLength == 0) { + LogToConsoleIncompleteItem(aChannel, aURI, groupName); + continue; + } + + const auto [begin, end] = client->mGroups.NonObservingRange(); + if (std::any_of(begin, end, [&groupName](const Group& group) { + return group.mName == groupName; + })) { + LogToConsoleDuplicateGroup(aChannel, aURI, groupName); + continue; + } + + Group* group = client->mGroups.AppendElement(); + group->mName = groupName; + group->mIncludeSubdomains = item.mInclude_subdomains; + group->mTTL = item.mMax_age.toNumber(); + group->mCreationTime = TimeStamp::Now(); + + for (uint32_t i = 0; i < endpointsLength; ++i) { + JS::Rooted element(cx); + if (!JS_GetElement(cx, endpoints, i, &element)) { + return nullptr; + } + + RootedDictionary endpoint(cx); + if (!endpoint.Init(cx, element)) { + LogToConsoleIncompleteEndpoint(aChannel, aURI, groupName); + continue; + } + + if (!endpoint.mUrl.isString() || + (!endpoint.mPriority.isUndefined() && + (!endpoint.mPriority.isNumber() || + endpoint.mPriority.toNumber() < 0)) || + (!endpoint.mWeight.isUndefined() && + (!endpoint.mWeight.isNumber() || endpoint.mWeight.toNumber() < 0))) { + LogToConsoleIncompleteEndpoint(aChannel, aURI, groupName); + continue; + } + + JS::Rooted endpointUrl(cx, endpoint.mUrl.toString()); + MOZ_ASSERT(endpointUrl); + + nsAutoJSString endpointString; + if (NS_WARN_IF(!endpointString.init(cx, endpointUrl))) { + continue; + } + + nsCOMPtr uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), endpointString); + if (NS_FAILED(rv)) { + LogToConsoleInvalidURLEndpoint(aChannel, aURI, groupName, + endpointString); + continue; + } + + Endpoint* ep = group->mEndpoints.AppendElement(); + ep->mUrl = uri; + ep->mPriority = + endpoint.mPriority.isUndefined() ? 1 : endpoint.mPriority.toNumber(); + ep->mWeight = + endpoint.mWeight.isUndefined() ? 1 : endpoint.mWeight.toNumber(); + } + } + + if (client->mGroups.IsEmpty()) { + return nullptr; + } + + return client; +} + +bool ReportingHeader::IsSecureURI(nsIURI* aURI) const { + MOZ_ASSERT(aURI); + + bool prioriAuthenticated = false; + if (NS_WARN_IF(NS_FAILED(NS_URIChainHasFlags( + aURI, nsIProtocolHandler::URI_IS_POTENTIALLY_TRUSTWORTHY, + &prioriAuthenticated)))) { + return false; + } + + return prioriAuthenticated; +} + +/* static */ +void ReportingHeader::LogToConsoleInvalidJSON(nsIHttpChannel* aChannel, + nsIURI* aURI) { + nsTArray params; + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderInvalidJSON", params); +} + +/* static */ +void ReportingHeader::LogToConsoleDuplicateGroup(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName) { + nsTArray params; + params.AppendElement(aName); + + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderDuplicateGroup", params); +} + +/* static */ +void ReportingHeader::LogToConsoleInvalidNameItem(nsIHttpChannel* aChannel, + nsIURI* aURI) { + nsTArray params; + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderInvalidNameItem", + params); +} + +/* static */ +void ReportingHeader::LogToConsoleIncompleteItem(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName) { + nsTArray params; + params.AppendElement(aName); + + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderInvalidItem", params); +} + +/* static */ +void ReportingHeader::LogToConsoleIncompleteEndpoint(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName) { + nsTArray params; + params.AppendElement(aName); + + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderInvalidEndpoint", + params); +} + +/* static */ +void ReportingHeader::LogToConsoleInvalidURLEndpoint(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName, + const nsAString& aURL) { + nsTArray params; + params.AppendElement(aURL); + params.AppendElement(aName); + + LogToConsoleInternal(aChannel, aURI, "ReportingHeaderInvalidURLEndpoint", + params); +} + +/* static */ +void ReportingHeader::LogToConsoleInternal(nsIHttpChannel* aChannel, + nsIURI* aURI, const char* aMsg, + const nsTArray& aParams) { + MOZ_ASSERT(aURI); + + if (!aChannel) { + // We are in a gtest. + return; + } + + uint64_t windowID = 0; + + nsresult rv = aChannel->GetTopLevelContentWindowId(&windowID); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + if (!windowID) { + nsCOMPtr loadGroup; + nsresult rv = aChannel->GetLoadGroup(getter_AddRefs(loadGroup)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + if (loadGroup) { + windowID = nsContentUtils::GetInnerWindowID(loadGroup); + } + } + + nsAutoString localizedMsg; + rv = nsContentUtils::FormatLocalizedString( + nsContentUtils::eSECURITY_PROPERTIES, aMsg, aParams, localizedMsg); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + rv = nsContentUtils::ReportToConsoleByWindowID( + localizedMsg, nsIScriptError::infoFlag, "Reporting"_ns, windowID, aURI); + Unused << NS_WARN_IF(NS_FAILED(rv)); +} + +/* static */ +void ReportingHeader::GetEndpointForReport( + const nsAString& aGroupName, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo, + nsACString& aEndpointURI) { + auto principalOrErr = PrincipalInfoToPrincipal(aPrincipalInfo); + if (NS_WARN_IF(principalOrErr.isErr())) { + return; + } + + nsCOMPtr principal = principalOrErr.unwrap(); + GetEndpointForReport(aGroupName, principal, aEndpointURI); +} + +/* static */ +void ReportingHeader::GetEndpointForReport(const nsAString& aGroupName, + nsIPrincipal* aPrincipal, + nsACString& aEndpointURI) { + MOZ_ASSERT(aEndpointURI.IsEmpty()); + + if (!gReporting) { + return; + } + + nsAutoCString origin; + nsresult rv = aPrincipal->GetOrigin(origin); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + Client* client = gReporting->mOrigins.Get(origin); + if (!client) { + return; + } + + const auto [begin, end] = client->mGroups.NonObservingRange(); + const auto foundIt = std::find_if( + begin, end, + [&aGroupName](const Group& group) { return group.mName == aGroupName; }); + if (foundIt != end) { + GetEndpointForReportInternal(*foundIt, aEndpointURI); + } + + // XXX More explicitly report an error if not found? +} + +/* static */ +void ReportingHeader::GetEndpointForReportInternal( + const ReportingHeader::Group& aGroup, nsACString& aEndpointURI) { + TimeDuration diff = TimeStamp::Now() - aGroup.mCreationTime; + if (diff.ToSeconds() > aGroup.mTTL) { + // Expired. + return; + } + + if (aGroup.mEndpoints.IsEmpty()) { + return; + } + + int64_t minPriority = -1; + uint32_t totalWeight = 0; + + for (const Endpoint& endpoint : aGroup.mEndpoints.NonObservingRange()) { + if (minPriority == -1 || minPriority > endpoint.mPriority) { + minPriority = endpoint.mPriority; + totalWeight = endpoint.mWeight; + } else if (minPriority == endpoint.mPriority) { + totalWeight += endpoint.mWeight; + } + } + + nsCOMPtr randomGenerator = + do_GetService("@mozilla.org/security/random-generator;1"); + if (NS_WARN_IF(!randomGenerator)) { + return; + } + + uint32_t randomNumber = 0; + + uint8_t* buffer; + nsresult rv = + randomGenerator->GenerateRandomBytes(sizeof(randomNumber), &buffer); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + memcpy(&randomNumber, buffer, sizeof(randomNumber)); + free(buffer); + + totalWeight = randomNumber % totalWeight; + + const auto [begin, end] = aGroup.mEndpoints.NonObservingRange(); + const auto foundIt = std::find_if( + begin, end, [minPriority, totalWeight](const Endpoint& endpoint) { + return minPriority == endpoint.mPriority && + totalWeight < endpoint.mWeight; + }); + if (foundIt != end) { + Unused << NS_WARN_IF(NS_FAILED(foundIt->mUrl->GetSpec(aEndpointURI))); + } + // XXX More explicitly report an error if not found? +} + +/* static */ +void ReportingHeader::RemoveEndpoint( + const nsAString& aGroupName, const nsACString& aEndpointURL, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo) { + if (!gReporting) { + return; + } + + nsCOMPtr uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), aEndpointURL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + auto principalOrErr = PrincipalInfoToPrincipal(aPrincipalInfo); + if (NS_WARN_IF(principalOrErr.isErr())) { + return; + } + + nsAutoCString origin; + rv = principalOrErr.unwrap()->GetOrigin(origin); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + Client* client = gReporting->mOrigins.Get(origin); + if (!client) { + return; + } + + // Scope for the group iterator. + { + nsTObserverArray::BackwardIterator iter(client->mGroups); + while (iter.HasMore()) { + const Group& group = iter.GetNext(); + if (group.mName != aGroupName) { + continue; + } + + // Scope for the endpoint iterator. + { + nsTObserverArray::BackwardIterator endpointIter( + group.mEndpoints); + while (endpointIter.HasMore()) { + const Endpoint& endpoint = endpointIter.GetNext(); + + bool equal = false; + rv = endpoint.mUrl->Equals(uri, &equal); + if (NS_WARN_IF(NS_FAILED(rv))) { + continue; + } + + if (equal) { + endpointIter.Remove(); + break; + } + } + } + + if (group.mEndpoints.IsEmpty()) { + iter.Remove(); + } + + break; + } + } + + if (client->mGroups.IsEmpty()) { + gReporting->mOrigins.Remove(origin); + gReporting->MaybeCancelCleanupTimer(); + } +} + +void ReportingHeader::RemoveOriginsFromHost(const nsAString& aHost) { + nsCOMPtr tldService = + do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID); + if (NS_WARN_IF(!tldService)) { + return; + } + + NS_ConvertUTF16toUTF8 host(aHost); + + for (auto iter = mOrigins.Iter(); !iter.Done(); iter.Next()) { + bool hasRootDomain = false; + nsresult rv = tldService->HasRootDomain(iter.Key(), host, &hasRootDomain); + if (NS_WARN_IF(NS_FAILED(rv)) || !hasRootDomain) { + continue; + } + + iter.Remove(); + } + + MaybeCancelCleanupTimer(); +} + +void ReportingHeader::RemoveOriginsFromOriginAttributesPattern( + const OriginAttributesPattern& aPattern) { + for (auto iter = mOrigins.Iter(); !iter.Done(); iter.Next()) { + nsAutoCString suffix; + OriginAttributes attr; + if (NS_WARN_IF(!attr.PopulateFromOrigin(iter.Key(), suffix))) { + continue; + } + + if (aPattern.Matches(attr)) { + iter.Remove(); + } + } + + MaybeCancelCleanupTimer(); +} + +void ReportingHeader::RemoveOrigins() { + mOrigins.Clear(); + MaybeCancelCleanupTimer(); +} + +void ReportingHeader::RemoveOriginsForTTL() { + TimeStamp now = TimeStamp::Now(); + + for (auto iter = mOrigins.Iter(); !iter.Done(); iter.Next()) { + Client* client = iter.UserData(); + + // Scope of the iterator. + { + nsTObserverArray::BackwardIterator groupIter(client->mGroups); + while (groupIter.HasMore()) { + const Group& group = groupIter.GetNext(); + TimeDuration diff = now - group.mCreationTime; + if (diff.ToSeconds() > group.mTTL) { + groupIter.Remove(); + return; + } + } + } + + if (client->mGroups.IsEmpty()) { + iter.Remove(); + } + } +} + +/* static */ +bool ReportingHeader::HasReportingHeaderForOrigin(const nsACString& aOrigin) { + if (!gReporting) { + return false; + } + + return gReporting->mOrigins.Contains(aOrigin); +} + +NS_IMETHODIMP +ReportingHeader::Notify(nsITimer* aTimer) { + mCleanupTimer = nullptr; + + RemoveOriginsForTTL(); + MaybeCreateCleanupTimer(); + + return NS_OK; +} + +NS_IMETHODIMP +ReportingHeader::GetName(nsACString& aName) { + aName.AssignLiteral("ReportingHeader"); + return NS_OK; +} + +void ReportingHeader::MaybeCreateCleanupTimer() { + if (mCleanupTimer) { + return; + } + + if (mOrigins.Count() == 0) { + return; + } + + uint32_t timeout = StaticPrefs::dom_reporting_cleanup_timeout() * 1000; + nsresult rv = + NS_NewTimerWithCallback(getter_AddRefs(mCleanupTimer), this, timeout, + nsITimer::TYPE_ONE_SHOT_LOW_PRIORITY); + Unused << NS_WARN_IF(NS_FAILED(rv)); +} + +void ReportingHeader::MaybeCancelCleanupTimer() { + if (!mCleanupTimer) { + return; + } + + if (mOrigins.Count() != 0) { + return; + } + + mCleanupTimer->Cancel(); + mCleanupTimer = nullptr; +} + +NS_INTERFACE_MAP_BEGIN(ReportingHeader) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsITimerCallback) + NS_INTERFACE_MAP_ENTRY(nsINamed) +NS_INTERFACE_MAP_END + +NS_IMPL_ADDREF(ReportingHeader) +NS_IMPL_RELEASE(ReportingHeader) + +} // namespace mozilla::dom diff --git a/dom/reporting/ReportingHeader.h b/dom/reporting/ReportingHeader.h new file mode 100644 index 0000000000..d0db5f612b --- /dev/null +++ b/dom/reporting/ReportingHeader.h @@ -0,0 +1,142 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ReportingHeader_h +#define mozilla_dom_ReportingHeader_h + +#include "mozilla/TimeStamp.h" +#include "nsClassHashtable.h" +#include "nsIObserver.h" +#include "nsITimer.h" +#include "nsTObserverArray.h" + +class nsIHttpChannel; +class nsIPrincipal; +class nsIURI; + +namespace mozilla { + +class OriginAttributesPattern; + +namespace ipc { +class PrincipalInfo; +} + +namespace dom { + +class ReportingHeader final : public nsIObserver, + public nsITimerCallback, + public nsINamed { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + + static void Initialize(); + + // Exposed structs for gtests + + struct Endpoint { + nsCOMPtr mUrl; + uint32_t mPriority; + uint32_t mWeight; + }; + + struct Group { + nsString mName; + bool mIncludeSubdomains; + int32_t mTTL; + TimeStamp mCreationTime; + nsTObserverArray mEndpoints; + }; + + struct Client { + nsTObserverArray mGroups; + }; + + static UniquePtr ParseHeader(nsIHttpChannel* aChannel, nsIURI* aURI, + const nsACString& aHeaderValue); + + static void GetEndpointForReport( + const nsAString& aGroupName, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo, + nsACString& aEndpointURI); + + static void GetEndpointForReport(const nsAString& aGroupName, + nsIPrincipal* aPrincipal, + nsACString& aEndpointURI); + + static void RemoveEndpoint(const nsAString& aGroupName, + const nsACString& aEndpointURL, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo); + + // ChromeOnly-WebIDL methods + + static bool HasReportingHeaderForOrigin(const nsACString& aOrigin); + + private: + ReportingHeader(); + ~ReportingHeader(); + + static void Shutdown(); + + // Checks if a channel contains a Report-To header and parses its value. + void ReportingFromChannel(nsIHttpChannel* aChannel); + + // This method checks if the protocol handler of the URI has the + // URI_IS_POTENTIALLY_TRUSTWORTHY flag. + bool IsSecureURI(nsIURI* aURI) const; + + void RemoveOriginsFromHost(const nsAString& aHost); + + void RemoveOriginsFromOriginAttributesPattern( + const OriginAttributesPattern& aPattern); + + void RemoveOrigins(); + + void RemoveOriginsForTTL(); + + void MaybeCreateCleanupTimer(); + + void MaybeCancelCleanupTimer(); + + static void LogToConsoleInvalidJSON(nsIHttpChannel* aChannel, nsIURI* aURI); + + static void LogToConsoleDuplicateGroup(nsIHttpChannel* aChannel, nsIURI* aURI, + const nsAString& aName); + + static void LogToConsoleInvalidNameItem(nsIHttpChannel* aChannel, + nsIURI* aURI); + + static void LogToConsoleIncompleteItem(nsIHttpChannel* aChannel, nsIURI* aURI, + const nsAString& aName); + + static void LogToConsoleIncompleteEndpoint(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName); + + static void LogToConsoleInvalidURLEndpoint(nsIHttpChannel* aChannel, + nsIURI* aURI, + const nsAString& aName, + const nsAString& aURL); + + static void LogToConsoleInternal(nsIHttpChannel* aChannel, nsIURI* aURI, + const char* aMsg, + const nsTArray& aParams); + + static void GetEndpointForReportInternal(const ReportingHeader::Group& aGrup, + nsACString& aEndpointURI); + + nsClassHashtable mOrigins; + + nsCOMPtr mCleanupTimer; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ReportingHeader_h diff --git a/dom/reporting/ReportingObserver.cpp b/dom/reporting/ReportingObserver.cpp new file mode 100644 index 0000000000..808824ce95 --- /dev/null +++ b/dom/reporting/ReportingObserver.cpp @@ -0,0 +1,152 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/ReportingObserver.h" +#include "mozilla/dom/Report.h" +#include "mozilla/dom/ReportingBinding.h" +#include "nsContentUtils.h" +#include "nsIGlobalObject.h" +#include "nsThreadUtils.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ReportingObserver) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ReportingObserver) + tmp->Disconnect(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mReports) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback) + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(ReportingObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReports) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +/* static */ +already_AddRefed ReportingObserver::Constructor( + const GlobalObject& aGlobal, ReportingObserverCallback& aCallback, + const ReportingObserverOptions& aOptions, ErrorResult& aRv) { + nsCOMPtr global = do_QueryInterface(aGlobal.GetAsSupports()); + MOZ_ASSERT(global); + + nsTArray types; + if (aOptions.mTypes.WasPassed()) { + types = aOptions.mTypes.Value(); + } + + RefPtr ro = + new ReportingObserver(global, aCallback, types, aOptions.mBuffered); + + return ro.forget(); +} + +ReportingObserver::ReportingObserver(nsIGlobalObject* aGlobal, + ReportingObserverCallback& aCallback, + const nsTArray& aTypes, + bool aBuffered) + : mGlobal(aGlobal), + mCallback(&aCallback), + mTypes(aTypes.Clone()), + mBuffered(aBuffered) { + MOZ_ASSERT(aGlobal); +} + +ReportingObserver::~ReportingObserver() { Disconnect(); } + +JSObject* ReportingObserver::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) { + return ReportingObserver_Binding::Wrap(aCx, this, aGivenProto); +} + +void ReportingObserver::Observe() { + mGlobal->RegisterReportingObserver(this, mBuffered); +} + +void ReportingObserver::Disconnect() { + if (mGlobal) { + mGlobal->UnregisterReportingObserver(this); + } +} + +void ReportingObserver::TakeRecords(nsTArray>& aRecords) { + mReports.SwapElements(aRecords); +} + +namespace { + +class ReportRunnable final : public DiscardableRunnable { + public: + explicit ReportRunnable(nsIGlobalObject* aGlobal) + : DiscardableRunnable("ReportRunnable"), mGlobal(aGlobal) {} + + // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT. See + // bug 1535398. + MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override { + MOZ_KnownLive(mGlobal)->NotifyReportingObservers(); + return NS_OK; + } + + private: + const nsCOMPtr mGlobal; +}; + +} // namespace + +void ReportingObserver::MaybeReport(Report* aReport) { + MOZ_ASSERT(aReport); + + if (!mTypes.IsEmpty()) { + nsAutoString type; + aReport->GetType(type); + + if (!mTypes.Contains(type)) { + return; + } + } + + bool wasEmpty = mReports.IsEmpty(); + + RefPtr report = aReport->Clone(); + MOZ_ASSERT(report); + + if (NS_WARN_IF(!mReports.AppendElement(report, fallible))) { + return; + } + + if (!wasEmpty) { + return; + } + + RefPtr r = new ReportRunnable(mGlobal); + NS_DispatchToCurrentThread(r); +} + +void ReportingObserver::MaybeNotify() { + if (mReports.IsEmpty()) { + return; + } + + // Let's take the ownership of the reports. + nsTArray> list = std::move(mReports); + + Sequence> reports; + for (Report* report : list) { + if (NS_WARN_IF(!reports.AppendElement(*report, fallible))) { + return; + } + } + + // We should report if this throws exception. But where? + RefPtr callback(mCallback); + callback->Call(reports, *this); +} + +void ReportingObserver::ForgetReports() { mReports.Clear(); } + +} // namespace mozilla::dom diff --git a/dom/reporting/ReportingObserver.h b/dom/reporting/ReportingObserver.h new file mode 100644 index 0000000000..b89ee33adf --- /dev/null +++ b/dom/reporting/ReportingObserver.h @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ReportingObserver_h +#define mozilla_dom_ReportingObserver_h + +#include "js/TypeDecls.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/Attributes.h" +#include "mozilla/RefPtr.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsISupports.h" +#include "nsStringFwd.h" +#include "nsTArray.h" +#include "nsWrapperCache.h" + +class nsIGlobalObject; + +namespace mozilla { +class ErrorResult; + +namespace dom { +class GlobalObject; +class Report; +class ReportingObserverCallback; +struct ReportingObserverOptions; + +class ReportingObserver final : public nsWrapperCache { + public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(ReportingObserver) + NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(ReportingObserver) + + static already_AddRefed Constructor( + const GlobalObject& aGlobal, ReportingObserverCallback& aCallback, + const ReportingObserverOptions& aOptions, ErrorResult& aRv); + + ReportingObserver(nsIGlobalObject* aGlobal, + ReportingObserverCallback& aCallback, + const nsTArray& aTypes, bool aBuffered); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + nsIGlobalObject* GetParentObject() const { return mGlobal; } + + void Observe(); + + void Disconnect(); + + void TakeRecords(nsTArray>& aRecords); + + void MaybeReport(Report* aReport); + + MOZ_CAN_RUN_SCRIPT void MaybeNotify(); + + void ForgetReports(); + + private: + ~ReportingObserver(); + + nsTArray> mReports; + + nsCOMPtr mGlobal; + RefPtr mCallback; + nsTArray mTypes; + bool mBuffered; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_ReportingObserver_h diff --git a/dom/reporting/ReportingUtils.cpp b/dom/reporting/ReportingUtils.cpp new file mode 100644 index 0000000000..ce7966a0a3 --- /dev/null +++ b/dom/reporting/ReportingUtils.cpp @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/ReportingUtils.h" +#include "mozilla/dom/ReportBody.h" +#include "mozilla/dom/ReportDeliver.h" +#include "mozilla/dom/Report.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "nsAtom.h" +#include "nsIGlobalObject.h" + +namespace mozilla::dom { + +/* static */ +void ReportingUtils::Report(nsIGlobalObject* aGlobal, nsAtom* aType, + const nsAString& aGroupName, const nsAString& aURL, + ReportBody* aBody) { + MOZ_ASSERT(aGlobal); + MOZ_ASSERT(aBody); + + nsDependentAtomString type(aType); + + RefPtr report = + new mozilla::dom::Report(aGlobal, type, aURL, aBody); + aGlobal->BroadcastReport(report); + + if (!NS_IsMainThread()) { + return; + } + + nsCOMPtr window = do_QueryInterface(aGlobal); + if (!window) { + return; + } + + // Send the report to the server. + ReportDeliver::Record(window, type, aGroupName, aURL, aBody); +} + +} // namespace mozilla::dom diff --git a/dom/reporting/ReportingUtils.h b/dom/reporting/ReportingUtils.h new file mode 100644 index 0000000000..ee9726bed7 --- /dev/null +++ b/dom/reporting/ReportingUtils.h @@ -0,0 +1,28 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ReportingUtils_h +#define mozilla_dom_ReportingUtils_h + +#include "nsString.h" + +class nsAtom; +class nsIGlobalObject; + +namespace mozilla::dom { + +class ReportBody; + +class ReportingUtils final { + public: + static void Report(nsIGlobalObject* aGlobal, nsAtom* aType, + const nsAString& aGroupName, const nsAString& aURL, + ReportBody* aBody); +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_ReportingUtils_h diff --git a/dom/reporting/TestingDeprecatedInterface.cpp b/dom/reporting/TestingDeprecatedInterface.cpp new file mode 100644 index 0000000000..9c03f3125d --- /dev/null +++ b/dom/reporting/TestingDeprecatedInterface.cpp @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/TestingDeprecatedInterface.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/ReportingBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(TestingDeprecatedInterface, mGlobal) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(TestingDeprecatedInterface) +NS_IMPL_CYCLE_COLLECTING_RELEASE(TestingDeprecatedInterface) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TestingDeprecatedInterface) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +/* static */ +already_AddRefed +TestingDeprecatedInterface::Constructor(const GlobalObject& aGlobal) { + nsCOMPtr global = do_QueryInterface(aGlobal.GetAsSupports()); + MOZ_ASSERT(global); + + RefPtr obj = + new TestingDeprecatedInterface(global); + return obj.forget(); +} + +TestingDeprecatedInterface::TestingDeprecatedInterface(nsIGlobalObject* aGlobal) + : mGlobal(aGlobal) {} + +TestingDeprecatedInterface::~TestingDeprecatedInterface() = default; + +JSObject* TestingDeprecatedInterface::WrapObject( + JSContext* aCx, JS::Handle aGivenProto) { + return TestingDeprecatedInterface_Binding::Wrap(aCx, this, aGivenProto); +} + +void TestingDeprecatedInterface::DeprecatedMethod() const {} + +bool TestingDeprecatedInterface::DeprecatedAttribute() const { return true; } + +} // namespace mozilla::dom diff --git a/dom/reporting/TestingDeprecatedInterface.h b/dom/reporting/TestingDeprecatedInterface.h new file mode 100644 index 0000000000..7056a91ed7 --- /dev/null +++ b/dom/reporting/TestingDeprecatedInterface.h @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_TestingDeprecatedInterface_h +#define mozilla_dom_TestingDeprecatedInterface_h + +#include "js/TypeDecls.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsISupports.h" +#include "nsWrapperCache.h" + +class nsIGlobalObject; + +namespace mozilla::dom { +class GlobalObject; + +class TestingDeprecatedInterface final : public nsISupports, + public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(TestingDeprecatedInterface) + + static already_AddRefed Constructor( + const GlobalObject& aGlobal); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + nsIGlobalObject* GetParentObject() const { return mGlobal; } + + void DeprecatedMethod() const; + + bool DeprecatedAttribute() const; + + private: + explicit TestingDeprecatedInterface(nsIGlobalObject* aGlobal); + ~TestingDeprecatedInterface(); + + nsCOMPtr mGlobal; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_TestingDeprecatedInterface_h diff --git a/dom/reporting/moz.build b/dom/reporting/moz.build new file mode 100644 index 0000000000..9b122e386b --- /dev/null +++ b/dom/reporting/moz.build @@ -0,0 +1,51 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +EXPORTS.mozilla.dom = [ + "CrashReport.h", + "DeprecationReportBody.h", + "EndpointForReportChild.h", + "EndpointForReportParent.h", + "FeaturePolicyViolationReportBody.h", + "Report.h", + "ReportBody.h", + "ReportDeliver.h", + "ReportingHeader.h", + "ReportingObserver.h", + "ReportingUtils.h", + "TestingDeprecatedInterface.h", +] + +UNIFIED_SOURCES += [ + "CrashReport.cpp", + "DeprecationReportBody.cpp", + "EndpointForReportChild.cpp", + "EndpointForReportParent.cpp", + "FeaturePolicyViolationReportBody.cpp", + "Report.cpp", + "ReportBody.cpp", + "ReportDeliver.cpp", + "ReportingHeader.cpp", + "ReportingObserver.cpp", + "ReportingUtils.cpp", + "TestingDeprecatedInterface.cpp", +] + +IPDL_SOURCES += [ + "PEndpointForReport.ipdl", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Security") + +FINAL_LIBRARY = "xul" + +MOCHITEST_MANIFESTS += ["tests/mochitest.ini"] +BROWSER_CHROME_MANIFESTS += ["tests/browser.ini"] + +TEST_DIRS += ["tests/gtest"] diff --git a/dom/reporting/tests/browser.ini b/dom/reporting/tests/browser.ini new file mode 100644 index 0000000000..f9cf651f75 --- /dev/null +++ b/dom/reporting/tests/browser.ini @@ -0,0 +1,6 @@ +[DEFAULT] +support-files = + delivering.sjs + empty.html + +[browser_cleanup.js] diff --git a/dom/reporting/tests/browser_cleanup.js b/dom/reporting/tests/browser_cleanup.js new file mode 100644 index 0000000000..e50b8db1da --- /dev/null +++ b/dom/reporting/tests/browser_cleanup.js @@ -0,0 +1,276 @@ +/* eslint-disable mozilla/no-arbitrary-setTimeout */ + +const TEST_HOST = "example.org"; +const TEST_DOMAIN = "https://" + TEST_HOST; +const TEST_PATH = "/browser/dom/reporting/tests/"; +const TEST_TOP_PAGE = TEST_DOMAIN + TEST_PATH + "empty.html"; +const TEST_SJS = TEST_DOMAIN + TEST_PATH + "delivering.sjs"; + +async function storeReportingHeader(browser, extraParams = "") { + await SpecialPowers.spawn( + browser, + [{ url: TEST_SJS, extraParams }], + async obj => { + await content + .fetch( + obj.url + + "?task=header" + + (obj.extraParams.length ? "&" + obj.extraParams : "") + ) + .then(r => r.text()) + .then(text => { + is(text, "OK", "Report-to header sent"); + }); + } + ); +} + +add_task(async function () { + await SpecialPowers.flushPrefEnv(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["dom.reporting.enabled", true], + ["dom.reporting.header.enabled", true], + ["dom.reporting.testing.enabled", true], + ["dom.reporting.delivering.timeout", 1], + ["dom.reporting.cleanup.timeout", 1], + ["privacy.userContext.enabled", true], + ], + }); +}); + +add_task(async function () { + info("Testing a total cleanup"); + + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser); + ok(ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), "We have data"); + + await new Promise(resolve => { + Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, value => + resolve() + ); + }); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before a full cleanup" + ); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function () { + info("Testing a total QuotaManager cleanup"); + + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser); + ok(ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), "We have data"); + + await new Promise(resolve => { + Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_REPORTS, value => + resolve() + ); + }); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before a reports cleanup" + ); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function () { + info("Testing a QuotaManager host cleanup"); + + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser); + ok(ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), "We have data"); + + await new Promise(resolve => { + Services.clearData.deleteDataFromHost( + TEST_HOST, + true, + Ci.nsIClearDataService.CLEAR_REPORTS, + value => resolve() + ); + }); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before a reports cleanup" + ); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function () { + info("Testing a 410 endpoint status"); + + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser, "410=true"); + ok(ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), "We have data"); + + await SpecialPowers.spawn(browser, [], async _ => { + let testingInterface = new content.TestingDeprecatedInterface(); + ok(!!testingInterface, "Created a deprecated interface"); + }); + + await new Promise((resolve, reject) => { + let count = 0; + let id = setInterval(_ => { + ++count; + if (count > 10) { + ok(false, "Something went wrong."); + clearInterval(id); + reject(); + } + + if (!ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN)) { + ok(true, "No data after a 410!"); + clearInterval(id); + resolve(); + } + }, 1000); + }); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function () { + info("Creating a new container"); + + let identity = ContextualIdentityService.create( + "Report-To-Test", + "fingerprint", + "orange" + ); + + info("Creating a new container tab"); + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE, { + userContextId: identity.userContextId, + }); + is( + tab.getAttribute("usercontextid"), + "" + identity.userContextId, + "New tab has the right UCI" + ); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser); + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "We don't have data for the origin" + ); + ok( + ChromeUtils.hasReportingHeaderForOrigin( + TEST_DOMAIN + "^userContextId=" + identity.userContextId + ), + "We have data for the origin + userContextId" + ); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); + + ContextualIdentityService.remove(identity.userContextId); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin( + TEST_DOMAIN + "^userContextId=" + identity.userContextId + ), + "No more data after a container removal" + ); +}); + +add_task(async function () { + info("TTL cleanup"); + + let tab = BrowserTestUtils.addTab(gBrowser, TEST_TOP_PAGE); + gBrowser.selectedTab = tab; + + let browser = gBrowser.getBrowserForTab(tab); + await BrowserTestUtils.browserLoaded(browser); + + ok( + !ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "No data before the test" + ); + + await storeReportingHeader(browser); + ok( + ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), + "We have data for the origin" + ); + + // Let's wait a bit. + await new Promise(resolve => { + setTimeout(resolve, 5000); + }); + + ok(!ChromeUtils.hasReportingHeaderForOrigin(TEST_DOMAIN), "No data anymore"); + + info("Removing the tab"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function () { + info("Cleaning up."); + await new Promise(resolve => { + Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, value => + resolve() + ); + }); +}); diff --git a/dom/reporting/tests/common_deprecated.js b/dom/reporting/tests/common_deprecated.js new file mode 100644 index 0000000000..1cee9481c2 --- /dev/null +++ b/dom/reporting/tests/common_deprecated.js @@ -0,0 +1,214 @@ +let testingInterface; + +// eslint-disable-next-line no-unused-vars +function test_deprecatedInterface() { + info("Testing DeprecatedTestingInterface report"); + return new Promise(resolve => { + let obs = new ReportingObserver((reports, o) => { + is(obs, o, "Same observer!"); + ok(reports.length == 1, "We have 1 report"); + + let report = reports[0]; + is(report.type, "deprecation", "Deprecation report received"); + is(report.url, location.href, "URL is location"); + ok(!!report.body, "The report has a body"); + ok( + report.body instanceof DeprecationReportBody, + "Correct type for the body" + ); + is( + report.body.id, + "DeprecatedTestingInterface", + "report.body.id matches DeprecatedTestingMethod" + ); + ok(!report.body.anticipatedRemoval, "We don't have a anticipatedRemoval"); + ok( + report.body.message.includes("TestingDeprecatedInterface"), + "We have a message" + ); + is( + report.body.sourceFile, + location.href + .split("?")[0] + .replace("test_deprecated.html", "common_deprecated.js") + .replace("worker_deprecated.js", "common_deprecated.js"), + "We have a sourceFile" + ); + is(report.body.lineNumber, 48, "We have a lineNumber"); + is(report.body.columnNumber, 23, "We have a columnNumber"); + + obs.disconnect(); + resolve(); + }); + ok(!!obs, "ReportingObserver is a thing"); + + obs.observe(); + ok(true, "ReportingObserver.observe() is callable"); + + testingInterface = new TestingDeprecatedInterface(); + ok(true, "Created a deprecated interface"); + }); +} + +// eslint-disable-next-line no-unused-vars +function test_deprecatedMethod() { + info("Testing DeprecatedTestingMethod report"); + return new Promise(resolve => { + let obs = new ReportingObserver((reports, o) => { + is(obs, o, "Same observer!"); + ok(reports.length == 1, "We have 1 report"); + + let report = reports[0]; + is(report.type, "deprecation", "Deprecation report received"); + is(report.url, location.href, "URL is location"); + ok(!!report.body, "The report has a body"); + ok( + report.body instanceof DeprecationReportBody, + "Correct type for the body" + ); + is( + report.body.id, + "DeprecatedTestingMethod", + "report.body.id matches DeprecatedTestingMethod" + ); + ok(!report.body.anticipatedRemoval, "We don't have a anticipatedRemoval"); + ok( + report.body.message.includes( + "TestingDeprecatedInterface.deprecatedMethod" + ), + "We have a message" + ); + is( + report.body.sourceFile, + location.href + .split("?")[0] + .replace("test_deprecated.html", "common_deprecated.js") + .replace("worker_deprecated.js", "common_deprecated.js"), + "We have a sourceFile" + ); + is(report.body.lineNumber, 100, "We have a lineNumber"); + is(report.body.columnNumber, 21, "We have a columnNumber"); + + obs.disconnect(); + resolve(); + }); + ok(!!obs, "ReportingObserver is a thing"); + + obs.observe(); + ok(true, "ReportingObserver.observe() is callable"); + + testingInterface.deprecatedMethod(); + ok(true, "Run a deprecated method."); + }); +} + +// eslint-disable-next-line no-unused-vars +function test_deprecatedMethodWithDataURI() { + info("Testing deprecatedMethodWithDataURI report"); + + const uri = `data:text/html,`; + + return new Promise((resolve, reject) => { + window.open(uri); + window.addEventListener("message", e => { + is(e.data, "passed", "The data URI is truncated"); + resolve(); + }); + }); +} + +// eslint-disable-next-line no-unused-vars +function test_deprecatedAttribute() { + info("Testing DeprecatedTestingAttribute report"); + return new Promise(resolve => { + let obs = new ReportingObserver((reports, o) => { + is(obs, o, "Same observer!"); + ok(reports.length == 1, "We have 1 report"); + + let report = reports[0]; + is(report.type, "deprecation", "Deprecation report received"); + is(report.url, location.href, "URL is location"); + ok(!!report.body, "The report has a body"); + ok( + report.body instanceof DeprecationReportBody, + "Correct type for the body" + ); + is( + report.body.id, + "DeprecatedTestingAttribute", + "report.body.id matches DeprecatedTestingAttribute" + ); + ok(!report.body.anticipatedRemoval, "We don't have a anticipatedRemoval"); + ok( + report.body.message.includes( + "TestingDeprecatedInterface.deprecatedAttribute" + ), + "We have a message" + ); + is( + report.body.sourceFile, + location.href + .split("?")[0] + .replace("test_deprecated.html", "common_deprecated.js") + .replace("worker_deprecated.js", "common_deprecated.js"), + "We have a sourceFile" + ); + is(report.body.lineNumber, 181, "We have a lineNumber"); + is(report.body.columnNumber, 4, "We have a columnNumber"); + + obs.disconnect(); + resolve(); + }); + ok(!!obs, "ReportingObserver is a thing"); + + obs.observe(); + ok(true, "ReportingObserver.observe() is callable"); + + ok(testingInterface.deprecatedAttribute, "Attributed called"); + }); +} + +// eslint-disable-next-line no-unused-vars +function test_takeRecords() { + info("Testing ReportingObserver.takeRecords()"); + let p = new Promise(resolve => { + let obs = new ReportingObserver((reports, o) => { + is(obs, o, "Same observer!"); + resolve(obs); + }); + ok(!!obs, "ReportingObserver is a thing"); + + obs.observe(); + ok(true, "ReportingObserver.observe() is callable"); + + testingInterface.deprecatedMethod(); + ok(true, "Run a deprecated method."); + }); + + return p.then(obs => { + let reports = obs.takeRecords(); + is(reports.length, 0, "No reports after an callback"); + + testingInterface.deprecatedAttribute + 1; + + reports = obs.takeRecords(); + ok(reports.length >= 1, "We have at least 1 report"); + + reports = obs.takeRecords(); + is(reports.length, 0, "No more reports"); + }); +} diff --git a/dom/reporting/tests/delivering.sjs b/dom/reporting/tests/delivering.sjs new file mode 100644 index 0000000000..9d378a9c82 --- /dev/null +++ b/dom/reporting/tests/delivering.sjs @@ -0,0 +1,113 @@ +const CC = Components.Constructor; +const BinaryInputStream = CC( + "@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream" +); + +Cu.importGlobalProperties(["URLSearchParams"]); + +function handleRequest(aRequest, aResponse) { + var params = new URLSearchParams(aRequest.queryString); + + // Report-to setter + if (aRequest.method == "GET" && params.get("task") == "header") { + let extraParams = []; + + if (params.has("410")) { + extraParams.push("410=true"); + } + + if (params.has("worker")) { + extraParams.push("worker=true"); + } + + let body = { + max_age: 1, + endpoints: [ + { + url: + "https://example.org/tests/dom/reporting/tests/delivering.sjs" + + (extraParams.length ? "?" + extraParams.join("&") : ""), + priority: 1, + weight: 1, + }, + ], + }; + + aResponse.setStatusLine(aRequest.httpVersion, 200, "OK"); + aResponse.setHeader("Report-to", JSON.stringify(body), false); + aResponse.write("OK"); + return; + } + + // Report check + if (aRequest.method == "GET" && params.get("task") == "check") { + aResponse.setStatusLine(aRequest.httpVersion, 200, "OK"); + + let reports = getState("report"); + if (!reports) { + aResponse.write(""); + return; + } + + if (params.has("min")) { + let json = JSON.parse(reports); + if (json.length < params.get("min")) { + aResponse.write(""); + return; + } + } + + aResponse.setStatusLine(aRequest.httpVersion, 200, "OK"); + aResponse.write(getState("report")); + + setState("report", ""); + return; + } + + if (aRequest.method == "POST") { + var body = new BinaryInputStream(aRequest.bodyInputStream); + + var avail; + var bytes = []; + while ((avail = body.available()) > 0) { + Array.prototype.push.apply(bytes, body.readByteArray(avail)); + } + + let reports = getState("report"); + if (!reports) { + reports = []; + } else { + reports = JSON.parse(reports); + } + + const incoming_reports = JSON.parse(String.fromCharCode.apply(null, bytes)); + for (let report of incoming_reports) { + let data = { + contentType: aRequest.getHeader("content-type"), + origin: aRequest.getHeader("origin"), + body: report, + url: + aRequest.scheme + + "://" + + aRequest.host + + aRequest.path + + (aRequest.queryString ? "&" + aRequest.queryString : ""), + }; + reports.push(data); + } + + setState("report", JSON.stringify(reports)); + + if (params.has("410")) { + aResponse.setStatusLine(aRequest.httpVersion, 410, "Gone"); + } else { + aResponse.setStatusLine(aRequest.httpVersion, 200, "OK"); + } + return; + } + + aResponse.setStatusLine(aRequest.httpVersion, 500, "Internal error"); + aResponse.write("Invalid request"); +} diff --git a/dom/reporting/tests/empty.html b/dom/reporting/tests/empty.html new file mode 100644 index 0000000000..cd0875583a --- /dev/null +++ b/dom/reporting/tests/empty.html @@ -0,0 +1 @@ +Hello world! diff --git a/dom/reporting/tests/gtest/TestReportToParser.cpp b/dom/reporting/tests/gtest/TestReportToParser.cpp new file mode 100644 index 0000000000..a3549886a3 --- /dev/null +++ b/dom/reporting/tests/gtest/TestReportToParser.cpp @@ -0,0 +1,418 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gtest/gtest.h" +#include "mozilla/dom/ReportingHeader.h" +#include "nsNetUtil.h" +#include "nsIURI.h" + +using namespace mozilla; +using namespace mozilla::dom; + +TEST(ReportToParser, Basic) +{ + nsCOMPtr uri; + + nsresult rv = NS_NewURI(getter_AddRefs(uri), "https://example.com"); + ASSERT_EQ(NS_OK, rv); + + bool urlEqual = false; + + // Empty header. + UniquePtr client = + ReportingHeader::ParseHeader(nullptr, uri, ""_ns); + ASSERT_TRUE(!client); + + // Empty header. + client = ReportingHeader::ParseHeader(nullptr, uri, " "_ns); + ASSERT_TRUE(!client); + + // No minimal attributes + client = ReportingHeader::ParseHeader(nullptr, uri, "{}"_ns); + ASSERT_TRUE(!client); + + // Single client + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 42, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("default")); + ASSERT_FALSE(client->mGroups.ElementAt(0).mIncludeSubdomains); + ASSERT_EQ(42, client->mGroups.ElementAt(0).mTTL); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 clients, same group name. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 43, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 44, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("default")); + ASSERT_EQ(43, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first one with an invalid group name. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 43, \"group\": 123, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 44, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("default")); + ASSERT_EQ(44, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first one with an invalid group name. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 43, \"group\": null, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 44, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("default")); + ASSERT_EQ(44, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first one with an invalid group name. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 43, \"group\": {}, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 44, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("default")); + ASSERT_EQ(44, client->mGroups.ElementAt(0).mTTL); + + // Single client: optional params + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 45, \"group\": \"foobar\", \"include_subdomains\": " + "true, \"endpoints\": [{\"url\": \"https://example.com\", " + "\"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_TRUE(client->mGroups.ElementAt(0).mName.EqualsLiteral("foobar")); + ASSERT_TRUE(client->mGroups.ElementAt(0).mIncludeSubdomains); + ASSERT_EQ(45, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: missing max_age. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"endpoints\": [{\"url\": \"https://example.com\", \"priority\": " + "1, \"weight\": 2}]}," + "{\"max_age\": 46, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(46, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid max_age. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": null, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 46, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(46, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid max_age. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": \"foobar\", \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 46, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(46, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid max_age. + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": {}, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}," + "{\"max_age\": 46, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(46, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: missing endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 47}," + "{\"max_age\": 48, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(48, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 47, \"endpoints\": null }," + "{\"max_age\": 48, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(48, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 47, \"endpoints\": \"abc\" }," + "{\"max_age\": 48, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(48, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 47, \"endpoints\": 42 }," + "{\"max_age\": 48, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(48, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: invalid endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 47, \"endpoints\": {} }," + "{\"max_age\": 48, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(48, client->mGroups.ElementAt(0).mTTL); + + // 2 clients, the first incomplete: empty endpoints + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 49, \"endpoints\": []}," + "{\"max_age\": 50, \"endpoints\": [{\"url\": " + "\"https://example.com\", \"priority\": 1, \"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ(50, client->mGroups.ElementAt(0).mTTL); + + // 2 endpoints, the first incomplete: missing url + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 51, \"endpoints\": [" + " {\"priority\": 1, \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 1, " + "\"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid url + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 51, \"endpoints\": [" + " {\"url\": 42, \"priority\": 1, \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 1, " + "\"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid url + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 51, \"endpoints\": [" + " {\"url\": \"something here\", \"priority\": 1, \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 1, \"weight\": " + "2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid url + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 51, \"endpoints\": [" + " {\"url\": {}, \"priority\": 1, \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 1, " + "\"weight\": 2}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: missing priority + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 52, \"endpoints\": [" + " {\"url\": \"https://example.com\", \"weight\": 3}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)3, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid priority + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 52, \"endpoints\": [" + " {\"url\": \"https://example.com\", \"priority\": " + "{}, \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 2, " + "\"weight\": 3}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)3, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid priority + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 52, \"endpoints\": [" + " {\"url\": \"https://example.com\", \"priority\": " + "\"ok\", \"weight\": 2}," + " {\"url\": \"https://example.com\", \"priority\": 2, " + "\"weight\": 3}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)2, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)3, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: missing weight + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString( + "{\"max_age\": 52, \"endpoints\": [" + " {\"url\": \"https://example.com\", \"priority\": 5}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)5, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)1, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); + + // 2 endpoints, the first incomplete: invalid weight + client = ReportingHeader::ParseHeader( + nullptr, uri, + nsLiteralCString("{\"max_age\": 52, \"endpoints\": [" + " {\"url\": \"https://example.com\", \"priority\": 4, " + "\"weight\": []}," + " {\"url\": \"https://example.com\", \"priority\": 5, " + "\"weight\": 6}]}")); + ASSERT_TRUE(!!client); + ASSERT_EQ((uint32_t)1, client->mGroups.Length()); + ASSERT_EQ((uint32_t)1, client->mGroups.ElementAt(0).mEndpoints.Length()); + ASSERT_TRUE( + NS_SUCCEEDED( + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mUrl->Equals( + uri, &urlEqual)) && + urlEqual); + ASSERT_EQ((uint32_t)5, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mPriority); + ASSERT_EQ((uint32_t)6, + client->mGroups.ElementAt(0).mEndpoints.ElementAt(0).mWeight); +} diff --git a/dom/reporting/tests/gtest/moz.build b/dom/reporting/tests/gtest/moz.build new file mode 100644 index 0000000000..860ef48d1e --- /dev/null +++ b/dom/reporting/tests/gtest/moz.build @@ -0,0 +1,13 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, you can obtain one at http://mozilla.org/MPL/2.0/. + +UNIFIED_SOURCES = [ + "TestReportToParser.cpp", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul-gtest" diff --git a/dom/reporting/tests/iframe_delivering.html b/dom/reporting/tests/iframe_delivering.html new file mode 100644 index 0000000000..c77ff50b9c --- /dev/null +++ b/dom/reporting/tests/iframe_delivering.html @@ -0,0 +1,92 @@ + + + + Test for delivering reports + + + + + + diff --git a/dom/reporting/tests/mochitest.ini b/dom/reporting/tests/mochitest.ini new file mode 100644 index 0000000000..6b9cc0c7d2 --- /dev/null +++ b/dom/reporting/tests/mochitest.ini @@ -0,0 +1,15 @@ +[DEFAULT] +prefs = + dom.reporting.enabled=true + dom.reporting.header.enabled=true + dom.reporting.testing.enabled=true + +[test_deprecated.html] +support-files = common_deprecated.js worker_deprecated.js +skip-if = + http3 +[test_memoryPressure.html] +[test_delivering.html] +support-files = delivering.sjs iframe_delivering.html worker_delivering.js +skip-if = + http3 diff --git a/dom/reporting/tests/test_delivering.html b/dom/reporting/tests/test_delivering.html new file mode 100644 index 0000000000..2c552273e0 --- /dev/null +++ b/dom/reporting/tests/test_delivering.html @@ -0,0 +1,45 @@ + + + + Test for delivering reports + + + + + + + + diff --git a/dom/reporting/tests/test_deprecated.html b/dom/reporting/tests/test_deprecated.html new file mode 100644 index 0000000000..da55978e9b --- /dev/null +++ b/dom/reporting/tests/test_deprecated.html @@ -0,0 +1,51 @@ + + + + Test for Deprecated reports + + + + + + + + + diff --git a/dom/reporting/tests/test_memoryPressure.html b/dom/reporting/tests/test_memoryPressure.html new file mode 100644 index 0000000000..1bb887b05e --- /dev/null +++ b/dom/reporting/tests/test_memoryPressure.html @@ -0,0 +1,33 @@ + + + + Test for ReportingObserver + memory-pressure + + + + + + + + diff --git a/dom/reporting/tests/worker_delivering.js b/dom/reporting/tests/worker_delivering.js new file mode 100644 index 0000000000..539bcd231c --- /dev/null +++ b/dom/reporting/tests/worker_delivering.js @@ -0,0 +1,5 @@ +fetch("delivering.sjs?task=header&worker=true") + .then(r => r.text()) + .then(text => { + postMessage("All good!"); + }); diff --git a/dom/reporting/tests/worker_deprecated.js b/dom/reporting/tests/worker_deprecated.js new file mode 100644 index 0000000000..f6b57896f6 --- /dev/null +++ b/dom/reporting/tests/worker_deprecated.js @@ -0,0 +1,28 @@ +/* eslint-disable no-undef */ + +// eslint-disable-next-line no-unused-vars +function ok(a, msg) { + postMessage({ type: "check", check: !!a, msg }); +} + +// eslint-disable-next-line no-unused-vars +function is(a, b, msg) { + ok(a === b, msg); +} + +// eslint-disable-next-line no-unused-vars +function info(msg) { + postMessage({ type: "info", msg }); +} + +function finish() { + postMessage({ type: "finish" }); +} + +importScripts("common_deprecated.js"); + +test_deprecatedInterface() + .then(() => test_deprecatedMethod()) + .then(() => test_deprecatedAttribute()) + .then(() => test_takeRecords()) + .then(() => finish()); -- cgit v1.2.3