mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 09:15:35 +00:00
b5a2bda7ee
This will mean that in places like the tight loop in GetTypeIndex() we would no longer require calling strlen() on the input type argument once per loop iteration. Depends on D20236 Differential Revision: https://phabricator.services.mozilla.com/D20237 --HG-- extra : moz-landing-system : lando
496 lines
15 KiB
C++
496 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,
|
|
&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));
|
|
}
|
|
}
|