mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-23 02:05:42 +00:00
ace6d1063f
The inclusions were removed with the following very crude script and the resulting breakage was fixed up by hand. The manual fixups did either revert the changes done by the script, replace a generic header with a more specific one or replace a header with a forward declaration. find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2) if [ -n "$interfaces" ]; then if [[ "$interfaces" == *$'\n'* ]]; then regexp="\(" for i in $interfaces; do regexp="$regexp$i\|"; done regexp="${regexp%%\\\|}\)" else regexp="$interfaces" fi interface=$(basename "$path") rg -l "#include.*${interface%%.idl}.h" . | while read path2; do hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" ) if [ $hits -eq 0 ]; then echo "Removing ${interface} from ${path2}" grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp mv -f "$path2".tmp "$path2" fi done fi done Differential Revision: https://phabricator.services.mozilla.com/D55442 --HG-- extra : moz-landing-system : lando
278 lines
8.7 KiB
C++
278 lines
8.7 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 "MediaDocument.h"
|
|
#include "nsIPluginDocument.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIObjectFrame.h"
|
|
#include "nsNPAPIPluginInstance.h"
|
|
#include "DocumentInlines.h"
|
|
#include "nsIDocShellTreeItem.h"
|
|
#include "nsNodeInfoManager.h"
|
|
#include "nsContentCreatorFunctions.h"
|
|
#include "nsContentPolicyUtils.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "nsObjectLoadingContent.h"
|
|
#include "GeckoProfiler.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class PluginDocument final : public MediaDocument, public nsIPluginDocument {
|
|
public:
|
|
PluginDocument();
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_NSIPLUGINDOCUMENT
|
|
|
|
enum MediaDocumentKind MediaDocumentKind() const override {
|
|
return MediaDocumentKind::Plugin;
|
|
}
|
|
|
|
nsresult StartDocumentLoad(const char* aCommand, nsIChannel* aChannel,
|
|
nsILoadGroup* aLoadGroup, nsISupports* aContainer,
|
|
nsIStreamListener** aDocListener,
|
|
bool aReset = true,
|
|
nsIContentSink* aSink = nullptr) override;
|
|
|
|
void SetScriptGlobalObject(
|
|
nsIScriptGlobalObject* aScriptGlobalObject) override;
|
|
bool CanSavePresentation(nsIRequest* aNewRequest,
|
|
uint16_t& aBFCacheStatus) override;
|
|
|
|
const nsCString& GetType() const { return mMimeType; }
|
|
Element* GetPluginContent() { return mPluginContent; }
|
|
|
|
virtual void Destroy() override {
|
|
if (mStreamListener) {
|
|
mStreamListener->DropDocumentRef();
|
|
}
|
|
MediaDocument::Destroy();
|
|
}
|
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PluginDocument, MediaDocument)
|
|
protected:
|
|
~PluginDocument() override;
|
|
|
|
nsresult CreateSyntheticPluginDocument();
|
|
|
|
nsCOMPtr<Element> mPluginContent;
|
|
RefPtr<MediaDocumentStreamListener> mStreamListener;
|
|
nsCString mMimeType;
|
|
};
|
|
|
|
class PluginStreamListener : public MediaDocumentStreamListener {
|
|
public:
|
|
explicit PluginStreamListener(PluginDocument* aDoc)
|
|
: MediaDocumentStreamListener(aDoc), mPluginDoc(aDoc) {}
|
|
NS_IMETHOD OnStartRequest(nsIRequest* request) override;
|
|
|
|
private:
|
|
RefPtr<PluginDocument> mPluginDoc;
|
|
};
|
|
|
|
NS_IMETHODIMP
|
|
PluginStreamListener::OnStartRequest(nsIRequest* request) {
|
|
AUTO_PROFILER_LABEL("PluginStreamListener::OnStartRequest", NETWORK);
|
|
|
|
nsCOMPtr<nsIContent> embed = mPluginDoc->GetPluginContent();
|
|
nsCOMPtr<nsIObjectLoadingContent> objlc = do_QueryInterface(embed);
|
|
nsCOMPtr<nsIStreamListener> objListener = do_QueryInterface(objlc);
|
|
|
|
if (!objListener) {
|
|
MOZ_ASSERT_UNREACHABLE(
|
|
"PluginStreamListener without appropriate content "
|
|
"node");
|
|
return NS_BINDING_ABORTED;
|
|
}
|
|
|
|
SetStreamListener(objListener);
|
|
|
|
// Sets up the ObjectLoadingContent tag as if it is waiting for a
|
|
// channel, so it can proceed with a load normally once it gets OnStartRequest
|
|
nsresult rv = objlc->InitializeFromChannel(request);
|
|
if (NS_FAILED(rv)) {
|
|
MOZ_ASSERT_UNREACHABLE("InitializeFromChannel failed");
|
|
return rv;
|
|
}
|
|
|
|
// Note that because we're now hooked up to a plugin listener, this will
|
|
// likely spawn a plugin, which may re-enter.
|
|
return MediaDocumentStreamListener::OnStartRequest(request);
|
|
}
|
|
|
|
PluginDocument::PluginDocument() {}
|
|
|
|
PluginDocument::~PluginDocument() = default;
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(PluginDocument, MediaDocument,
|
|
mPluginContent)
|
|
|
|
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(PluginDocument, MediaDocument,
|
|
nsIPluginDocument)
|
|
|
|
void PluginDocument::SetScriptGlobalObject(
|
|
nsIScriptGlobalObject* aScriptGlobalObject) {
|
|
// Set the script global object on the superclass before doing
|
|
// anything that might require it....
|
|
MediaDocument::SetScriptGlobalObject(aScriptGlobalObject);
|
|
|
|
if (aScriptGlobalObject) {
|
|
if (!InitialSetupHasBeenDone()) {
|
|
// Create synthetic document
|
|
#ifdef DEBUG
|
|
nsresult rv =
|
|
#endif
|
|
CreateSyntheticPluginDocument();
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create synthetic document");
|
|
InitialSetupDone();
|
|
}
|
|
} else {
|
|
mStreamListener = nullptr;
|
|
}
|
|
}
|
|
|
|
bool PluginDocument::CanSavePresentation(nsIRequest* aNewRequest,
|
|
uint16_t& aBFCacheStatus) {
|
|
// Full-page plugins cannot be cached, currently, because we don't have
|
|
// the stream listener data to feed to the plugin instance.
|
|
return false;
|
|
}
|
|
|
|
nsresult PluginDocument::StartDocumentLoad(const char* aCommand,
|
|
nsIChannel* aChannel,
|
|
nsILoadGroup* aLoadGroup,
|
|
nsISupports* aContainer,
|
|
nsIStreamListener** aDocListener,
|
|
bool aReset, nsIContentSink* aSink) {
|
|
// do not allow message panes to host full-page plugins
|
|
// returning an error causes helper apps to take over
|
|
nsCOMPtr<nsIDocShellTreeItem> dsti(do_QueryInterface(aContainer));
|
|
if (dsti) {
|
|
bool isMsgPane = false;
|
|
dsti->NameEquals(NS_LITERAL_STRING("messagepane"), &isMsgPane);
|
|
if (isMsgPane) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
nsresult rv = MediaDocument::StartDocumentLoad(
|
|
aCommand, aChannel, aLoadGroup, aContainer, aDocListener, aReset, aSink);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
rv = aChannel->GetContentType(mMimeType);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
MediaDocument::UpdateTitleAndCharset(mMimeType, aChannel);
|
|
|
|
mStreamListener = new PluginStreamListener(this);
|
|
NS_ASSERTION(aDocListener, "null aDocListener");
|
|
NS_ADDREF(*aDocListener = mStreamListener);
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult PluginDocument::CreateSyntheticPluginDocument() {
|
|
NS_ASSERTION(!GetPresShell() || !GetPresShell()->DidInitialize(),
|
|
"Creating synthetic plugin document content too late");
|
|
|
|
// make our generic document
|
|
nsresult rv = MediaDocument::CreateSyntheticDocument();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
// then attach our plugin
|
|
|
|
RefPtr<Element> body = GetBodyElement();
|
|
if (!body) {
|
|
NS_WARNING("no body on plugin document!");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// remove margins from body
|
|
NS_NAMED_LITERAL_STRING(zero, "0");
|
|
body->SetAttr(kNameSpaceID_None, nsGkAtoms::marginwidth, zero, false);
|
|
body->SetAttr(kNameSpaceID_None, nsGkAtoms::marginheight, zero, false);
|
|
|
|
// make plugin content
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
|
|
nodeInfo = mNodeInfoManager->GetNodeInfo(
|
|
nsGkAtoms::embed, nullptr, kNameSpaceID_XHTML, nsINode::ELEMENT_NODE);
|
|
rv = NS_NewHTMLElement(getter_AddRefs(mPluginContent), nodeInfo.forget(),
|
|
NOT_FROM_PARSER);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// make it a named element
|
|
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::name,
|
|
NS_LITERAL_STRING("plugin"), false);
|
|
|
|
// fill viewport and auto-resize
|
|
NS_NAMED_LITERAL_STRING(percent100, "100%");
|
|
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::width, percent100,
|
|
false);
|
|
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::height, percent100,
|
|
false);
|
|
|
|
// set URL
|
|
nsAutoCString src;
|
|
mDocumentURI->GetSpec(src);
|
|
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src,
|
|
NS_ConvertUTF8toUTF16(src), false);
|
|
|
|
// set mime type
|
|
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::type,
|
|
NS_ConvertUTF8toUTF16(mMimeType), false);
|
|
|
|
// nsHTML(Shared)ObjectElement does not kick off a load on BindToTree if it is
|
|
// to a PluginDocument
|
|
body->AppendChildTo(mPluginContent, false);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PluginDocument::Print() {
|
|
NS_ENSURE_TRUE(mPluginContent, NS_ERROR_FAILURE);
|
|
|
|
nsIObjectFrame* objectFrame =
|
|
do_QueryFrame(mPluginContent->GetPrimaryFrame());
|
|
if (objectFrame) {
|
|
RefPtr<nsNPAPIPluginInstance> pi = objectFrame->GetPluginInstance();
|
|
if (pi) {
|
|
NPPrint npprint;
|
|
npprint.mode = NP_FULL;
|
|
npprint.print.fullPrint.pluginPrinted = false;
|
|
npprint.print.fullPrint.printOne = false;
|
|
npprint.print.fullPrint.platformPrint = nullptr;
|
|
|
|
pi->Print(&npprint);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
nsresult NS_NewPluginDocument(mozilla::dom::Document** aResult) {
|
|
auto* doc = new mozilla::dom::PluginDocument();
|
|
|
|
NS_ADDREF(doc);
|
|
nsresult rv = doc->Init();
|
|
|
|
if (NS_FAILED(rv)) {
|
|
NS_RELEASE(doc);
|
|
}
|
|
|
|
*aResult = doc;
|
|
|
|
return rv;
|
|
}
|