forked from mirrors/gecko-dev
d2ed260822
Summary: Really sorry for the size of the patch. It's mostly automatic s/nsIDocument/Document/ but I had to fix up in a bunch of places manually to add the right namespacing and such. Overall it's not a very interesting patch I think. nsDocument.cpp turns into Document.cpp, nsIDocument.h into Document.h and nsIDocumentInlines.h into DocumentInlines.h. I also changed a bunch of nsCOMPtr usage to RefPtr, but not all of it. While fixing up some of the bits I also removed some unneeded OwnerDoc() null checks and such, but I didn't do anything riskier than that.
495 lines
15 KiB
C++
495 lines
15 KiB
C++
/* -*- 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 "nsPluginArray.h"
|
|
|
|
#include "mozilla/dom/PluginArrayBinding.h"
|
|
#include "mozilla/dom/PluginBinding.h"
|
|
#include "mozilla/dom/HiddenPluginEvent.h"
|
|
|
|
#include "nsMimeTypeArray.h"
|
|
#include "Navigator.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIWebNavigation.h"
|
|
#include "nsPluginHost.h"
|
|
#include "nsPluginTags.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsIWeakReference.h"
|
|
#include "mozilla/Services.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIPermissionManager.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "nsIBlocklistService.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
nsPluginArray::nsPluginArray(nsPIDOMWindowInner* aWindow) : mWindow(aWindow) {}
|
|
|
|
void nsPluginArray::Init() {
|
|
nsCOMPtr<nsIObserverService> obsService =
|
|
mozilla::services::GetObserverService();
|
|
if (obsService) {
|
|
obsService->AddObserver(this, "plugin-info-updated", true);
|
|
}
|
|
}
|
|
|
|
nsPluginArray::~nsPluginArray() = default;
|
|
|
|
nsPIDOMWindowInner* nsPluginArray::GetParentObject() const {
|
|
MOZ_ASSERT(mWindow);
|
|
return mWindow;
|
|
}
|
|
|
|
JSObject* nsPluginArray::WrapObject(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return PluginArray_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPluginArray)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginArray)
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginArray)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsPluginArray, mWindow, mPlugins,
|
|
mCTPPlugins)
|
|
|
|
static void GetPluginMimeTypes(
|
|
const nsTArray<RefPtr<nsPluginElement>>& aPlugins,
|
|
nsTArray<RefPtr<nsMimeType>>& aMimeTypes) {
|
|
for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
|
|
nsPluginElement* plugin = aPlugins[i];
|
|
aMimeTypes.AppendElements(plugin->MimeTypes());
|
|
}
|
|
}
|
|
|
|
static bool operator<(const RefPtr<nsMimeType>& lhs,
|
|
const RefPtr<nsMimeType>& rhs) {
|
|
// Sort MIME types alphabetically by type name.
|
|
return lhs->Type() < rhs->Type();
|
|
}
|
|
|
|
void nsPluginArray::GetMimeTypes(nsTArray<RefPtr<nsMimeType>>& aMimeTypes) {
|
|
aMimeTypes.Clear();
|
|
|
|
if (!AllowPlugins()) {
|
|
return;
|
|
}
|
|
|
|
EnsurePlugins();
|
|
|
|
GetPluginMimeTypes(mPlugins, aMimeTypes);
|
|
|
|
// Alphabetize the enumeration order of non-hidden MIME types to reduce
|
|
// fingerprintable entropy based on plugins' installation file times.
|
|
aMimeTypes.Sort();
|
|
}
|
|
|
|
void nsPluginArray::GetCTPMimeTypes(nsTArray<RefPtr<nsMimeType>>& aMimeTypes) {
|
|
aMimeTypes.Clear();
|
|
|
|
if (!AllowPlugins()) {
|
|
return;
|
|
}
|
|
|
|
EnsurePlugins();
|
|
|
|
GetPluginMimeTypes(mCTPPlugins, aMimeTypes);
|
|
|
|
// Alphabetize the enumeration order of non-hidden MIME types to reduce
|
|
// fingerprintable entropy based on plugins' installation file times.
|
|
aMimeTypes.Sort();
|
|
}
|
|
|
|
nsPluginElement* nsPluginArray::Item(uint32_t aIndex, CallerType aCallerType) {
|
|
bool unused;
|
|
return IndexedGetter(aIndex, unused, aCallerType);
|
|
}
|
|
|
|
nsPluginElement* nsPluginArray::NamedItem(const nsAString& aName,
|
|
CallerType aCallerType) {
|
|
bool unused;
|
|
return NamedGetter(aName, unused, aCallerType);
|
|
}
|
|
|
|
void nsPluginArray::Refresh(bool aReloadDocuments) {
|
|
RefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
|
|
|
|
if (!AllowPlugins() || !pluginHost) {
|
|
return;
|
|
}
|
|
|
|
// NS_ERROR_PLUGINS_PLUGINSNOTCHANGED on reloading plugins indicates
|
|
// that plugins did not change and was not reloaded
|
|
if (pluginHost->ReloadPlugins() == NS_ERROR_PLUGINS_PLUGINSNOTCHANGED) {
|
|
nsTArray<nsCOMPtr<nsIInternalPluginTag>> newPluginTags;
|
|
pluginHost->GetPlugins(newPluginTags);
|
|
|
|
// Check if the number of plugins we know about are different from
|
|
// the number of plugin tags the plugin host knows about. If the
|
|
// lengths are different, we refresh. This is safe because we're
|
|
// notified for every plugin enabling/disabling event that
|
|
// happens, and therefore the lengths will be in sync only when
|
|
// the both arrays contain the same plugin tags (though as
|
|
// different types).
|
|
if (newPluginTags.Length() == mPlugins.Length()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
mPlugins.Clear();
|
|
mCTPPlugins.Clear();
|
|
|
|
RefPtr<Navigator> navigator = mWindow->Navigator();
|
|
navigator->RefreshMIMEArray();
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(mWindow);
|
|
if (aReloadDocuments && webNav) {
|
|
webNav->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
|
|
}
|
|
}
|
|
|
|
nsPluginElement* nsPluginArray::IndexedGetter(uint32_t aIndex, bool& aFound,
|
|
CallerType aCallerType) {
|
|
aFound = false;
|
|
|
|
if (!AllowPlugins() || nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return nullptr;
|
|
}
|
|
|
|
EnsurePlugins();
|
|
|
|
aFound = aIndex < mPlugins.Length();
|
|
|
|
if (!aFound) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mPlugins[aIndex];
|
|
}
|
|
|
|
void nsPluginArray::Invalidate() {
|
|
nsCOMPtr<nsIObserverService> obsService =
|
|
mozilla::services::GetObserverService();
|
|
if (obsService) {
|
|
obsService->RemoveObserver(this, "plugin-info-updated");
|
|
}
|
|
}
|
|
|
|
static nsPluginElement* FindPlugin(
|
|
const nsTArray<RefPtr<nsPluginElement>>& aPlugins, const nsAString& aName) {
|
|
for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
|
|
nsAutoString pluginName;
|
|
nsPluginElement* plugin = aPlugins[i];
|
|
plugin->GetName(pluginName);
|
|
|
|
if (pluginName.Equals(aName)) {
|
|
return plugin;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsPluginElement* nsPluginArray::NamedGetter(const nsAString& aName,
|
|
bool& aFound,
|
|
CallerType aCallerType) {
|
|
aFound = false;
|
|
|
|
if (!AllowPlugins() || nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return nullptr;
|
|
}
|
|
|
|
EnsurePlugins();
|
|
|
|
nsPluginElement* plugin = FindPlugin(mPlugins, aName);
|
|
aFound = (plugin != nullptr);
|
|
if (!aFound) {
|
|
nsPluginElement* hiddenPlugin = FindPlugin(mCTPPlugins, aName);
|
|
if (hiddenPlugin) {
|
|
NotifyHiddenPluginTouched(hiddenPlugin);
|
|
}
|
|
}
|
|
return plugin;
|
|
}
|
|
|
|
void nsPluginArray::NotifyHiddenPluginTouched(nsPluginElement* aHiddenElement) {
|
|
HiddenPluginEventInit init;
|
|
init.mTag = aHiddenElement->PluginTag();
|
|
nsCOMPtr<Document> doc = aHiddenElement->GetParentObject()->GetDoc();
|
|
RefPtr<HiddenPluginEvent> event = HiddenPluginEvent::Constructor(
|
|
doc, NS_LITERAL_STRING("HiddenPlugin"), init);
|
|
event->SetTarget(doc);
|
|
event->SetTrusted(true);
|
|
event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
|
|
doc->DispatchEvent(*event);
|
|
}
|
|
|
|
uint32_t nsPluginArray::Length(CallerType aCallerType) {
|
|
if (!AllowPlugins() || nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return 0;
|
|
}
|
|
|
|
EnsurePlugins();
|
|
|
|
return mPlugins.Length();
|
|
}
|
|
|
|
void nsPluginArray::GetSupportedNames(nsTArray<nsString>& aRetval,
|
|
CallerType aCallerType) {
|
|
aRetval.Clear();
|
|
|
|
if (!AllowPlugins() || nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < mPlugins.Length(); ++i) {
|
|
nsAutoString pluginName;
|
|
mPlugins[i]->GetName(pluginName);
|
|
|
|
aRetval.AppendElement(pluginName);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginArray::Observe(nsISupports* aSubject, const char* aTopic,
|
|
const char16_t* aData) {
|
|
if (!nsCRT::strcmp(aTopic, "plugin-info-updated")) {
|
|
Refresh(false);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool nsPluginArray::AllowPlugins() const {
|
|
if (!mWindow) {
|
|
return false;
|
|
}
|
|
nsCOMPtr<Document> doc = mWindow->GetDoc();
|
|
if (!doc) {
|
|
return false;
|
|
}
|
|
|
|
return doc->GetAllowPlugins();
|
|
}
|
|
|
|
static bool operator<(const RefPtr<nsPluginElement>& lhs,
|
|
const RefPtr<nsPluginElement>& rhs) {
|
|
// Sort plugins alphabetically by name.
|
|
return lhs->PluginTag()->Name() < rhs->PluginTag()->Name();
|
|
}
|
|
|
|
static bool PluginShouldBeHidden(const nsCString& aName) {
|
|
// This only supports one hidden plugin
|
|
nsAutoCString value;
|
|
Preferences::GetCString("plugins.navigator.hidden_ctp_plugin", value);
|
|
return value.Equals(aName);
|
|
}
|
|
|
|
void nsPluginArray::EnsurePlugins() {
|
|
if (!mPlugins.IsEmpty() || !mCTPPlugins.IsEmpty()) {
|
|
// We already have an array of plugin elements.
|
|
return;
|
|
}
|
|
|
|
RefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
|
|
if (!pluginHost) {
|
|
// We have no plugin host.
|
|
return;
|
|
}
|
|
|
|
nsTArray<nsCOMPtr<nsIInternalPluginTag>> pluginTags;
|
|
pluginHost->GetPlugins(pluginTags);
|
|
|
|
// need to wrap each of these with a nsPluginElement, which is
|
|
// scriptable.
|
|
for (uint32_t i = 0; i < pluginTags.Length(); ++i) {
|
|
nsCOMPtr<nsPluginTag> pluginTag = do_QueryInterface(pluginTags[i]);
|
|
if (!pluginTag) {
|
|
mPlugins.AppendElement(new nsPluginElement(mWindow, pluginTags[i]));
|
|
} else if (pluginTag->IsActive()) {
|
|
uint32_t permission = nsIPermissionManager::ALLOW_ACTION;
|
|
uint32_t blocklistState;
|
|
if (pluginTag->IsClicktoplay() &&
|
|
NS_SUCCEEDED(pluginTag->GetBlocklistState(&blocklistState)) &&
|
|
blocklistState == nsIBlocklistService::STATE_NOT_BLOCKED) {
|
|
nsCString name;
|
|
pluginTag->GetName(name);
|
|
if (PluginShouldBeHidden(name)) {
|
|
RefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
|
|
nsCString permString;
|
|
nsresult rv =
|
|
pluginHost->GetPermissionStringForTag(pluginTag, 0, permString);
|
|
if (rv == NS_OK) {
|
|
nsCOMPtr<Document> currentDoc = mWindow->GetExtantDoc();
|
|
|
|
// The top-level content document gets the final say on whether or
|
|
// not a plugin is going to be hidden or not, regardless of the
|
|
// origin that a subframe is hosted at. This is to avoid spamming
|
|
// the user with the hidden plugin notification bar when third-party
|
|
// iframes attempt to access navigator.plugins after the user has
|
|
// already expressed that the top-level document has this
|
|
// permission.
|
|
nsCOMPtr<Document> topDoc =
|
|
currentDoc->GetTopLevelContentDocument();
|
|
|
|
if (topDoc) {
|
|
nsIPrincipal* principal = topDoc->NodePrincipal();
|
|
nsCOMPtr<nsIPermissionManager> permMgr =
|
|
services::GetPermissionManager();
|
|
permMgr->TestPermissionFromPrincipal(principal, permString.get(),
|
|
&permission);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (permission == nsIPermissionManager::ALLOW_ACTION) {
|
|
mPlugins.AppendElement(new nsPluginElement(mWindow, pluginTags[i]));
|
|
} else {
|
|
mCTPPlugins.AppendElement(new nsPluginElement(mWindow, pluginTags[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mPlugins.Length() == 0 && mCTPPlugins.Length() != 0) {
|
|
nsCOMPtr<nsPluginTag> hiddenTag = new nsPluginTag(
|
|
"Hidden Plugin", nullptr, "dummy.plugin", nullptr, nullptr, nullptr,
|
|
nullptr, nullptr, 0, 0, false, nsIBlocklistService::STATE_NOT_BLOCKED);
|
|
mPlugins.AppendElement(new nsPluginElement(mWindow, hiddenTag));
|
|
}
|
|
|
|
// Alphabetize the enumeration order of non-hidden plugins to reduce
|
|
// fingerprintable entropy based on plugins' installation file times.
|
|
mPlugins.Sort();
|
|
}
|
|
// nsPluginElement implementation.
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPluginElement)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginElement)
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginElement)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsPluginElement, mWindow, mMimeTypes)
|
|
|
|
nsPluginElement::nsPluginElement(nsPIDOMWindowInner* aWindow,
|
|
nsIInternalPluginTag* aPluginTag)
|
|
: mWindow(aWindow), mPluginTag(aPluginTag) {}
|
|
|
|
nsPluginElement::~nsPluginElement() = default;
|
|
|
|
nsPIDOMWindowInner* nsPluginElement::GetParentObject() const {
|
|
MOZ_ASSERT(mWindow);
|
|
return mWindow;
|
|
}
|
|
|
|
JSObject* nsPluginElement::WrapObject(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return Plugin_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
void nsPluginElement::GetDescription(nsString& retval) const {
|
|
CopyUTF8toUTF16(mPluginTag->Description(), retval);
|
|
}
|
|
|
|
void nsPluginElement::GetFilename(nsString& retval) const {
|
|
CopyUTF8toUTF16(mPluginTag->FileName(), retval);
|
|
}
|
|
|
|
void nsPluginElement::GetVersion(nsString& retval) const {
|
|
CopyUTF8toUTF16(mPluginTag->Version(), retval);
|
|
}
|
|
|
|
void nsPluginElement::GetName(nsString& retval) const {
|
|
CopyUTF8toUTF16(mPluginTag->Name(), retval);
|
|
}
|
|
|
|
nsMimeType* nsPluginElement::Item(uint32_t aIndex) {
|
|
EnsurePluginMimeTypes();
|
|
|
|
return mMimeTypes.SafeElementAt(aIndex);
|
|
}
|
|
|
|
nsMimeType* nsPluginElement::NamedItem(const nsAString& aName) {
|
|
bool unused;
|
|
return NamedGetter(aName, unused);
|
|
}
|
|
|
|
nsMimeType* nsPluginElement::IndexedGetter(uint32_t aIndex, bool& aFound) {
|
|
EnsurePluginMimeTypes();
|
|
|
|
aFound = aIndex < mMimeTypes.Length();
|
|
|
|
if (!aFound) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mMimeTypes[aIndex];
|
|
}
|
|
|
|
nsMimeType* nsPluginElement::NamedGetter(const nsAString& aName, bool& aFound) {
|
|
EnsurePluginMimeTypes();
|
|
|
|
aFound = false;
|
|
|
|
for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
|
|
if (mMimeTypes[i]->Type().Equals(aName)) {
|
|
aFound = true;
|
|
|
|
return mMimeTypes[i];
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t nsPluginElement::Length() {
|
|
EnsurePluginMimeTypes();
|
|
|
|
return mMimeTypes.Length();
|
|
}
|
|
|
|
void nsPluginElement::GetSupportedNames(nsTArray<nsString>& retval) {
|
|
EnsurePluginMimeTypes();
|
|
|
|
for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
|
|
retval.AppendElement(mMimeTypes[i]->Type());
|
|
}
|
|
}
|
|
|
|
nsTArray<RefPtr<nsMimeType>>& nsPluginElement::MimeTypes() {
|
|
EnsurePluginMimeTypes();
|
|
|
|
return mMimeTypes;
|
|
}
|
|
|
|
void nsPluginElement::EnsurePluginMimeTypes() {
|
|
if (!mMimeTypes.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (mPluginTag->MimeTypes().Length() !=
|
|
mPluginTag->MimeDescriptions().Length() ||
|
|
mPluginTag->MimeTypes().Length() != mPluginTag->Extensions().Length()) {
|
|
MOZ_ASSERT(false, "mime type arrays expected to be the same length");
|
|
return;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < mPluginTag->MimeTypes().Length(); ++i) {
|
|
NS_ConvertUTF8toUTF16 type(mPluginTag->MimeTypes()[i]);
|
|
NS_ConvertUTF8toUTF16 description(mPluginTag->MimeDescriptions()[i]);
|
|
NS_ConvertUTF8toUTF16 extension(mPluginTag->Extensions()[i]);
|
|
|
|
mMimeTypes.AppendElement(
|
|
new nsMimeType(mWindow, this, type, description, extension));
|
|
}
|
|
}
|