wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-26 02:17:34 +09:00
Code Issues Projects Releases Packages Wiki Activity

Remove base conditional code for crash reporter and injector.

Browse source
This commit is contained in:
wolfbeast 2018-03-30 08:50:58 +02:00 • committed by Roy Tam
commit 434f3590e3
131 changed files with 39 additions and 4139 deletions
Download patch file Download diff file Expand all files Collapse all files

4
dom/media/gmp/GMPChild.cpp
View file

@ -257,10 +257,6 @@ GMPChild::Init(const nsAString& aPluginPath,
return false;
}
#ifdef MOZ_CRASHREPORTER
SendPCrashReporterConstructor(CrashReporter::CurrentThreadId());
#endif
mPluginPath = aPluginPath;
mSandboxVoucherPath = aVoucherPath;

154
dom/media/gmp/GMPParent.cpp
View file

@ -29,12 +29,6 @@
using mozilla::dom::CrashReporterParent;
using mozilla::ipc::GeckoChildProcessHost;
#ifdef MOZ_CRASHREPORTER
#include "nsPrintfCString.h"
using CrashReporter::AnnotationTable;
using CrashReporter::GetIDFromMinidump;
#endif
#include "mozilla/Telemetry.h"
#ifdef XP_WIN
@ -224,10 +218,6 @@ GMPParent::AbortWaitingForGMPAsyncShutdown(nsITimer* aTimer, void* aClosure)
NS_WARNING("Timed out waiting for GMP async shutdown!");
GMPParent* parent = reinterpret_cast<GMPParent*>(aClosure);
MOZ_ASSERT(parent->mService);
#if defined(MOZ_CRASHREPORTER)
parent->mService->SetAsyncShutdownPluginState(parent, 'G',
NS_LITERAL_CSTRING("Timed out waiting for async shutdown"));
#endif
parent->mService->AsyncShutdownComplete(parent);
}
@ -270,22 +260,8 @@ GMPParent::RecvPGMPContentChildDestroyed()
{
--mGMPContentChildCount;
if (!IsUsed()) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'E',
NS_LITERAL_CSTRING("Last content child destroyed"));
}
#endif
CloseIfUnused();
}
#if defined(MOZ_CRASHREPORTER)
else {
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'F',
nsPrintfCString("Content child destroyed, remaining: %u", mGMPContentChildCount));
}
}
#endif
return true;
}
@ -307,38 +283,14 @@ GMPParent::CloseIfUnused()
if (mAsyncShutdownRequired) {
if (!mAsyncShutdownInProgress) {
LOGD("%s: sending async shutdown notification", __FUNCTION__);
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'H',
NS_LITERAL_CSTRING("Sent BeginAsyncShutdown"));
}
#endif
mAsyncShutdownInProgress = true;
if (!SendBeginAsyncShutdown()) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'I',
NS_LITERAL_CSTRING("Could not send BeginAsyncShutdown - Aborting async shutdown"));
}
#endif
AbortAsyncShutdown();
} else if (NS_FAILED(EnsureAsyncShutdownTimeoutSet())) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'J',
NS_LITERAL_CSTRING("Could not start timer after sending BeginAsyncShutdown - Aborting async shutdown"));
}
#endif
AbortAsyncShutdown();
}
}
} else {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'K',
NS_LITERAL_CSTRING("No (more) async-shutdown required"));
}
#endif
// No async-shutdown, kill async-shutdown timer started in CloseActive().
AbortAsyncShutdown();
// Any async shutdown must be complete. Shutdown GMPStorage.
@ -385,29 +337,11 @@ GMPParent::CloseActive(bool aDieWhenUnloaded)
mState = GMPStateUnloading;
}
if (mState != GMPStateNotLoaded && IsUsed()) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'A',
nsPrintfCString("Sent CloseActive, content children to close: %u", mGMPContentChildCount));
}
#endif
if (!SendCloseActive()) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'B',
NS_LITERAL_CSTRING("Could not send CloseActive - Aborting async shutdown"));
}
#endif
AbortAsyncShutdown();
} else if (IsUsed()) {
// We're expecting RecvPGMPContentChildDestroyed's -> Start async-shutdown timer now if needed.
if (mAsyncShutdownRequired && NS_FAILED(EnsureAsyncShutdownTimeoutSet())) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'C',
NS_LITERAL_CSTRING("Could not start timer after sending CloseActive - Aborting async shutdown"));
}
#endif
AbortAsyncShutdown();
}
} else {
@ -418,12 +352,6 @@ GMPParent::CloseActive(bool aDieWhenUnloaded)
// that time, it might not have proceeded with shutdown; And calling it
// again after shutdown is fine because after the first one we'll be in
// GMPStateNotLoaded.
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'D',
NS_LITERAL_CSTRING("Content children already destroyed"));
}
#endif
CloseIfUnused();
}
}
@ -630,78 +558,10 @@ GMPParent::EnsureProcessLoaded()
return NS_SUCCEEDED(rv);
}
#ifdef MOZ_CRASHREPORTER
void
GMPParent::WriteExtraDataForMinidump(CrashReporter::AnnotationTable& notes)
{
notes.Put(NS_LITERAL_CSTRING("GMPPlugin"), NS_LITERAL_CSTRING("1"));
notes.Put(NS_LITERAL_CSTRING("PluginFilename"),
NS_ConvertUTF16toUTF8(mName));
notes.Put(NS_LITERAL_CSTRING("PluginName"), mDisplayName);
notes.Put(NS_LITERAL_CSTRING("PluginVersion"), mVersion);
}
void
GMPParent::GetCrashID(nsString& aResult)
{
CrashReporterParent* cr =
static_cast<CrashReporterParent*>(LoneManagedOrNullAsserts(ManagedPCrashReporterParent()));
if (NS_WARN_IF(!cr)) {
return;
}
AnnotationTable notes(4);
WriteExtraDataForMinidump(notes);
nsCOMPtr<nsIFile> dumpFile;
TakeMinidump(getter_AddRefs(dumpFile), nullptr);
if (!dumpFile) {
NS_WARNING("GMP crash without crash report");
aResult = mName;
aResult += '-';
AppendUTF8toUTF16(mVersion, aResult);
return;
}
GetIDFromMinidump(dumpFile, aResult);
cr->GenerateCrashReportForMinidump(dumpFile, &notes);
}
static void
GMPNotifyObservers(const uint32_t aPluginID, const nsACString& aPluginName, const nsAString& aPluginDumpID)
{
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
nsCOMPtr<nsIWritablePropertyBag2> propbag =
do_CreateInstance("@mozilla.org/hash-property-bag;1");
if (obs && propbag) {
propbag->SetPropertyAsUint32(NS_LITERAL_STRING("pluginID"), aPluginID);
propbag->SetPropertyAsACString(NS_LITERAL_STRING("pluginName"), aPluginName);
propbag->SetPropertyAsAString(NS_LITERAL_STRING("pluginDumpID"), aPluginDumpID);
obs->NotifyObservers(propbag, "gmp-plugin-crash", nullptr);
}
RefPtr<gmp::GeckoMediaPluginService> service =
gmp::GeckoMediaPluginService::GetGeckoMediaPluginService();
if (service) {
service->RunPluginCrashCallbacks(aPluginID, aPluginName);
}
}
#endif
void
GMPParent::ActorDestroy(ActorDestroyReason aWhy)
{
LOGD("%s: (%d)", __FUNCTION__, (int)aWhy);
#ifdef MOZ_CRASHREPORTER
if (AbnormalShutdown == aWhy) {
Telemetry::Accumulate(Telemetry::SUBPROCESS_ABNORMAL_ABORT,
NS_LITERAL_CSTRING("gmplugin"), 1);
nsString dumpID;
GetCrashID(dumpID);
// NotifyObservers is mainthread-only
NS_DispatchToMainThread(WrapRunnableNM(&GMPNotifyObservers,
mPluginId, mDisplayName, dumpID),
NS_DISPATCH_NORMAL);
}
#endif
// warn us off trying to close again
mState = GMPStateClosing;
mAbnormalShutdownInProgress = true;
@ -711,12 +571,6 @@ GMPParent::ActorDestroy(ActorDestroyReason aWhy)
if (AbnormalShutdown == aWhy) {
RefPtr<GMPParent> self(this);
if (mAsyncShutdownRequired) {
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'M',
NS_LITERAL_CSTRING("Actor destroyed"));
}
#endif
mService->AsyncShutdownComplete(this);
mAsyncShutdownRequired = false;
}
@ -732,9 +586,7 @@ GMPParent::ActorDestroy(ActorDestroyReason aWhy)
mozilla::dom::PCrashReporterParent*
GMPParent::AllocPCrashReporterParent(const NativeThreadId& aThread)
{
#ifndef MOZ_CRASHREPORTER
MOZ_ASSERT(false, "Should only be sent if crash reporting is enabled.");
#endif
CrashReporterParent* cr = new CrashReporterParent();
cr->SetChildData(aThread, GeckoProcessType_GMPlugin);
return cr;
@ -1043,12 +895,6 @@ GMPParent::RecvAsyncShutdownComplete()
LOGD("%s", __FUNCTION__);
MOZ_ASSERT(mAsyncShutdownRequired);
#if defined(MOZ_CRASHREPORTER)
if (mService) {
mService->SetAsyncShutdownPluginState(this, 'L',
NS_LITERAL_CSTRING("Received AsyncShutdownComplete"));
}
#endif
AbortAsyncShutdown();
return true;
}

15
dom/media/gmp/GMPParent.h
View file

@ -25,17 +25,6 @@
class nsIThread;
#ifdef MOZ_CRASHREPORTER
#include "nsExceptionHandler.h"
namespace mozilla {
namespace dom {
class PCrashReporterParent;
class CrashReporterParent;
}
}
#endif
namespace mozilla {
namespace gmp {
@ -177,10 +166,6 @@ private:
RefPtr<GenericPromise> ReadGMPInfoFile(nsIFile* aFile);
RefPtr<GenericPromise> ParseChromiumManifest(nsString aJSON); // Main thread.
RefPtr<GenericPromise> ReadChromiumManifestFile(nsIFile* aFile); // GMP thread.
#ifdef MOZ_CRASHREPORTER
void WriteExtraDataForMinidump(CrashReporter::AnnotationTable& notes);
void GetCrashID(nsString& aResult);
#endif
void ActorDestroy(ActorDestroyReason aWhy) override;
PCrashReporterParent* AllocPCrashReporterParent(const NativeThreadId& aThread) override;

109
dom/media/gmp/GMPServiceParent.cpp
View file

@ -36,10 +36,6 @@
#include "nsHashKeys.h"
#include "nsIFile.h"
#include "nsISimpleEnumerator.h"
#if defined(MOZ_CRASHREPORTER)
#include "nsExceptionHandler.h"
#include "nsPrintfCString.h"
#endif
#include "nsIXULRuntime.h"
#include "GMPDecoderModule.h"
#include <limits>
@ -88,9 +84,6 @@ NS_IMPL_ISUPPORTS_INHERITED(GeckoMediaPluginServiceParent,
GeckoMediaPluginServiceParent::GeckoMediaPluginServiceParent()
: mShuttingDown(false)
#ifdef MOZ_CRASHREPORTER
, mAsyncShutdownPluginStatesMutex("GeckoMediaPluginService::mAsyncShutdownPluginStatesMutex")
#endif
, mScannedPluginOnDisk(false)
, mWaitingForPluginsSyncShutdown(false)
, mInitPromiseMonitor("GeckoMediaPluginServiceParent::mInitPromiseMonitor")
@ -421,28 +414,16 @@ GeckoMediaPluginServiceParent::Observe(nsISupports* aSubject,
if (gmpThread) {
LOGD(("%s::%s Starting to unload plugins, waiting for first sync shutdown..."
, __CLASS__, __FUNCTION__));
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '0',
NS_LITERAL_CSTRING("Dispatching UnloadPlugins"));
#endif
gmpThread->Dispatch(
NewRunnableMethod(this,
&GeckoMediaPluginServiceParent::UnloadPlugins),
NS_DISPATCH_NORMAL);
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '1',
NS_LITERAL_CSTRING("Waiting for sync shutdown"));
#endif
// Wait for UnloadPlugins() to do initial sync shutdown...
while (mWaitingForPluginsSyncShutdown) {
NS_ProcessNextEvent(NS_GetCurrentThread(), true);
}
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '4',
NS_LITERAL_CSTRING("Waiting for async shutdown"));
#endif
// Wait for other plugins (if any) to do async shutdown...
auto syncShutdownPluginsRemaining =
std::numeric_limits<decltype(mAsyncShutdownPlugins.Length())>::max();
@ -452,10 +433,6 @@ GeckoMediaPluginServiceParent::Observe(nsISupports* aSubject,
if (mAsyncShutdownPlugins.IsEmpty()) {
LOGD(("%s::%s Finished unloading all plugins"
, __CLASS__, __FUNCTION__));
#if defined(MOZ_CRASHREPORTER)
CrashReporter::RemoveCrashReportAnnotation(
NS_LITERAL_CSTRING("AsyncPluginShutdown"));
#endif
break;
} else if (mAsyncShutdownPlugins.Length() < syncShutdownPluginsRemaining) {
// First time here, or number of pending plugins has decreased.
@ -463,24 +440,10 @@ GeckoMediaPluginServiceParent::Observe(nsISupports* aSubject,
syncShutdownPluginsRemaining = mAsyncShutdownPlugins.Length();
LOGD(("%s::%s Still waiting for %d plugins to shutdown..."
, __CLASS__, __FUNCTION__, (int)syncShutdownPluginsRemaining));
#if defined(MOZ_CRASHREPORTER)
nsAutoCString names;
for (const auto& plugin : mAsyncShutdownPlugins) {
if (!names.IsEmpty()) { names.Append(NS_LITERAL_CSTRING(", ")); }
names.Append(plugin->GetDisplayName());
}
CrashReporter::AnnotateCrashReport(
NS_LITERAL_CSTRING("AsyncPluginShutdown"),
names);
#endif
}
}
NS_ProcessNextEvent(NS_GetCurrentThread(), true);
}
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '5',
NS_LITERAL_CSTRING("Async shutdown complete"));
#endif
} else {
// GMP thread has already shutdown.
MOZ_ASSERT(mPlugins.IsEmpty());
@ -627,66 +590,6 @@ GeckoMediaPluginServiceParent::AsyncShutdownComplete(GMPParent* aParent)
}
}
#ifdef MOZ_CRASHREPORTER
void
GeckoMediaPluginServiceParent::SetAsyncShutdownPluginState(GMPParent* aGMPParent,
char aId,
const nsCString& aState)
{
MutexAutoLock lock(mAsyncShutdownPluginStatesMutex);
if (!aGMPParent) {
mAsyncShutdownPluginStates.Update(NS_LITERAL_CSTRING("-"),
NS_LITERAL_CSTRING("-"),
aId,
aState);
return;
}
mAsyncShutdownPluginStates.Update(aGMPParent->GetDisplayName(),
nsPrintfCString("%p", aGMPParent),
aId,
aState);
}
void
GeckoMediaPluginServiceParent::AsyncShutdownPluginStates::Update(const nsCString& aPlugin,
const nsCString& aInstance,
char aId,
const nsCString& aState)
{
nsCString note;
StatesByInstance* instances = mStates.LookupOrAdd(aPlugin);
if (!instances) { return; }
State* state = instances->LookupOrAdd(aInstance);
if (!state) { return; }
state->mStateSequence += aId;
state->mLastStateDescription = aState;
note += '{';
bool firstPlugin = true;
for (auto pluginIt = mStates.ConstIter(); !pluginIt.Done(); pluginIt.Next()) {
if (!firstPlugin) { note += ','; } else { firstPlugin = false; }
note += pluginIt.Key();
note += ":{";
bool firstInstance = true;
for (auto instanceIt = pluginIt.UserData()->ConstIter(); !instanceIt.Done(); instanceIt.Next()) {
if (!firstInstance) { note += ','; } else { firstInstance = false; }
note += instanceIt.Key();
note += ":\"";
note += instanceIt.UserData()->mStateSequence;
note += '=';
note += instanceIt.UserData()->mLastStateDescription;
note += '"';
}
note += '}';
}
note += '}';
LOGD(("%s::%s states[%s][%s]='%c'/'%s' -> %s", __CLASS__, __FUNCTION__,
aPlugin.get(), aInstance.get(), aId, aState.get(), note.get()));
CrashReporter::AnnotateCrashReport(
NS_LITERAL_CSTRING("AsyncPluginShutdownStates"),
note);
}
#endif // MOZ_CRASHREPORTER
void
GeckoMediaPluginServiceParent::NotifyAsyncShutdownComplete()
{
@ -714,10 +617,6 @@ GeckoMediaPluginServiceParent::UnloadPlugins()
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(!mShuttingDownOnGMPThread);
mShuttingDownOnGMPThread = true;
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '2',
NS_LITERAL_CSTRING("Starting to unload plugins"));
#endif
nsTArray<RefPtr<GMPParent>> plugins;
{
@ -742,17 +641,9 @@ GeckoMediaPluginServiceParent::UnloadPlugins()
// Note: CloseActive may be async; it could actually finish
// shutting down when all the plugins have unloaded.
for (const auto& plugin : plugins) {
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(plugin, 'S',
NS_LITERAL_CSTRING("CloseActive"));
#endif
plugin->CloseActive(true);
}
#ifdef MOZ_CRASHREPORTER
SetAsyncShutdownPluginState(nullptr, '3',
NS_LITERAL_CSTRING("Dispatching sync-shutdown-complete"));
#endif
nsCOMPtr<nsIRunnable> task(NewRunnableMethod(
this, &GeckoMediaPluginServiceParent::NotifySyncShutdownComplete));
NS_DispatchToMainThread(task);

18
dom/media/gmp/GMPServiceParent.h
View file

@ -54,9 +54,6 @@ public:
void AsyncShutdownComplete(GMPParent* aParent);
int32_t AsyncShutdownTimeoutMs();
#ifdef MOZ_CRASHREPORTER
void SetAsyncShutdownPluginState(GMPParent* aGMPParent, char aId, const nsCString& aState);
#endif // MOZ_CRASHREPORTER
RefPtr<GenericPromise> EnsureInitialized();
RefPtr<GenericPromise> AsyncAddPluginDirectory(const nsAString& aDirectory);
@ -169,21 +166,6 @@ private:
bool mShuttingDown;
nsTArray<RefPtr<GMPParent>> mAsyncShutdownPlugins;
#ifdef MOZ_CRASHREPORTER
Mutex mAsyncShutdownPluginStatesMutex; // Protects mAsyncShutdownPluginStates.
class AsyncShutdownPluginStates
{
public:
void Update(const nsCString& aPlugin, const nsCString& aInstance,
char aId, const nsCString& aState);
private:
struct State { nsCString mStateSequence; nsCString mLastStateDescription; };
typedef nsClassHashtable<nsCStringHashKey, State> StatesByInstance;
typedef nsClassHashtable<nsCStringHashKey, StatesByInstance> StateInstancesByPlugin;
StateInstancesByPlugin mStates;
} mAsyncShutdownPluginStates;
#endif // MOZ_CRASHREPORTER
// True if we've inspected MOZ_GMP_PATH on the GMP thread and loaded any
// plugins found there into mPlugins.
Atomic<bool> mScannedPluginOnDisk;