Line data    Source code

       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 "nsIConsoleService.h"
      10             : #include "nsIScriptError.h"
      11             : #include "nsNetUtil.h"
      12             : 
      13             : namespace mozilla {
      14             : 
      15         538 : NS_IMPL_ISUPPORTS(ConsoleReportCollector, nsIConsoleReportCollector)
      16             : 
      17         129 : ConsoleReportCollector::ConsoleReportCollector()
      18         129 :   : mMutex("mozilla::ConsoleReportCollector")
      19             : {
      20         129 : }
      21             : 
      22             : void
      23           0 : ConsoleReportCollector::AddConsoleReport(uint32_t aErrorFlags,
      24             :                                          const nsACString& aCategory,
      25             :                                          nsContentUtils::PropertiesFile aPropertiesFile,
      26             :                                          const nsACString& aSourceFileURI,
      27             :                                          uint32_t aLineNumber,
      28             :                                          uint32_t aColumnNumber,
      29             :                                          const nsACString& aMessageName,
      30             :                                          const nsTArray<nsString>& aStringParams)
      31             : {
      32             :   // any thread
      33           0 :   MutexAutoLock lock(mMutex);
      34             : 
      35           0 :   mPendingReports.AppendElement(PendingReport(aErrorFlags, aCategory,
      36             :                                               aPropertiesFile, aSourceFileURI,
      37             :                                               aLineNumber, aColumnNumber,
      38           0 :                                               aMessageName, aStringParams));
      39           0 : }
      40             : 
      41             : void
      42           2 : ConsoleReportCollector::FlushReportsToConsole(uint64_t aInnerWindowID,
      43             :                                               ReportAction aAction)
      44             : {
      45           4 :   nsTArray<PendingReport> reports;
      46             : 
      47             :   {
      48           4 :     MutexAutoLock lock(mMutex);
      49           2 :     if (aAction == ReportAction::Forget) {
      50           2 :       mPendingReports.SwapElements(reports);
      51             :     } else {
      52           0 :       reports = mPendingReports;
      53             :     }
      54             :   }
      55             : 
      56           2 :   for (uint32_t i = 0; i < reports.Length(); ++i) {
      57           0 :     PendingReport& report = reports[i];
      58             : 
      59           0 :     nsXPIDLString errorText;
      60             :     nsresult rv;
      61           0 :     if (!report.mStringParams.IsEmpty()) {
      62           0 :       rv = nsContentUtils::FormatLocalizedString(report.mPropertiesFile,
      63             :                                                  report.mMessageName.get(),
      64             :                                                  report.mStringParams,
      65           0 :                                                  errorText);
      66             :     } else {
      67           0 :       rv = nsContentUtils::GetLocalizedString(report.mPropertiesFile,
      68             :                                               report.mMessageName.get(),
      69           0 :                                               errorText);
      70             :     }
      71           0 :     if (NS_WARN_IF(NS_FAILED(rv))) {
      72           0 :       continue;
      73             :     }
      74             : 
      75             :     // It would be nice if we did not have to do this since ReportToConsole()
      76             :     // just turns around and converts it back to a spec.
      77           0 :     nsCOMPtr<nsIURI> uri;
      78           0 :     if (!report.mSourceFileURI.IsEmpty()) {
      79           0 :       nsresult rv = NS_NewURI(getter_AddRefs(uri), report.mSourceFileURI);
      80           0 :       MOZ_ALWAYS_SUCCEEDS(rv);
      81           0 :       if (NS_FAILED(rv)) {
      82           0 :         continue;
      83             :       }
      84             :     }
      85             : 
      86           0 :     nsContentUtils::ReportToConsoleByWindowID(errorText,
      87           0 :                                               report.mErrorFlags,
      88             :                                               report.mCategory,
      89             :                                               aInnerWindowID,
      90             :                                               uri,
      91             :                                               EmptyString(),
      92           0 :                                               report.mLineNumber,
      93           0 :                                               report.mColumnNumber);
      94             :   }
      95           2 : }
      96             : 
      97             : void
      98           0 : ConsoleReportCollector::FlushConsoleReports(nsIDocument* aDocument,
      99             :                                             ReportAction aAction)
     100             : {
     101           0 :   MOZ_ASSERT(NS_IsMainThread());
     102             : 
     103           0 :   FlushReportsToConsole(aDocument ? aDocument->InnerWindowID() : 0, aAction);
     104           0 : }
     105             : 
     106             : void
     107           2 : ConsoleReportCollector::FlushConsoleReports(nsILoadGroup* aLoadGroup,
     108             :                                             ReportAction aAction)
     109             : {
     110           2 :   FlushReportsToConsole(nsContentUtils::GetInnerWindowID(aLoadGroup), aAction);
     111           2 : }
     112             : 
     113             : void
     114           0 : ConsoleReportCollector::FlushConsoleReports(nsIConsoleReportCollector* aCollector)
     115             : {
     116           0 :   MOZ_ASSERT(aCollector);
     117             : 
     118           0 :   nsTArray<PendingReport> reports;
     119             : 
     120             :   {
     121           0 :     MutexAutoLock lock(mMutex);
     122           0 :     mPendingReports.SwapElements(reports);
     123             :   }
     124             : 
     125           0 :   for (uint32_t i = 0; i < reports.Length(); ++i) {
     126           0 :     PendingReport& report = reports[i];
     127           0 :     aCollector->AddConsoleReport(report.mErrorFlags, report.mCategory,
     128           0 :                                  report.mPropertiesFile, report.mSourceFileURI,
     129           0 :                                  report.mLineNumber, report.mColumnNumber,
     130           0 :                                  report.mMessageName, report.mStringParams);
     131             :   }
     132           0 : }
     133             : 
     134             : void
     135           0 : ConsoleReportCollector::ClearConsoleReports()
     136             : {
     137           0 :   MutexAutoLock lock(mMutex);
     138             : 
     139           0 :   mPendingReports.Clear();
     140           0 : }
     141             : 
     142          11 : ConsoleReportCollector::~ConsoleReportCollector()
     143             : {
     144          11 : }
     145             : 
     146             : } // namespace mozilla