corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1349750 - Have AsyncDragMetrics use ScrollDirection instead of rolling its own direction enum. r=kats

Browse Source 
MozReview-Commit-ID: FKK4OBx12oa
This commit is contained in:
Botond Ballo
2017-05-10 15:22:04 -04:00
parent 654c075f22
commit f740ce1992
5 changed files with 21 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
gfx/ipc/GfxMessageUtils.h
View File

@@ -1286,14 +1286,6 @@ struct ParamTraits<mozilla::layers::EventRegionsOverride>
mozilla::layers::EventRegionsOverride::ALL_BITS> mozilla::layers::EventRegionsOverride::ALL_BITS>
{}; {};
template<>
struct ParamTraits<mozilla::layers::AsyncDragMetrics::DragDirection>
: public ContiguousEnumSerializer<
mozilla::layers::AsyncDragMetrics::DragDirection,
mozilla::layers::AsyncDragMetrics::DragDirection::NONE,
mozilla::layers::AsyncDragMetrics::DragDirection::SENTINEL>
{};
template<> template<>
struct ParamTraits<mozilla::layers::AsyncDragMetrics> struct ParamTraits<mozilla::layers::AsyncDragMetrics>
{ {

14
gfx/layers/apz/src/AsyncDragMetrics.h
View File

@@ -8,6 +8,7 @@
#define mozilla_layers_DragMetrics_h #define mozilla_layers_DragMetrics_h
#include "FrameMetrics.h" #include "FrameMetrics.h"
#include "LayersTypes.h"
namespace IPC { namespace IPC {
template <typename T> struct ParamTraits; template <typename T> struct ParamTraits;
@@ -21,27 +22,20 @@ class AsyncDragMetrics {
friend struct IPC::ParamTraits<mozilla::layers::AsyncDragMetrics>; friend struct IPC::ParamTraits<mozilla::layers::AsyncDragMetrics>;
public: public:
enum DragDirection {
NONE,
VERTICAL,
HORIZONTAL,
SENTINEL,
};
// IPC constructor // IPC constructor
AsyncDragMetrics() AsyncDragMetrics()
: mViewId(0) : mViewId(0)
, mPresShellId(0) , mPresShellId(0)
, mDragStartSequenceNumber(0) , mDragStartSequenceNumber(0)
, mScrollbarDragOffset(0) , mScrollbarDragOffset(0)
, mDirection(NONE) , mDirection(ScrollDirection::NONE)
{} {}
AsyncDragMetrics(const FrameMetrics::ViewID& aViewId, AsyncDragMetrics(const FrameMetrics::ViewID& aViewId,
uint32_t aPresShellId, uint32_t aPresShellId,
uint64_t aDragStartSequenceNumber, uint64_t aDragStartSequenceNumber,
CSSCoord aScrollbarDragOffset, CSSCoord aScrollbarDragOffset,
DragDirection aDirection) ScrollDirection aDirection)
: mViewId(aViewId) : mViewId(aViewId)
, mPresShellId(aPresShellId) , mPresShellId(aPresShellId)
, mDragStartSequenceNumber(aDragStartSequenceNumber) , mDragStartSequenceNumber(aDragStartSequenceNumber)
@@ -53,7 +47,7 @@ public:
uint32_t mPresShellId; uint32_t mPresShellId;
uint64_t mDragStartSequenceNumber; uint64_t mDragStartSequenceNumber;
CSSCoord mScrollbarDragOffset; CSSCoord mScrollbarDragOffset;
DragDirection mDirection; ScrollDirection mDirection;
}; };
} }

26
gfx/layers/apz/src/AsyncPanZoomController.cpp
View File

@@ -833,8 +833,8 @@ AsyncPanZoomController::ArePointerEventsConsumable(TouchBlockState* aBlock, uint
} }
template <typename Units> template <typename Units>
static CoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, const PointTyped<Units>& aValue) { static CoordTyped<Units> GetAxisStart(ScrollDirection aDir, const PointTyped<Units>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.x; return aValue.x;
} else { } else {
return aValue.y; return aValue.y;
@@ -842,8 +842,8 @@ static CoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, cons
} }
template <typename Units> template <typename Units>
static CoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, const RectTyped<Units>& aValue) { static CoordTyped<Units> GetAxisStart(ScrollDirection aDir, const RectTyped<Units>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.x; return aValue.x;
} else { } else {
return aValue.y; return aValue.y;
@@ -851,8 +851,8 @@ static CoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, cons
} }
template <typename Units> template <typename Units>
static IntCoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, const IntRectTyped<Units>& aValue) { static IntCoordTyped<Units> GetAxisStart(ScrollDirection aDir, const IntRectTyped<Units>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.x; return aValue.x;
} else { } else {
return aValue.y; return aValue.y;
@@ -860,8 +860,8 @@ static IntCoordTyped<Units> GetAxisStart(AsyncDragMetrics::DragDirection aDir, c
} }
template <typename Units> template <typename Units>
static CoordTyped<Units> GetAxisEnd(AsyncDragMetrics::DragDirection aDir, const RectTyped<Units>& aValue) { static CoordTyped<Units> GetAxisEnd(ScrollDirection aDir, const RectTyped<Units>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.x + aValue.width; return aValue.x + aValue.width;
} else { } else {
return aValue.y + aValue.height; return aValue.y + aValue.height;
@@ -869,8 +869,8 @@ static CoordTyped<Units> GetAxisEnd(AsyncDragMetrics::DragDirection aDir, const
} }
template <typename Units> template <typename Units>
static CoordTyped<Units> GetAxisLength(AsyncDragMetrics::DragDirection aDir, const RectTyped<Units>& aValue) { static CoordTyped<Units> GetAxisLength(ScrollDirection aDir, const RectTyped<Units>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.width; return aValue.width;
} else { } else {
return aValue.height; return aValue.height;
@@ -878,8 +878,8 @@ static CoordTyped<Units> GetAxisLength(AsyncDragMetrics::DragDirection aDir, con
} }
template <typename FromUnits, typename ToUnits> template <typename FromUnits, typename ToUnits>
static float GetAxisScale(AsyncDragMetrics::DragDirection aDir, const ScaleFactors2D<FromUnits, ToUnits>& aValue) { static float GetAxisScale(ScrollDirection aDir, const ScaleFactors2D<FromUnits, ToUnits>& aValue) {
if (aDir == AsyncDragMetrics::HORIZONTAL) { if (aDir == ScrollDirection::HORIZONTAL) {
return aValue.xScale; return aValue.xScale;
} else { } else {
return aValue.yScale; return aValue.yScale;
@@ -936,7 +936,7 @@ nsEventStatus AsyncPanZoomController::HandleDragEvent(const MouseInput& aEvent,
scrollPosition = std::min(scrollPosition, maxScrollPosition); scrollPosition = std::min(scrollPosition, maxScrollPosition);
CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset(); CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset();
if (aDragMetrics.mDirection == AsyncDragMetrics::HORIZONTAL) { if (aDragMetrics.mDirection == ScrollDirection::HORIZONTAL) {
scrollOffset.x = scrollPosition; scrollOffset.x = scrollPosition;
} else { } else {
scrollOffset.y = scrollPosition; scrollOffset.y = scrollPosition;

6
gfx/layers/apz/src/HitTestingTreeNode.cpp
View File

@@ -105,10 +105,8 @@ HitTestingTreeNode::SetScrollbarData(FrameMetrics::ViewID aScrollViewId,
bool bool
HitTestingTreeNode::MatchesScrollDragMetrics(const AsyncDragMetrics& aDragMetrics) const HitTestingTreeNode::MatchesScrollDragMetrics(const AsyncDragMetrics& aDragMetrics) const
{ {
return ((mScrollThumbData.mDirection == ScrollDirection::HORIZONTAL && return IsScrollThumbNode() &&
aDragMetrics.mDirection == AsyncDragMetrics::HORIZONTAL) || mScrollThumbData.mDirection == aDragMetrics.mDirection &&
(mScrollThumbData.mDirection == ScrollDirection::VERTICAL &&
aDragMetrics.mDirection == AsyncDragMetrics::VERTICAL)) &&
mScrollViewId == aDragMetrics.mViewId; mScrollViewId == aDragMetrics.mViewId;
} }

4
layout/xul/nsSliderFrame.cpp
View File

@@ -1090,8 +1090,8 @@ nsSliderFrame::StartAPZDrag(WidgetGUIEvent* aEvent)
AsyncDragMetrics dragMetrics(scrollTargetId, presShellId, inputblockId, AsyncDragMetrics dragMetrics(scrollTargetId, presShellId, inputblockId,
NSAppUnitsToFloatPixels(mDragStart, NSAppUnitsToFloatPixels(mDragStart,
float(AppUnitsPerCSSPixel())), float(AppUnitsPerCSSPixel())),
isHorizontal ? AsyncDragMetrics::HORIZONTAL : isHorizontal ? ScrollDirection::HORIZONTAL :
AsyncDragMetrics::VERTICAL); ScrollDirection::VERTICAL);
if (!nsLayoutUtils::HasDisplayPort(scrollableContent)) { if (!nsLayoutUtils::HasDisplayPort(scrollableContent)) {
return; return;