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

Bug 1438425 - Delete DocumentRenderer. r=jesup, a=RyanVM

Browse source 
It is unused.

--HG--
extra : histedit_source : b7af9f250f0330f90547114184873ae9971f20fc
This commit is contained in:
Jeff Muizelaar 2018-03-02 15:56:02 -05:00 • committed by Roy Tam
commit a64b1808c0
15 changed files with 3 additions and 396 deletions
Download patch file Download diff file Expand all files Collapse all files

3
dom/canvas/CanvasRenderingContext2D.cpp
View file

@ -92,8 +92,7 @@
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/gfx/DataSurfaceHelpers.h"
#include "mozilla/gfx/PatternHelpers.h"
#include "mozilla/ipc/DocumentRendererParent.h"
#include "mozilla/ipc/PDocumentRendererParent.h"
#include "mozilla/gfx/Swizzle.h"
#include "mozilla/layers/PersistentBufferProvider.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/Preferences.h"

1
dom/canvas/CanvasRenderingContextHelper.cpp
View file

@ -9,6 +9,7 @@
#include "mozilla/dom/CanvasRenderingContext2D.h"
#include "mozilla/Telemetry.h"
#include "mozilla/UniquePtr.h"
#include "MozFramebuffer.h"
#include "nsContentUtils.h"
#include "nsDOMJSUtils.h"
#include "nsIScriptContext.h"

94
dom/canvas/DocumentRendererChild.cpp
View file

@ -1,94 +0,0 @@
/* 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 "mozilla/ipc/DocumentRendererChild.h"
#include "base/basictypes.h"
#include "gfx2DGlue.h"
#include "gfxPattern.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/RefPtr.h"
#include "nsPIDOMWindow.h"
#include "nsIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsCSSParser.h"
#include "nsPresContext.h"
#include "nsCOMPtr.h"
#include "nsColor.h"
#include "gfxContext.h"
#include "nsLayoutUtils.h"
#include "nsContentUtils.h"
#include "nsCSSValue.h"
#include "nsRuleNode.h"
#include "mozilla/gfx/Matrix.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::ipc;
DocumentRendererChild::DocumentRendererChild()
{}
DocumentRendererChild::~DocumentRendererChild()
{}
bool
DocumentRendererChild::RenderDocument(nsPIDOMWindowOuter* window,
const nsRect& documentRect,
const mozilla::gfx::Matrix& transform,
const nsString& aBGColor,
uint32_t renderFlags,
bool flushLayout,
const nsIntSize& renderSize,
nsCString& data)
{
if (flushLayout)
nsContentUtils::FlushLayoutForTree(window);
RefPtr<nsPresContext> presContext;
if (window) {
nsIDocShell* docshell = window->GetDocShell();
if (docshell) {
docshell->GetPresContext(getter_AddRefs(presContext));
}
}
if (!presContext)
return false;
nsCSSParser parser;
nsCSSValue bgColorValue;
if (!parser.ParseColorString(aBGColor, nullptr, 0, bgColorValue)) {
return false;
}
nscolor bgColor;
if (!nsRuleNode::ComputeColor(bgColorValue, presContext, nullptr, bgColor)) {
return false;
}
// Draw directly into the output array.
data.SetLength(renderSize.width * renderSize.height * 4);
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForData(BackendType::CAIRO,
reinterpret_cast<uint8_t*>(data.BeginWriting()),
IntSize(renderSize.width, renderSize.height),
4 * renderSize.width,
SurfaceFormat::B8G8R8A8);
if (!dt || !dt->IsValid()) {
gfxWarning() << "DocumentRendererChild::RenderDocument failed to Factory::CreateDrawTargetForData";
return false;
}
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(ctx); // already checked the draw target above
ctx->SetMatrix(mozilla::gfx::ThebesMatrix(transform));
nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
shell->RenderDocument(documentRect, renderFlags, bgColor, ctx);
return true;
}

37
dom/canvas/DocumentRendererChild.h
View file

@ -1,37 +0,0 @@
/* 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/. */
#ifndef mozilla_dom_DocumentRendererChild
#define mozilla_dom_DocumentRendererChild
#include "mozilla/ipc/PDocumentRendererChild.h"
#include "nsString.h"
#include "gfxContext.h"
class nsIDOMWindow;
namespace mozilla {
namespace ipc {
class DocumentRendererChild : public PDocumentRendererChild
{
public:
DocumentRendererChild();
virtual ~DocumentRendererChild();
bool RenderDocument(nsPIDOMWindowOuter* window,
const nsRect& documentRect, const gfx::Matrix& transform,
const nsString& bgcolor,
uint32_t renderFlags, bool flushLayout,
const nsIntSize& renderSize, nsCString& data);
private:
DISALLOW_EVIL_CONSTRUCTORS(DocumentRendererChild);
};
} // namespace ipc
} // namespace mozilla
#endif

63
dom/canvas/DocumentRendererParent.cpp
View file

@ -1,63 +0,0 @@
/* 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 "mozilla/ipc/DocumentRendererParent.h"
#include "gfx2DGlue.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/RefPtr.h"
#include "nsICanvasRenderingContextInternal.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::ipc;
DocumentRendererParent::DocumentRendererParent()
{}
DocumentRendererParent::~DocumentRendererParent()
{}
void DocumentRendererParent::SetCanvasContext(nsICanvasRenderingContextInternal* aCanvas,
gfxContext* ctx)
{
mCanvas = aCanvas;
mCanvasContext = ctx;
}
void DocumentRendererParent::DrawToCanvas(const nsIntSize& aSize,
const nsCString& aData)
{
if (!mCanvas || !mCanvasContext)
return;
DrawTarget* drawTarget = mCanvasContext->GetDrawTarget();
Rect rect(0, 0, aSize.width, aSize.height);
MaybeSnapToDevicePixels(rect, *drawTarget, true);
RefPtr<DataSourceSurface> dataSurface =
Factory::CreateWrappingDataSourceSurface(reinterpret_cast<uint8_t*>(const_cast<nsCString&>(aData).BeginWriting()),
aSize.width * 4,
IntSize(aSize.width, aSize.height),
SurfaceFormat::B8G8R8A8);
SurfacePattern pattern(dataSurface, ExtendMode::CLAMP);
drawTarget->FillRect(rect, pattern);
gfxRect damageRect = mCanvasContext->UserToDevice(ThebesRect(rect));
mCanvas->Redraw(damageRect);
}
void
DocumentRendererParent::ActorDestroy(ActorDestroyReason aWhy)
{
// Implement me! Bug 1005139
}
bool
DocumentRendererParent::Recv__delete__(const nsIntSize& renderedSize,
const nsCString& data)
{
DrawToCanvas(renderedSize, data);
return true;
}

44
dom/canvas/DocumentRendererParent.h
View file

@ -1,44 +0,0 @@
/* 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/. */
#ifndef mozilla_dom_DocumentRendererParent
#define mozilla_dom_DocumentRendererParent
#include "mozilla/ipc/PDocumentRendererParent.h"
#include "nsCOMPtr.h"
#include "nsString.h"
#include "gfxContext.h"
class nsICanvasRenderingContextInternal;
namespace mozilla {
namespace ipc {
class DocumentRendererParent : public PDocumentRendererParent
{
public:
DocumentRendererParent();
virtual ~DocumentRendererParent();
void SetCanvasContext(nsICanvasRenderingContextInternal* aCanvas,
gfxContext* ctx);
void DrawToCanvas(const nsIntSize& renderedSize,
const nsCString& aData);
virtual void ActorDestroy(ActorDestroyReason aWhy) override;
virtual bool Recv__delete__(const nsIntSize& renderedSize,
const nsCString& data) override;
private:
nsCOMPtr<nsICanvasRenderingContextInternal> mCanvas;
RefPtr<gfxContext> mCanvasContext;
DISALLOW_EVIL_CONSTRUCTORS(DocumentRendererParent);
};
} // namespace ipc
} // namespace mozilla
#endif

1
dom/canvas/WebGLContextState.cpp
View file

@ -9,6 +9,7 @@
#include "GLScreenBuffer.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/Preferences.h"
#include "MozFramebuffer.h"
#include "nsString.h"
#include "WebGLBuffer.h"
#include "WebGLContextUtils.h"

7
dom/canvas/moz.build
View file

@ -25,11 +25,6 @@ EXPORTS += [
'nsICanvasRenderingContextInternal.h',
]
EXPORTS.mozilla.ipc += [
'DocumentRendererChild.h',
'DocumentRendererParent.h',
]
EXPORTS.mozilla.dom += [
'CanvasGradient.h',
'CanvasPath.h',
@ -52,8 +47,6 @@ UNIFIED_SOURCES += [
'CanvasRenderingContext2D.cpp',
'CanvasRenderingContextHelper.cpp',
'CanvasUtils.cpp',
'DocumentRendererChild.cpp',
'DocumentRendererParent.cpp',
'ImageBitmap.cpp',
'ImageBitmapColorUtils.cpp',
'ImageBitmapRenderingContext.cpp',

20
dom/ipc/PBrowser.ipdl
View file

@ -11,7 +11,6 @@ include protocol PContent;
include protocol PContentBridge;
include protocol PDatePicker;
include protocol PDocAccessible;
include protocol PDocumentRenderer;
include protocol PFilePicker;
include protocol PIndexedDBPermissionRequest;
include protocol PRenderFrame;
@ -119,7 +118,6 @@ nested(upto inside_cpow) sync protocol PBrowser
manages PColorPicker;
manages PDatePicker;
manages PDocAccessible;
manages PDocumentRenderer;
manages PFilePicker;
manages PIndexedDBPermissionRequest;
manages PRenderFrame;
@ -738,24 +736,6 @@ child:
async LoadRemoteScript(nsString aURL, bool aRunInGlobalScope);
/**
* Create a asynchronous request to render whatever document is
* loaded in the child when this message arrives. When the
* request finishes, PDocumentRenderer:__delete__ is sent back to
* this side to notify completion.
*
* |documentRect| is the area of the remote document to draw,
* transformed by |transform|. The rendered area will have the
* default background color |bgcolor|. |renderFlags| are the
* nsIPresShell::RenderDocument() flags to use on the remote side,
* and if true, |flushLayout| will do just that before rendering
* the document. The rendered image will be of size |renderSize|.
*/
async PDocumentRenderer(nsRect documentRect, Matrix transform,
nsString bgcolor,
uint32_t renderFlags, bool flushLayout,
IntSize renderSize);
/**
* Sent by the chrome process when it no longer wants this remote
* <browser>. The child side cleans up in response, then

25
dom/ipc/PDocumentRenderer.ipdl
View file

@ -1,25 +0,0 @@
/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
/* 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 protocol PBrowser;
include "mozilla/GfxMessageUtils.h";
using nsIntSize from "nsSize.h";
namespace mozilla {
namespace ipc {
protocol PDocumentRenderer
{
manager PBrowser;
parent:
// Returns the width and height, in pixels, of the returned ARGB32 data.
async __delete__(nsIntSize renderedSize, nsCString data);
};
} // namespace ipc
} // namespace mozilla

52
dom/ipc/TabChild.cpp
View file

@ -22,7 +22,6 @@
#include "mozilla/dom/indexedDB/PIndexedDBPermissionRequestChild.h"
#include "mozilla/plugins/PluginWidgetChild.h"
#include "mozilla/IMEStateManager.h"
#include "mozilla/ipc/DocumentRendererChild.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/APZChild.h"
#include "mozilla/layers/APZCCallbackHelper.h"
@ -2006,57 +2005,6 @@ TabChild::DeallocPDocAccessibleChild(a11y::PDocAccessibleChild* aChild)
return true;
}
PDocumentRendererChild*
TabChild::AllocPDocumentRendererChild(const nsRect& documentRect,
const mozilla::gfx::Matrix& transform,
const nsString& bgcolor,
const uint32_t& renderFlags,
const bool& flushLayout,
const nsIntSize& renderSize)
{
return new DocumentRendererChild();
}
bool
TabChild::DeallocPDocumentRendererChild(PDocumentRendererChild* actor)
{
delete actor;
return true;
}
bool
TabChild::RecvPDocumentRendererConstructor(PDocumentRendererChild* actor,
const nsRect& documentRect,
const mozilla::gfx::Matrix& transform,
const nsString& bgcolor,
const uint32_t& renderFlags,
const bool& flushLayout,
const nsIntSize& renderSize)
{
DocumentRendererChild *render = static_cast<DocumentRendererChild *>(actor);
nsCOMPtr<nsIWebBrowser> browser = do_QueryInterface(WebNavigation());
if (!browser)
return true; // silently ignore
nsCOMPtr<mozIDOMWindowProxy> window;
if (NS_FAILED(browser->GetContentDOMWindow(getter_AddRefs(window))) ||
!window)
{
return true; // silently ignore
}
nsCString data;
bool ret = render->RenderDocument(nsPIDOMWindowOuter::From(window),
documentRect, transform,
bgcolor,
renderFlags, flushLayout,
renderSize, data);
if (!ret)
return true; // silently ignore
return PDocumentRendererChild::Send__delete__(actor, renderSize, data);
}
PColorPickerChild*
TabChild::AllocPColorPickerChild(const nsString&, const nsString&)
{

21
dom/ipc/TabChild.h
View file

@ -445,27 +445,6 @@ public:
virtual bool DeallocPDocAccessibleChild(PDocAccessibleChild*) override;
virtual PDocumentRendererChild*
AllocPDocumentRendererChild(const nsRect& aDocumentRect,
const gfx::Matrix& aTransform,
const nsString& aBggcolor,
const uint32_t& aRenderFlags,
const bool& aFlushLayout,
const nsIntSize& arenderSize) override;
virtual bool
DeallocPDocumentRendererChild(PDocumentRendererChild* aCctor) override;
virtual bool
RecvPDocumentRendererConstructor(PDocumentRendererChild* aActor,
const nsRect& aDocumentRect,
const gfx::Matrix& aTransform,
const nsString& aBgcolor,
const uint32_t& aRenderFlags,
const bool& aFlushLayout,
const nsIntSize& aRenderSize) override;
virtual PColorPickerChild*
AllocPColorPickerChild(const nsString& aTitle,
const nsString& aInitialColor) override;

19
dom/ipc/TabParent.cpp
View file

@ -28,7 +28,6 @@
#include "mozilla/gfx/GPUProcessManager.h"
#include "mozilla/Hal.h"
#include "mozilla/IMEStateManager.h"
#include "mozilla/ipc/DocumentRendererParent.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
#include "mozilla/layers/AsyncDragMetrics.h"
#include "mozilla/layers/InputAPZContext.h"
@ -957,24 +956,6 @@ TabParent::GetTopLevelDocAccessible() const
return nullptr;
}
PDocumentRendererParent*
TabParent::AllocPDocumentRendererParent(const nsRect& documentRect,
const gfx::Matrix& transform,
const nsString& bgcolor,
const uint32_t& renderFlags,
const bool& flushLayout,
const nsIntSize& renderSize)
{
return new DocumentRendererParent();
}
bool
TabParent::DeallocPDocumentRendererParent(PDocumentRendererParent* actor)
{
delete actor;
return true;
}
PFilePickerParent*
TabParent::AllocPFilePickerParent(const nsString& aTitle, const int16_t& aMode)
{

11
dom/ipc/TabParent.h
View file

@ -473,17 +473,6 @@ public:
const ScrollableLayerGuid& aGuid,
uint64_t aInputBlockId);
virtual PDocumentRendererParent*
AllocPDocumentRendererParent(const nsRect& documentRect,
const gfx::Matrix& transform,
const nsString& bgcolor,
const uint32_t& renderFlags,
const bool& flushLayout,
const nsIntSize& renderSize) override;
virtual bool
DeallocPDocumentRendererParent(PDocumentRendererParent* actor) override;
virtual PFilePickerParent*
AllocPFilePickerParent(const nsString& aTitle,
const int16_t& aMode) override;

1
dom/ipc/moz.build
View file

@ -96,7 +96,6 @@ IPDL_SOURCES += [
'PCrashReporter.ipdl',
'PCycleCollectWithLogs.ipdl',
'PDatePicker.ipdl',
'PDocumentRenderer.ipdl',
'PFilePicker.ipdl',
'PMemoryReportRequest.ipdl',
'PPluginWidget.ipdl',