dom/console/ConsoleReportCollector.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/ConsoleReportCollector.h"
   8
   9 #include "mozilla/dom/Document.h"
  10 #include "mozilla/net/NeckoChannelParams.h"
  11
  12 #include "ConsoleUtils.h"
  13 #include "nsIScriptError.h"
  14 #include "nsNetUtil.h"
  15
  16 namespace mozilla {
  17
  18 using mozilla::dom::ConsoleUtils;
  19
  20 NS_IMPL_ISUPPORTS(ConsoleReportCollector, nsIConsoleReportCollector)
  21
  22 ConsoleReportCollector::ConsoleReportCollector()
  23     : mMutex("mozilla::ConsoleReportCollector") {}
  24
  25 void ConsoleReportCollector::AddConsoleReport(
  26     uint32_t aErrorFlags, const nsACString& aCategory,
  27     nsContentUtils::PropertiesFile aPropertiesFile,
  28     const nsACString& aSourceFileURI, uint32_t aLineNumber,
  29     uint32_t aColumnNumber, const nsACString& aMessageName,
  30     const nsTArray<nsString>& aStringParams) {
  31   // any thread
  32   MutexAutoLock lock(mMutex);
  33
  34   mPendingReports.EmplaceBack(aErrorFlags, aCategory, aPropertiesFile,
  35                               aSourceFileURI, aLineNumber, aColumnNumber,
  36                               aMessageName, aStringParams);
  37 }
  38
  39 void ConsoleReportCollector::FlushReportsToConsole(uint64_t aInnerWindowID,
  40                                                    ReportAction aAction) {
  41   nsTArray<PendingReport> reports;
  42
  43   {
  44     MutexAutoLock lock(mMutex);
  45     if (aAction == ReportAction::Forget) {
  46       reports = std::move(mPendingReports);
  47     } else {
  48       reports = mPendingReports.Clone();
  49     }
  50   }
  51
  52   for (uint32_t i = 0; i < reports.Length(); ++i) {
  53     PendingReport& report = reports[i];
  54
  55     nsAutoString errorText;
  56     nsresult rv;
  57     if (!report.mStringParams.IsEmpty()) {
  58       rv = nsContentUtils::FormatLocalizedString(
  59           report.mPropertiesFile, report.mMessageName.get(),
  60           report.mStringParams, errorText);
  61     } else {
  62       rv = nsContentUtils::GetLocalizedString(
  63           report.mPropertiesFile, report.mMessageName.get(), errorText);
  64     }
  65     if (NS_WARN_IF(NS_FAILED(rv))) {
  66       continue;
  67     }
  68
  69     // It would be nice if we did not have to do this since ReportToConsole()
  70     // just turns around and converts it back to a spec.
  71     nsCOMPtr<nsIURI> uri;
  72     if (!report.mSourceFileURI.IsEmpty()) {
  73       nsresult rv = NS_NewURI(getter_AddRefs(uri), report.mSourceFileURI);
  74       if (NS_FAILED(rv)) {
  75         NS_WARNING(nsPrintfCString("Failed to transform %s to uri",
  76                                    report.mSourceFileURI.get())
  77                        .get());
  78         continue;
  79       }
  80     }
  81
  82     nsContentUtils::ReportToConsoleByWindowID(
  83         errorText, report.mErrorFlags, report.mCategory, aInnerWindowID, uri,
  84         u""_ns, report.mLineNumber, report.mColumnNumber);
  85   }
  86 }
  87
  88 void ConsoleReportCollector::FlushReportsToConsoleForServiceWorkerScope(
  89     const nsACString& aScope, ReportAction aAction) {
  90   nsTArray<PendingReport> reports;
  91
  92   {
  93     MutexAutoLock lock(mMutex);
  94     if (aAction == ReportAction::Forget) {
  95       reports = std::move(mPendingReports);
  96     } else {
  97       reports = mPendingReports.Clone();
  98     }
  99   }
 100
 101   for (uint32_t i = 0; i < reports.Length(); ++i) {
 102     PendingReport& report = reports[i];
 103
 104     nsAutoString errorText;
 105     nsresult rv;
 106     if (!report.mStringParams.IsEmpty()) {
 107       rv = nsContentUtils::FormatLocalizedString(
 108           report.mPropertiesFile, report.mMessageName.get(),
 109           report.mStringParams, errorText);
 110     } else {
 111       rv = nsContentUtils::GetLocalizedString(
 112           report.mPropertiesFile, report.mMessageName.get(), errorText);
 113     }
 114     if (NS_WARN_IF(NS_FAILED(rv))) {
 115       continue;
 116     }
 117
 118     ConsoleUtils::Level level = ConsoleUtils::eLog;
 119     switch (report.mErrorFlags) {
 120       case nsIScriptError::errorFlag:
 121         level = ConsoleUtils::eError;
 122         break;
 123       case nsIScriptError::warningFlag:
 124         level = ConsoleUtils::eWarning;
 125         break;
 126       default:
 127         // default to log otherwise
 128         break;
 129     }
 130
 131     ConsoleUtils::ReportForServiceWorkerScope(
 132         NS_ConvertUTF8toUTF16(aScope), errorText,
 133         NS_ConvertUTF8toUTF16(report.mSourceFileURI), report.mLineNumber,
 134         report.mColumnNumber, level);
 135   }
 136 }
 137
 138 void ConsoleReportCollector::FlushConsoleReports(dom::Document* aDocument,
 139                                                  ReportAction aAction) {
 140   MOZ_ASSERT(NS_IsMainThread());
 141
 142   FlushReportsToConsole(aDocument ? aDocument->InnerWindowID() : 0, aAction);
 143 }
 144
 145 void ConsoleReportCollector::FlushConsoleReports(nsILoadGroup* aLoadGroup,
 146                                                  ReportAction aAction) {
 147   FlushReportsToConsole(nsContentUtils::GetInnerWindowID(aLoadGroup), aAction);
 148 }
 149
 150 void ConsoleReportCollector::FlushConsoleReports(
 151     nsIConsoleReportCollector* aCollector) {
 152   MOZ_ASSERT(aCollector);
 153
 154   nsTArray<PendingReport> reports;
 155
 156   {
 157     MutexAutoLock lock(mMutex);
 158     reports = std::move(mPendingReports);
 159   }
 160
 161   for (uint32_t i = 0; i < reports.Length(); ++i) {
 162     PendingReport& report = reports[i];
 163     aCollector->AddConsoleReport(
 164         report.mErrorFlags, report.mCategory, report.mPropertiesFile,
 165         report.mSourceFileURI, report.mLineNumber, report.mColumnNumber,
 166         report.mMessageName,
 167         static_cast<const nsTArray<nsString>&>(report.mStringParams));
 168   }
 169 }
 170
 171 void ConsoleReportCollector::StealConsoleReports(
 172     nsTArray<net::ConsoleReportCollected>& aReports) {
 173   aReports.Clear();
 174
 175   nsTArray<PendingReport> reports;
 176
 177   {
 178     MutexAutoLock lock(mMutex);
 179     reports = std::move(mPendingReports);
 180   }
 181
 182   for (const PendingReport& report : reports) {
 183     aReports.AppendElement(net::ConsoleReportCollected(
 184         report.mErrorFlags, report.mCategory, report.mPropertiesFile,
 185         report.mSourceFileURI, report.mLineNumber, report.mColumnNumber,
 186         report.mMessageName, report.mStringParams));
 187   }
 188 }
 189
 190 void ConsoleReportCollector::ClearConsoleReports() {
 191   MutexAutoLock lock(mMutex);
 192
 193   mPendingReports.Clear();
 194 }
 195
 196 ConsoleReportCollector::~ConsoleReportCollector() = default;
 197
 198 }  // namespace mozilla