diff -r 000000000000 -r 6474c204b198 layout/ipc/RenderFrameParent.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/layout/ipc/RenderFrameParent.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,269 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: sw=2 ts=8 et : + */ +/* 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_layout_RenderFrameParent_h +#define mozilla_layout_RenderFrameParent_h + +#include "mozilla/Attributes.h" +#include + +#include "mozilla/layout/PRenderFrameParent.h" +#include "mozilla/layers/ShadowLayersManager.h" +#include "nsDisplayList.h" +#include "RenderFrameUtils.h" + +class nsContentView; +class nsFrameLoader; +class nsSubDocumentFrame; + +namespace mozilla { + +class InputEvent; + +namespace layers { +class APZCTreeManager; +class GestureEventListener; +class TargetConfig; +class LayerTransactionParent; +struct TextureFactoryIdentifier; +struct ScrollableLayerGuid; +} + +namespace layout { + +class RemoteContentController; + +class RenderFrameParent : public PRenderFrameParent, + public mozilla::layers::ShadowLayersManager +{ + typedef mozilla::layers::FrameMetrics FrameMetrics; + typedef mozilla::layers::ContainerLayer ContainerLayer; + typedef mozilla::layers::Layer Layer; + typedef mozilla::layers::LayerManager LayerManager; + typedef mozilla::layers::TargetConfig TargetConfig; + typedef mozilla::layers::LayerTransactionParent LayerTransactionParent; + typedef mozilla::ContainerLayerParameters ContainerLayerParameters; + typedef mozilla::layers::TextureFactoryIdentifier TextureFactoryIdentifier; + typedef mozilla::layers::ScrollableLayerGuid ScrollableLayerGuid; + typedef mozilla::layers::ZoomConstraints ZoomConstraints; + typedef FrameMetrics::ViewID ViewID; + +public: + typedef std::map > ViewMap; + + /* Init should be called immediately after allocation. */ + RenderFrameParent(); + virtual ~RenderFrameParent(); + + /** + * Select the desired scrolling behavior. If ASYNC_PAN_ZOOM is + * chosen, then RenderFrameParent will watch input events and use + * them to asynchronously pan and zoom. + */ + void + Init(nsFrameLoader* aFrameLoader, + ScrollingBehavior aScrollingBehavior, + TextureFactoryIdentifier* aTextureFactoryIdentifier, + uint64_t* aId); + + void Destroy(); + + /** + * Helper functions for getting a non-owning reference to a scrollable. + * @param aId The ID of the frame. + */ + nsContentView* GetContentView(ViewID aId); + nsContentView* GetRootContentView(); + + void ContentViewScaleChanged(nsContentView* aView); + + virtual void ShadowLayersUpdated(LayerTransactionParent* aLayerTree, + const TargetConfig& aTargetConfig, + bool aIsFirstPaint, + bool aScheduleComposite) MOZ_OVERRIDE; + + void BuildDisplayList(nsDisplayListBuilder* aBuilder, + nsSubDocumentFrame* aFrame, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists); + + already_AddRefed BuildLayer(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, + LayerManager* aManager, + const nsIntRect& aVisibleRect, + nsDisplayItem* aItem, + const ContainerLayerParameters& aContainerParameters); + + void OwnerContentChanged(nsIContent* aContent); + + void SetBackgroundColor(nscolor aColor) { mBackgroundColor = gfxRGBA(aColor); }; + + /** + * Notify the APZ code of an input event, and get back the untransformed event. + * @param aEvent the input event; this is modified in-place so that the async + * transforms are unapplied. This can be passed to Gecko for hit testing + * and normal event dispatch. + * @param aOutTargetGuid An out-parameter that will contain the identifier + * of the APZC instance that handled the event, if one was found. This + * argument may be null. + */ + void NotifyInputEvent(WidgetInputEvent& aEvent, + ScrollableLayerGuid* aOutTargetGuid); + + void ZoomToRect(uint32_t aPresShellId, ViewID aViewId, const CSSRect& aRect); + + void ContentReceivedTouch(const ScrollableLayerGuid& aGuid, + bool aPreventDefault); + + void UpdateZoomConstraints(uint32_t aPresShellId, + ViewID aViewId, + bool aIsRoot, + const ZoomConstraints& aConstraints); + + bool HitTest(const nsRect& aRect); + +protected: + void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE; + + virtual bool RecvNotifyCompositorTransaction() MOZ_OVERRIDE; + + virtual bool RecvUpdateHitRegion(const nsRegion& aRegion) MOZ_OVERRIDE; + + virtual PLayerTransactionParent* AllocPLayerTransactionParent() MOZ_OVERRIDE; + virtual bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) MOZ_OVERRIDE; + +private: + void BuildViewMap(); + void TriggerRepaint(); + void DispatchEventForPanZoomController(const InputEvent& aEvent); + + LayerTransactionParent* GetShadowLayers() const; + uint64_t GetLayerTreeId() const; + Layer* GetRootLayer() const; + + // When our child frame is pushing transactions directly to the + // compositor, this is the ID of its layer tree in the compositor's + // context. + uint64_t mLayersId; + + nsRefPtr mFrameLoader; + nsRefPtr mContainer; + // When our scrolling behavior is ASYNC_PAN_ZOOM, we have a nonnull + // APZCTreeManager. It's used to manipulate the shadow layer tree + // on the compositor thread. + nsRefPtr mApzcTreeManager; + nsRefPtr mContentController; + + layers::APZCTreeManager* GetApzcTreeManager(); + + // This contains the views for all the scrollable frames currently in the + // painted region of our remote content. + ViewMap mContentViews; + + // True after Destroy() has been called, which is triggered + // originally by nsFrameLoader::Destroy(). After this point, we can + // no longer safely ask the frame loader to find its nearest layer + // manager, because it may have been disconnected from the DOM. + // It's still OK to *tell* the frame loader that we've painted after + // it's destroyed; it'll just ignore us, and we won't be able to + // find an nsIFrame to invalidate. See ShadowLayersUpdated(). + // + // Prefer the extra bit of state to null'ing out mFrameLoader in + // Destroy() so that less code needs to be special-cased for after + // Destroy(). + // + // It's possible for mFrameLoader==null and + // mFrameLoaderDestroyed==false. + bool mFrameLoaderDestroyed; + // this is gfxRGBA because that's what ColorLayer wants. + gfxRGBA mBackgroundColor; + + nsRegion mTouchRegion; +}; + +} // namespace layout +} // namespace mozilla + +/** + * A DisplayRemote exists solely to graft a child process's shadow + * layer tree (for a given RenderFrameParent) into its parent + * process's layer tree. + */ +class nsDisplayRemote : public nsDisplayItem +{ + typedef mozilla::layout::RenderFrameParent RenderFrameParent; + +public: + nsDisplayRemote(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, + RenderFrameParent* aRemoteFrame) + : nsDisplayItem(aBuilder, aFrame) + , mRemoteFrame(aRemoteFrame) + {} + + virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder, + LayerManager* aManager, + const ContainerLayerParameters& aParameters) MOZ_OVERRIDE + { return mozilla::LAYER_ACTIVE_FORCE; } + + virtual already_AddRefed + BuildLayer(nsDisplayListBuilder* aBuilder, LayerManager* aManager, + const ContainerLayerParameters& aContainerParameters) MOZ_OVERRIDE; + + void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect, + HitTestState* aState, nsTArray *aOutFrames) MOZ_OVERRIDE; + + NS_DISPLAY_DECL_NAME("Remote", TYPE_REMOTE) + +private: + RenderFrameParent* mRemoteFrame; +}; + +/** + * nsDisplayRemoteShadow is a way of adding display items for frames in a + * separate process, for hit testing only. After being processed, the hit + * test state will contain IDs for any remote frames that were hit. + * + * The frame should be its respective render frame parent. + */ +class nsDisplayRemoteShadow : public nsDisplayItem +{ + typedef mozilla::layout::RenderFrameParent RenderFrameParent; + typedef mozilla::layers::FrameMetrics::ViewID ViewID; + +public: + nsDisplayRemoteShadow(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, + nsRect aRect, + ViewID aId) + : nsDisplayItem(aBuilder, aFrame) + , mRect(aRect) + , mId(aId) + {} + + nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) MOZ_OVERRIDE + { + *aSnap = false; + return mRect; + } + + virtual uint32_t GetPerFrameKey() MOZ_OVERRIDE + { + NS_ABORT(); + return 0; + } + + void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect, + HitTestState* aState, nsTArray *aOutFrames) MOZ_OVERRIDE; + + NS_DISPLAY_DECL_NAME("Remote-Shadow", TYPE_REMOTE_SHADOW) + +private: + nsRect mRect; + ViewID mId; +}; + +#endif // mozilla_layout_RenderFrameParent_h