/src/mozilla-central/dom/indexedDB/ScriptErrorHelper.cpp

Source (jump to first uncovered line)
/* -*- 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 "ScriptErrorHelper.h"

#include "MainThreadUtils.h"
#include "mozilla/SystemGroup.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nsIConsoleService.h"
#include "nsIScriptError.h"
#include "nsString.h"
#include "nsThreadUtils.h"

namespace {

class ScriptErrorRunnable final : public mozilla::Runnable
{
  nsString mMessage;
  nsCString mMessageName;
  nsString mFilename;
  uint32_t mLineNumber;
  uint32_t mColumnNumber;
  uint32_t mSeverityFlag;
  uint64_t mInnerWindowID;
  bool mIsChrome;

public:
  ScriptErrorRunnable(const nsAString& aMessage,
                      const nsAString& aFilename,
                      uint32_t aLineNumber,
                      uint32_t aColumnNumber,
                      uint32_t aSeverityFlag,
                      bool aIsChrome,
                      uint64_t aInnerWindowID)
    : mozilla::Runnable("ScriptErrorRunnable")
    , mMessage(aMessage)
    , mFilename(aFilename)
    , mLineNumber(aLineNumber)
    , mColumnNumber(aColumnNumber)
    , mSeverityFlag(aSeverityFlag)
    , mInnerWindowID(aInnerWindowID)
    , mIsChrome(aIsChrome)
  {
    MOZ_ASSERT(!NS_IsMainThread());
    mMessageName.SetIsVoid(true);
  }

  ScriptErrorRunnable(const nsACString& aMessageName,
                      const nsAString& aFilename,
                      uint32_t aLineNumber,
                      uint32_t aColumnNumber,
                      uint32_t aSeverityFlag,
                      bool aIsChrome,
                      uint64_t aInnerWindowID)
    : mozilla::Runnable("ScriptErrorRunnable")
    , mMessageName(aMessageName)
    , mFilename(aFilename)
    , mLineNumber(aLineNumber)
    , mColumnNumber(aColumnNumber)
    , mSeverityFlag(aSeverityFlag)
    , mInnerWindowID(aInnerWindowID)
    , mIsChrome(aIsChrome)
  {
    MOZ_ASSERT(!NS_IsMainThread());
    mMessage.SetIsVoid(true);
  }

  static void
  DumpLocalizedMessage(const nsACString& aMessageName,
                       const nsAString& aFilename,
                       uint32_t aLineNumber,
                       uint32_t aColumnNumber,
                       uint32_t aSeverityFlag,
                       bool aIsChrome,
                       uint64_t aInnerWindowID)
  {
    MOZ_ASSERT(NS_IsMainThread());
    MOZ_ASSERT(!aMessageName.IsEmpty());

    nsAutoString localizedMessage;
    if (NS_WARN_IF(NS_FAILED(
      nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
                                         aMessageName.BeginReading(),
                                         localizedMessage)))) {
      return;
    }

    Dump(localizedMessage,
         aFilename,
         aLineNumber,
         aColumnNumber,
         aSeverityFlag,
         aIsChrome,
         aInnerWindowID);
  }

  static void
  Dump(const nsAString& aMessage,
       const nsAString& aFilename,
       uint32_t aLineNumber,
       uint32_t aColumnNumber,
       uint32_t aSeverityFlag,
       bool aIsChrome,
       uint64_t aInnerWindowID)
  {
    MOZ_ASSERT(NS_IsMainThread());

    nsAutoCString category;
    if (aIsChrome) {
      category.AssignLiteral("chrome ");
    } else {
      category.AssignLiteral("content ");
    }
    category.AppendLiteral("javascript");

    nsCOMPtr<nsIConsoleService> consoleService =
      do_GetService(NS_CONSOLESERVICE_CONTRACTID);
    MOZ_ASSERT(consoleService);

    nsCOMPtr<nsIScriptError> scriptError =
      do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
    MOZ_ASSERT(scriptError);

    if (aInnerWindowID) {
      MOZ_ALWAYS_SUCCEEDS(
        scriptError->InitWithWindowID(aMessage,
                                      aFilename,
                                      /* aSourceLine */ EmptyString(),
                                      aLineNumber,
                                      aColumnNumber,
                                      aSeverityFlag,
                                      category,
                                      aInnerWindowID));
    } else {
      MOZ_ALWAYS_SUCCEEDS(
        scriptError->Init(aMessage,
                          aFilename,
                          /* aSourceLine */ EmptyString(),
                          aLineNumber,
                          aColumnNumber,
                          aSeverityFlag,
                          category.get(),
                          /* IDB doesn't run on Private browsing mode */ false));
    }

    MOZ_ALWAYS_SUCCEEDS(consoleService->LogMessage(scriptError));
  }

  NS_IMETHOD
  Run() override
  {
    MOZ_ASSERT(NS_IsMainThread());
    MOZ_ASSERT(mMessage.IsVoid() != mMessageName.IsVoid());

    if (!mMessage.IsVoid()) {
      Dump(mMessage,
           mFilename,
           mLineNumber,
           mColumnNumber,
           mSeverityFlag,
           mIsChrome,
           mInnerWindowID);
      return NS_OK;
    }

    DumpLocalizedMessage(mMessageName,
                         mFilename,
                         mLineNumber,
                         mColumnNumber,
                         mSeverityFlag,
                         mIsChrome,
                         mInnerWindowID);

    return NS_OK;
  }

private:
  virtual ~ScriptErrorRunnable() {}
};

} // namespace

namespace mozilla {
namespace dom {
namespace indexedDB {

/*static*/ void
ScriptErrorHelper::Dump(const nsAString& aMessage,
                        const nsAString& aFilename,
                        uint32_t aLineNumber,
                        uint32_t aColumnNumber,
                        uint32_t aSeverityFlag,
                        bool aIsChrome,
                        uint64_t aInnerWindowID)
{
  if (NS_IsMainThread()) {
    ScriptErrorRunnable::Dump(aMessage,
                              aFilename,
                              aLineNumber,
                              aColumnNumber,
                              aSeverityFlag,
                              aIsChrome,
                              aInnerWindowID);
  } else {
    RefPtr<ScriptErrorRunnable> runnable =
      new ScriptErrorRunnable(aMessage,
                              aFilename,
                              aLineNumber,
                              aColumnNumber,
                              aSeverityFlag,
                              aIsChrome,
                              aInnerWindowID);
    MOZ_ALWAYS_SUCCEEDS(
      SystemGroup::Dispatch(TaskCategory::Other, runnable.forget()));
  }
}

/*static*/ void
ScriptErrorHelper::DumpLocalizedMessage(const nsACString& aMessageName,
                                        const nsAString& aFilename,
                                        uint32_t aLineNumber,
                                        uint32_t aColumnNumber,
                                        uint32_t aSeverityFlag,
                                        bool aIsChrome,
                                        uint64_t aInnerWindowID)
{
  if (NS_IsMainThread()) {
    ScriptErrorRunnable::DumpLocalizedMessage(aMessageName,
                                              aFilename,
                                              aLineNumber,
                                              aColumnNumber,
                                              aSeverityFlag,
                                              aIsChrome,
                                              aInnerWindowID);
  } else {
    RefPtr<ScriptErrorRunnable> runnable =
      new ScriptErrorRunnable(aMessageName,
                              aFilename,
                              aLineNumber,
                              aColumnNumber,
                              aSeverityFlag,
                              aIsChrome,
                              aInnerWindowID);
    MOZ_ALWAYS_SUCCEEDS(
      SystemGroup::Dispatch(TaskCategory::Other, runnable.forget()));
  }
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
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 "ScriptErrorHelper.h"
8
9		#include "MainThreadUtils.h"
10		#include "mozilla/SystemGroup.h"
11		#include "nsCOMPtr.h"
12		#include "nsContentUtils.h"
13		#include "nsIConsoleService.h"
14		#include "nsIScriptError.h"
15		#include "nsString.h"
16		#include "nsThreadUtils.h"
17
18		namespace {
19
20		class ScriptErrorRunnable final : public mozilla::Runnable
21		{
22		nsString mMessage;
23		nsCString mMessageName;
24		nsString mFilename;
25		uint32_t mLineNumber;
26		uint32_t mColumnNumber;
27		uint32_t mSeverityFlag;
28		uint64_t mInnerWindowID;
29		bool mIsChrome;
30
31		public:
32		ScriptErrorRunnable(const nsAString& aMessage,
33		const nsAString& aFilename,
34		uint32_t aLineNumber,
35		uint32_t aColumnNumber,
36		uint32_t aSeverityFlag,
37		bool aIsChrome,
38		uint64_t aInnerWindowID)
39		: mozilla::Runnable("ScriptErrorRunnable")
40		, mMessage(aMessage)
41		, mFilename(aFilename)
42		, mLineNumber(aLineNumber)
43		, mColumnNumber(aColumnNumber)
44		, mSeverityFlag(aSeverityFlag)
45		, mInnerWindowID(aInnerWindowID)
46		, mIsChrome(aIsChrome)
47	0	{
48	0	MOZ_ASSERT(!NS_IsMainThread());
49	0	mMessageName.SetIsVoid(true);
50	0	}
51
52		ScriptErrorRunnable(const nsACString& aMessageName,
53		const nsAString& aFilename,
54		uint32_t aLineNumber,
55		uint32_t aColumnNumber,
56		uint32_t aSeverityFlag,
57		bool aIsChrome,
58		uint64_t aInnerWindowID)
59		: mozilla::Runnable("ScriptErrorRunnable")
60		, mMessageName(aMessageName)
61		, mFilename(aFilename)
62		, mLineNumber(aLineNumber)
63		, mColumnNumber(aColumnNumber)
64		, mSeverityFlag(aSeverityFlag)
65		, mInnerWindowID(aInnerWindowID)
66		, mIsChrome(aIsChrome)
67	0	{
68	0	MOZ_ASSERT(!NS_IsMainThread());
69	0	mMessage.SetIsVoid(true);
70	0	}
71
72		static void
73		DumpLocalizedMessage(const nsACString& aMessageName,
74		const nsAString& aFilename,
75		uint32_t aLineNumber,
76		uint32_t aColumnNumber,
77		uint32_t aSeverityFlag,
78		bool aIsChrome,
79		uint64_t aInnerWindowID)
80	0	{
81	0	MOZ_ASSERT(NS_IsMainThread());
82	0	MOZ_ASSERT(!aMessageName.IsEmpty());
83	0
84	0	nsAutoString localizedMessage;
85	0	if (NS_WARN_IF(NS_FAILED(
86	0	nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
87	0	aMessageName.BeginReading(),
88	0	localizedMessage)))) {
89	0	return;
90	0	}
91	0
92	0	Dump(localizedMessage,
93	0	aFilename,
94	0	aLineNumber,
95	0	aColumnNumber,
96	0	aSeverityFlag,
97	0	aIsChrome,
98	0	aInnerWindowID);
99	0	}
100
101		static void
102		Dump(const nsAString& aMessage,
103		const nsAString& aFilename,
104		uint32_t aLineNumber,
105		uint32_t aColumnNumber,
106		uint32_t aSeverityFlag,
107		bool aIsChrome,
108		uint64_t aInnerWindowID)
109	0	{
110	0	MOZ_ASSERT(NS_IsMainThread());
111	0
112	0	nsAutoCString category;
113	0	if (aIsChrome) {
114	0	category.AssignLiteral("chrome ");
115	0	} else {
116	0	category.AssignLiteral("content ");
117	0	}
118	0	category.AppendLiteral("javascript");
119	0
120	0	nsCOMPtr<nsIConsoleService> consoleService =
121	0	do_GetService(NS_CONSOLESERVICE_CONTRACTID);
122	0	MOZ_ASSERT(consoleService);
123	0
124	0	nsCOMPtr<nsIScriptError> scriptError =
125	0	do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
126	0	MOZ_ASSERT(scriptError);
127	0
128	0	if (aInnerWindowID) {
129	0	MOZ_ALWAYS_SUCCEEDS(
130	0	scriptError->InitWithWindowID(aMessage,
131	0	aFilename,
132	0	/* aSourceLine */ EmptyString(),
133	0	aLineNumber,
134	0	aColumnNumber,
135	0	aSeverityFlag,
136	0	category,
137	0	aInnerWindowID));
138	0	} else {
139	0	MOZ_ALWAYS_SUCCEEDS(
140	0	scriptError->Init(aMessage,
141	0	aFilename,
142	0	/* aSourceLine */ EmptyString(),
143	0	aLineNumber,
144	0	aColumnNumber,
145	0	aSeverityFlag,
146	0	category.get(),
147	0	/* IDB doesn't run on Private browsing mode */ false));
148	0	}
149	0
150	0	MOZ_ALWAYS_SUCCEEDS(consoleService->LogMessage(scriptError));
151	0	}
152
153		NS_IMETHOD
154		Run() override
155	0	{
156	0	MOZ_ASSERT(NS_IsMainThread());
157	0	MOZ_ASSERT(mMessage.IsVoid() != mMessageName.IsVoid());
158	0
159	0	if (!mMessage.IsVoid()) {
160	0	Dump(mMessage,
161	0	mFilename,
162	0	mLineNumber,
163	0	mColumnNumber,
164	0	mSeverityFlag,
165	0	mIsChrome,
166	0	mInnerWindowID);
167	0	return NS_OK;
168	0	}
169	0
170	0	DumpLocalizedMessage(mMessageName,
171	0	mFilename,
172	0	mLineNumber,
173	0	mColumnNumber,
174	0	mSeverityFlag,
175	0	mIsChrome,
176	0	mInnerWindowID);
177	0
178	0	return NS_OK;
179	0	}
180
181		private:
182	0	virtual ~ScriptErrorRunnable() {}
183		};
184
185		} // namespace
186
187		namespace mozilla {
188		namespace dom {
189		namespace indexedDB {
190
191		/static/ void
192		ScriptErrorHelper::Dump(const nsAString& aMessage,
193		const nsAString& aFilename,
194		uint32_t aLineNumber,
195		uint32_t aColumnNumber,
196		uint32_t aSeverityFlag,
197		bool aIsChrome,
198		uint64_t aInnerWindowID)
199	0	{
200	0	if (NS_IsMainThread()) {
201	0	ScriptErrorRunnable::Dump(aMessage,
202	0	aFilename,
203	0	aLineNumber,
204	0	aColumnNumber,
205	0	aSeverityFlag,
206	0	aIsChrome,
207	0	aInnerWindowID);
208	0	} else {
209	0	RefPtr<ScriptErrorRunnable> runnable =
210	0	new ScriptErrorRunnable(aMessage,
211	0	aFilename,
212	0	aLineNumber,
213	0	aColumnNumber,
214	0	aSeverityFlag,
215	0	aIsChrome,
216	0	aInnerWindowID);
217	0	MOZ_ALWAYS_SUCCEEDS(
218	0	SystemGroup::Dispatch(TaskCategory::Other, runnable.forget()));
219	0	}
220	0	}
221
222		/static/ void
223		ScriptErrorHelper::DumpLocalizedMessage(const nsACString& aMessageName,
224		const nsAString& aFilename,
225		uint32_t aLineNumber,
226		uint32_t aColumnNumber,
227		uint32_t aSeverityFlag,
228		bool aIsChrome,
229		uint64_t aInnerWindowID)
230	0	{
231	0	if (NS_IsMainThread()) {
232	0	ScriptErrorRunnable::DumpLocalizedMessage(aMessageName,
233	0	aFilename,
234	0	aLineNumber,
235	0	aColumnNumber,
236	0	aSeverityFlag,
237	0	aIsChrome,
238	0	aInnerWindowID);
239	0	} else {
240	0	RefPtr<ScriptErrorRunnable> runnable =
241	0	new ScriptErrorRunnable(aMessageName,
242	0	aFilename,
243	0	aLineNumber,
244	0	aColumnNumber,
245	0	aSeverityFlag,
246	0	aIsChrome,
247	0	aInnerWindowID);
248	0	MOZ_ALWAYS_SUCCEEDS(
249	0	SystemGroup::Dispatch(TaskCategory::Other, runnable.forget()));
250	0	}
251	0	}
252
253		} // namespace indexedDB
254		} // namespace dom
255		} // namespace mozilla