Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am d2738ead: Merge "Frameworks/base: Unused parameters in hwui"

Browse Source 
* commit 'd2738eadc1f8c92c64d47429ef3f168738431809':
  Frameworks/base: Unused parameters in hwui
This commit is contained in:
Andreas Gampe
2014-11-21 21:38:42 +00:00
committed by Android Git Automerger
parent e606a7884d d2738eadc1
commit 99377df12e
25 changed files with 196 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libs/hwui/Android.mk
View File

@@ -6,8 +6,6 @@ LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
# getConfig in external/skia/include/core/SkBitmap.h is deprecated.
# Allow Gnu extension: in-class initializer of static 'const float' member.
LOCAL_CLANG_CFLAGS += \
-Wno-unused-parameter \
-Wno-deprecated-declarations \
-Wno-gnu-static-float-init
# Only build libhwui when USE_OPENGL_RENDERER is

2
libs/hwui/AnimationContext.cpp
View File

@@ -54,7 +54,7 @@ void AnimationContext::addAnimationHandle(AnimationHandle* handle) {
handle->insertAfter(&mNextFrameAnimations);
}
void AnimationContext::startFrame(TreeInfo::TraversalMode mode) {
void AnimationContext::startFrame(TreeInfo::TraversalMode /* mode */) {
LOG_ALWAYS_FATAL_IF(mCurrentFrameAnimations.mNextHandle,
"Missed running animations last frame!");
AnimationHandle* head = mNextFrameAnimations.mNextHandle;

8
libs/hwui/Animator.cpp
View File

@@ -245,11 +245,11 @@ CanvasPropertyPrimitiveAnimator::CanvasPropertyPrimitiveAnimator(
, mProperty(property) {
}
float CanvasPropertyPrimitiveAnimator::getValue(RenderNode* target) const {
float CanvasPropertyPrimitiveAnimator::getValue(RenderNode* /* target */) const {
return mProperty->value;
}
void CanvasPropertyPrimitiveAnimator::setValue(RenderNode* target, float value) {
void CanvasPropertyPrimitiveAnimator::setValue(RenderNode* /* target */, float value) {
mProperty->value = value;
}
@@ -268,7 +268,7 @@ CanvasPropertyPaintAnimator::CanvasPropertyPaintAnimator(
, mField(field) {
}
float CanvasPropertyPaintAnimator::getValue(RenderNode* target) const {
float CanvasPropertyPaintAnimator::getValue(RenderNode* /* target */) const {
switch (mField) {
case STROKE_WIDTH:
return mProperty->value.getStrokeWidth();
@@ -284,7 +284,7 @@ static uint8_t to_uint8(float value) {
return static_cast<uint8_t>( c < 0 ? 0 : c > 255 ? 255 : c );
}
void CanvasPropertyPaintAnimator::setValue(RenderNode* target, float value) {
void CanvasPropertyPaintAnimator::setValue(RenderNode* /* target */, float value) {
switch (mField) {
case STROKE_WIDTH:
mProperty->value.setStrokeWidth(value);

10
libs/hwui/Caches.h
View File

@@ -385,13 +385,13 @@ private:
bool bindIndicesBufferInternal(const GLuint buffer);
static void eventMarkNull(GLsizei length, const GLchar* marker) { }
static void startMarkNull(GLsizei length, const GLchar* marker) { }
static void eventMarkNull(GLsizei /* length */, const GLchar* /* marker */) { }
static void startMarkNull(GLsizei /* length */, const GLchar* /* marker */) { }
static void endMarkNull() { }
static void setLabelNull(GLenum type, uint object, GLsizei length,
const char* label) { }
static void getLabelNull(GLenum type, uint object, GLsizei bufferSize,
static void setLabelNull(GLenum /* type */, uint /* object */, GLsizei /* length */,
const char* /* label */) { }
static void getLabelNull(GLenum /* type */, uint /* object */, GLsizei /* bufferSize */,
GLsizei* length, char* label) {
if (length) *length = 0;
if (label) *label = '\0';

14
libs/hwui/DeferredDisplayList.cpp
View File

@@ -55,7 +55,7 @@ public:
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) = 0;
virtual ~Batch() {}
virtual bool purelyDrawBatch() { return false; }
virtual bool coversBounds(const Rect& bounds) { return false; }
virtual bool coversBounds(const Rect& /* bounds */) { return false; }
};
class DrawBatch : public Batch {
@@ -91,7 +91,7 @@ public:
return false;
}
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int /* index */) {
DEFER_LOGD("%d replaying DrawBatch %p, with %d ops (batch id %x, merge id %p)",
index, this, mOps.size(), getBatchId(), getMergeId());
@@ -269,7 +269,7 @@ public:
if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = state->mClip.bottom;
}
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int /* index */) {
DEFER_LOGD("%d replaying MergingDrawBatch %p, with %d ops,"
" clip flags %x (batch id %x, merge id %p)",
index, this, mOps.size(), mClipSideFlags, getBatchId(), getMergeId());
@@ -313,7 +313,7 @@ public:
// creates a single operation batch
StateOpBatch(const StateOp* op, const DeferredDisplayState* state) : mOp(op), mState(state) {}
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
virtual status_t replay(OpenGLRenderer& renderer, Rect& /* dirty */, int /* index */) {
DEFER_LOGD("replaying state op batch %p", this);
renderer.restoreDisplayState(*mState);
@@ -332,10 +332,10 @@ private:
class RestoreToCountBatch : public Batch {
public:
RestoreToCountBatch(const StateOp* op, const DeferredDisplayState* state, int restoreCount) :
mState(state), mRestoreCount(restoreCount) {}
RestoreToCountBatch(const StateOp* /* op */, const DeferredDisplayState* state,
int restoreCount) : mState(state), mRestoreCount(restoreCount) {}
virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
virtual status_t replay(OpenGLRenderer& renderer, Rect& /* dirty */, int /* index */) {
DEFER_LOGD("batch %p restoring to count %d", this, mRestoreCount);
renderer.restoreDisplayState(*mState);

234
libs/hwui/DisplayListOp.h
View File

@@ -63,7 +63,7 @@ public:
// These objects should always be allocated with a LinearAllocator, and never destroyed/deleted.
// standard new() intentionally not implemented, and delete/deconstructor should never be used.
virtual ~DisplayListOp() { CRASH(); }
static void operator delete(void* ptr) { CRASH(); }
static void operator delete(void* /* ptr */) { CRASH(); }
/** static void* operator new(size_t size); PURPOSELY OMITTED **/
static void* operator new(size_t size, LinearAllocator& allocator) {
return allocator.alloc(size);
@@ -93,8 +93,8 @@ public:
virtual ~StateOp() {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
bool /* useQuickReject */) {
// default behavior only affects immediate, deferrable state, issue directly to renderer
applyState(deferStruct.mRenderer, saveCount);
}
@@ -103,8 +103,8 @@ public:
* State operations are applied directly to the renderer, but can cause the deferred drawing op
* list to flush
*/
virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
bool useQuickReject) {
virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int /* level */,
bool /* useQuickReject */) {
applyState(replayStruct.mRenderer, saveCount);
}
@@ -117,7 +117,7 @@ public:
DrawOp(const SkPaint* paint)
: mPaint(paint), mQuickRejected(false) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
bool useQuickReject) {
if (mQuickRejected && CC_LIKELY(useQuickReject)) {
return;
@@ -126,7 +126,7 @@ public:
deferStruct.mDeferredList.addDrawOp(deferStruct.mRenderer, this);
}
virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int /* level */,
bool useQuickReject) {
if (mQuickRejected && CC_LIKELY(useQuickReject)) {
return;
@@ -145,7 +145,7 @@ public:
* reducing which operations are tagged as mergeable.
*/
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
const Vector<OpStatePair>& ops, const Rect& bounds) {
const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
status_t status = DrawGlInfo::kStatusDone;
for (unsigned int i = 0; i < ops.size(); i++) {
renderer.restoreDisplayState(*(ops[i].state), true);
@@ -164,15 +164,15 @@ public:
*
* if a subclass can set deferInfo.mergeable to true, it should implement multiDraw()
*/
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {}
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& /* deferInfo */,
const DeferredDisplayState& /* state */) {}
/**
* Query the conservative, local bounds (unmapped) bounds of the op.
*
* returns true if bounds exist
*/
virtual bool getLocalBounds(Rect& localBounds) {
virtual bool getLocalBounds(Rect& /* localBounds */) {
return false;
}
@@ -282,17 +282,17 @@ public:
SaveOp(int flags)
: mFlags(flags) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
bool /* useQuickReject */) {
int newSaveCount = deferStruct.mRenderer.save(mFlags);
deferStruct.mDeferredList.addSave(deferStruct.mRenderer, this, newSaveCount);
}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.save(mFlags);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Save flags %x", mFlags);
}
@@ -308,8 +308,8 @@ public:
RestoreToCountOp(int count)
: mCount(count) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
bool /* useQuickReject */) {
deferStruct.mDeferredList.addRestoreToCount(deferStruct.mRenderer,
this, saveCount + mCount);
deferStruct.mRenderer.restoreToCount(saveCount + mCount);
@@ -319,7 +319,7 @@ public:
renderer.restoreToCount(saveCount + mCount);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Restore to count %d", mCount);
}
@@ -346,8 +346,8 @@ public:
, mConvexMask(NULL)
{}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
bool /* useQuickReject */) {
// NOTE: don't bother with actual saveLayer, instead issuing it at flush time
int newSaveCount = deferStruct.mRenderer.getSaveCount();
deferStruct.mDeferredList.addSaveLayer(deferStruct.mRenderer, this, newSaveCount);
@@ -358,12 +358,12 @@ public:
mPaint, mFlags);
}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.saveLayer(mArea.left, mArea.top, mArea.right, mArea.bottom,
mPaint, mFlags, mConvexMask);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("SaveLayer%s of area " RECT_STRING,
(isSaveLayerAlpha() ? "Alpha" : ""),RECT_ARGS(mArea));
}
@@ -399,11 +399,11 @@ public:
TranslateOp(float dx, float dy)
: mDx(dx), mDy(dy) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.translate(mDx, mDy);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Translate by %f %f", mDx, mDy);
}
@@ -419,11 +419,11 @@ public:
RotateOp(float degrees)
: mDegrees(degrees) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.rotate(mDegrees);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Rotate by %f degrees", mDegrees);
}
@@ -438,11 +438,11 @@ public:
ScaleOp(float sx, float sy)
: mSx(sx), mSy(sy) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.scale(mSx, mSy);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Scale by %f %f", mSx, mSy);
}
@@ -458,11 +458,11 @@ public:
SkewOp(float sx, float sy)
: mSx(sx), mSy(sy) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.skew(mSx, mSy);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Skew by %f %f", mSx, mSy);
}
@@ -478,11 +478,11 @@ public:
SetMatrixOp(const SkMatrix& matrix)
: mMatrix(matrix) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.setMatrix(mMatrix);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
if (mMatrix.isIdentity()) {
OP_LOGS("SetMatrix (reset)");
} else {
@@ -501,11 +501,11 @@ public:
ConcatMatrixOp(const SkMatrix& matrix)
: mMatrix(matrix) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.concatMatrix(mMatrix);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("ConcatMatrix " SK_MATRIX_STRING, SK_MATRIX_ARGS(&mMatrix));
}
@@ -519,8 +519,8 @@ class ClipOp : public StateOp {
public:
ClipOp(SkRegion::Op op) : mOp(op) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
bool /* useQuickReject */) {
// NOTE: must defer op BEFORE applying state, since it may read clip
deferStruct.mDeferredList.addClip(deferStruct.mRenderer, this);
@@ -543,11 +543,11 @@ public:
ClipRectOp(float left, float top, float right, float bottom, SkRegion::Op op)
: ClipOp(op), mArea(left, top, right, bottom) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.clipRect(mArea.left, mArea.top, mArea.right, mArea.bottom, mOp);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("ClipRect " RECT_STRING, RECT_ARGS(mArea));
}
@@ -565,11 +565,11 @@ public:
ClipPathOp(const SkPath* path, SkRegion::Op op)
: ClipOp(op), mPath(path) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.clipPath(mPath, mOp);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
SkRect bounds = mPath->getBounds();
OP_LOG("ClipPath bounds " RECT_STRING,
bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
@@ -586,11 +586,11 @@ public:
ClipRegionOp(const SkRegion* region, SkRegion::Op op)
: ClipOp(op), mRegion(region) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.clipRegion(mRegion, mOp);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
SkIRect bounds = mRegion->getBounds();
OP_LOG("ClipRegion bounds %d %d %d %d",
bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
@@ -604,11 +604,11 @@ private:
class ResetPaintFilterOp : public StateOp {
public:
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.resetPaintFilter();
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOGS("ResetPaintFilter");
}
@@ -620,11 +620,11 @@ public:
SetupPaintFilterOp(int clearBits, int setBits)
: mClearBits(clearBits), mSetBits(setBits) {}
virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
renderer.setupPaintFilter(mClearBits, mSetBits);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("SetupPaintFilter, clear %#x, set %#x", mClearBits, mSetBits);
}
@@ -652,7 +652,7 @@ public:
}
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawBitmap(mBitmap, getPaint(renderer));
}
@@ -675,7 +675,7 @@ public:
* for each bitmap in the batch. This method is also responsible for dirtying
* the current layer, if any.
*/
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
const Vector<OpStatePair>& ops, const Rect& bounds) {
const DeferredDisplayState& firstState = *(ops[0].state);
renderer.restoreDisplayState(firstState, true); // restore all but the clip
@@ -716,13 +716,13 @@ public:
pureTranslate, bounds, mPaint);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw bitmap %p at %f %f", mBitmap, mLocalBounds.left, mLocalBounds.top);
}
virtual const char* name() { return "DrawBitmap"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
deferInfo.mergeId = getAtlasEntry() ?
@@ -755,21 +755,21 @@ public:
: DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint),
mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw bitmap %p src=" RECT_STRING ", dst=" RECT_STRING,
mBitmap, RECT_ARGS(mSrc), RECT_ARGS(mLocalBounds));
}
virtual const char* name() { return "DrawBitmapRect"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
@@ -783,18 +783,18 @@ public:
DrawBitmapDataOp(const SkBitmap* bitmap, const SkPaint* paint)
: DrawBitmapOp(bitmap, paint) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawBitmapData(mBitmap, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw bitmap %p", mBitmap);
}
virtual const char* name() { return "DrawBitmapData"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
};
@@ -807,19 +807,19 @@ public:
mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight),
mVertices(vertices), mColors(colors) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
mVertices, mColors, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw bitmap %p mesh %d x %d", mBitmap, mMeshWidth, mMeshHeight);
}
virtual const char* name() { return "DrawBitmapMesh"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
@@ -868,8 +868,8 @@ public:
* and transforming the vertices of each 9-patch in the batch. This method
* is also responsible for dirtying the current layer, if any.
*/
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
const Vector<OpStatePair>& ops, const Rect& bounds) {
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
const DeferredDisplayState& firstState = *(ops[0].state);
renderer.restoreDisplayState(firstState, true); // restore all but the clip
@@ -942,7 +942,7 @@ public:
&vertices[0], indexCount, getPaint(renderer));
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
// We're not calling the public variant of drawPatch() here
// This method won't perform the quickReject() since we've already done it at this point
return renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(),
@@ -950,13 +950,13 @@ public:
getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw patch " RECT_STRING, RECT_ARGS(mLocalBounds));
}
virtual const char* name() { return "DrawPatch"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Patch;
deferInfo.mergeId = getAtlasEntry() ? (mergeid_t) mEntry->getMergeId() : (mergeid_t) mBitmap;
@@ -982,11 +982,11 @@ public:
DrawColorOp(int color, SkXfermode::Mode mode)
: DrawOp(NULL), mColor(color), mMode(mode) {};
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawColor(mColor, mMode);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw color %#x, mode %d", mColor, mMode);
}
@@ -1012,8 +1012,8 @@ public:
return true;
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
if (mPaint->getPathEffect()) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
} else {
@@ -1029,12 +1029,12 @@ public:
DrawRectOp(float left, float top, float right, float bottom, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Rect " RECT_STRING, RECT_ARGS(mLocalBounds));
}
@@ -1054,18 +1054,18 @@ public:
: DrawBoundedOp(rects, count, paint),
mRects(rects), mCount(count) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawRects(mRects, mCount, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Rects count %d", mCount);
}
virtual const char* name() { return "DrawRects"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Vertices;
}
@@ -1080,12 +1080,12 @@ public:
float rx, float ry, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw RoundRect " RECT_STRING ", rx %f, ry %f", RECT_ARGS(mLocalBounds), mRx, mRy);
}
@@ -1112,12 +1112,12 @@ public:
: DrawOp(paint), mLeft(left), mTop(top), mRight(right), mBottom(bottom),
mRx(rx), mRy(ry) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom,
*mRx, *mRy, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw RoundRect Props " RECT_STRING ", rx %f, ry %f",
*mLeft, *mTop, *mRight, *mBottom, *mRx, *mRy);
}
@@ -1139,11 +1139,11 @@ public:
: DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint),
mX(x), mY(y), mRadius(radius) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawCircle(mX, mY, mRadius, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Circle x %f, y %f, r %f", mX, mY, mRadius);
}
@@ -1160,11 +1160,11 @@ public:
DrawCirclePropsOp(float* x, float* y, float* radius, const SkPaint* paint)
: DrawOp(paint), mX(x), mY(y), mRadius(radius) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawCircle(*mX, *mY, *mRadius, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Circle Props x %p, y %p, r %p", mX, mY, mRadius);
}
@@ -1181,12 +1181,12 @@ public:
DrawOvalOp(float left, float top, float right, float bottom, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Oval " RECT_STRING, RECT_ARGS(mLocalBounds));
}
@@ -1200,13 +1200,13 @@ public:
: DrawStrokableOp(left, top, right, bottom, paint),
mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom,
mStartAngle, mSweepAngle, mUseCenter, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Arc " RECT_STRING ", start %f, sweep %f, useCenter %d",
RECT_ARGS(mLocalBounds), mStartAngle, mSweepAngle, mUseCenter);
}
@@ -1231,19 +1231,19 @@ public:
mLocalBounds.set(left, top, left + width, top + height);
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawPath(mPath, getPaint(renderer));
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
const DeferredDisplayState& /* state */) {
const SkPaint* paint = getPaint(renderer);
renderer.getCaches().pathCache.precache(mPath, paint);
deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Path %p in " RECT_STRING, mPath, RECT_ARGS(mLocalBounds));
}
@@ -1261,18 +1261,18 @@ public:
mLocalBounds.outset(strokeWidthOutset());
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawLines(mPoints, mCount, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Lines count %d", mCount);
}
virtual const char* name() { return "DrawLines"; }
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
const DeferredDisplayState& /* state */) {
deferInfo.batchId = mPaint->isAntiAlias() ?
DeferredDisplayList::kOpBatch_AlphaVertices :
DeferredDisplayList::kOpBatch_Vertices;
@@ -1288,11 +1288,11 @@ public:
DrawPointsOp(const float* points, int count, const SkPaint* paint)
: DrawLinesOp(points, count, paint) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawPoints(mPoints, mCount, getPaint(renderer));
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Points count %d", mCount);
}
@@ -1304,7 +1304,7 @@ public:
DrawSomeTextOp(const char* text, int bytesCount, int count, const SkPaint* paint)
: DrawOp(paint), mText(text), mBytesCount(bytesCount), mCount(count) {};
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw some text, %d bytes", mBytesCount);
}
@@ -1313,7 +1313,7 @@ public:
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
const DeferredDisplayState& /* state */) {
const SkPaint* paint = getPaint(renderer);
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(paint);
fontRenderer.precache(paint, mText, mCount, SkMatrix::I());
@@ -1338,7 +1338,7 @@ public:
/* TODO: inherit from DrawBounded and init mLocalBounds */
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
mHOffset, mVOffset, getPaint(renderer));
}
@@ -1359,7 +1359,7 @@ public:
/* TODO: inherit from DrawBounded and init mLocalBounds */
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawPosText(mText, mBytesCount, mCount, mPositions, getPaint(renderer));
}
@@ -1403,15 +1403,15 @@ public:
&& OpenGLRenderer::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode;
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
Rect bounds;
getLocalBounds(bounds);
return renderer.drawText(mText, mBytesCount, mCount, mX, mY,
mPositions, getPaint(renderer), mTotalAdvance, bounds);
}
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
const Vector<OpStatePair>& ops, const Rect& bounds) {
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
status_t status = DrawGlInfo::kStatusDone;
for (unsigned int i = 0; i < ops.size(); i++) {
const DeferredDisplayState& state = *(ops[i].state);
@@ -1428,7 +1428,7 @@ public:
return status;
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Text of count %d, bytes %d", mCount, mBytesCount);
}
@@ -1461,7 +1461,7 @@ public:
return ret;
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Functor %p", mFunctor);
}
@@ -1479,21 +1479,21 @@ public:
: DrawBoundedOp(0, 0, renderNode->getWidth(), renderNode->getHeight(), 0),
mRenderNode(renderNode), mFlags(flags), mTransformFromParent(transformFromParent) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int level,
bool /* useQuickReject */) {
if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
mRenderNode->defer(deferStruct, level + 1);
}
}
virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
bool useQuickReject) {
virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int level,
bool /* useQuickReject */) {
if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
mRenderNode->replay(replayStruct, level + 1);
}
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& /* renderer */, Rect& /* dirty */) {
LOG_ALWAYS_FATAL("should not be called, because replay() is overridden");
return 0;
}
@@ -1547,14 +1547,14 @@ public:
, mCasterOutline(casterOutline) {
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& /* deferInfo */,
const DeferredDisplayState& state) {
renderer.getCaches().tessellationCache.precacheShadows(&state.mMatrix,
renderer.getLocalClipBounds(), isCasterOpaque(), mCasterOutline,
&mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius());
}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
TessellationCache::vertexBuffer_pair_t buffers;
Matrix4 drawTransform(*(renderer.currentTransform()));
renderer.getCaches().tessellationCache.getShadowBuffers(&drawTransform,
@@ -1565,7 +1565,7 @@ public:
return renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOGS("DrawShadow");
}
@@ -1585,11 +1585,11 @@ public:
DrawLayerOp(Layer* layer, float x, float y)
: DrawOp(NULL), mLayer(layer), mX(x), mY(y) {}
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
return renderer.drawLayer(mLayer, mX, mY);
}
virtual void output(int level, uint32_t logFlags) const {
virtual void output(int level, uint32_t /* logFlags */) const {
OP_LOG("Draw Layer %p at %f %f", mLayer, mX, mY);
}

11
libs/hwui/DisplayListRenderer.cpp
View File

@@ -59,8 +59,8 @@ DisplayListData* DisplayListRenderer::finishRecording() {
return data;
}
status_t DisplayListRenderer::prepareDirty(float left, float top,
float right, float bottom, bool opaque) {
status_t DisplayListRenderer::prepareDirty(float /* left */, float /* top */,
float /* right */, float /* bottom */, bool opaque) {
LOG_ALWAYS_FATAL_IF(mDisplayListData,
"prepareDirty called a second time during a recording!");
@@ -86,7 +86,7 @@ void DisplayListRenderer::interrupt() {
void DisplayListRenderer::resume() {
}
status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) {
status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& /* dirty */) {
// Ignore dirty during recording, it matters only when we replay
addDrawOp(new (alloc()) DrawFunctorOp(functor));
mDisplayListData->functors.add(functor);
@@ -177,7 +177,8 @@ bool DisplayListRenderer::clipRegion(const SkRegion* region, SkRegion::Op op) {
return StatefulBaseRenderer::clipRegion(region, op);
}
status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& /* dirty */,
int32_t flags) {
LOG_ALWAYS_FATAL_IF(!renderNode, "missing rendernode");
// dirty is an out parameter and should not be recorded,
@@ -391,7 +392,7 @@ static void simplifyPaint(int color, SkPaint* paint) {
status_t DisplayListRenderer::drawText(const char* text, int bytesCount, int count,
float x, float y, const float* positions, const SkPaint* paint,
float totalAdvance, const Rect& bounds, DrawOpMode drawOpMode) {
float totalAdvance, const Rect& bounds, DrawOpMode /* drawOpMode */) {
if (!text || count <= 0 || paintWillNotDrawText(*paint)) return DrawGlInfo::kStatusDone;

2
libs/hwui/FontRenderer.cpp
View File

@@ -47,7 +47,7 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
// TextSetupFunctor
///////////////////////////////////////////////////////////////////////////////
status_t TextSetupFunctor::operator ()(int what, void* data) {
status_t TextSetupFunctor::operator ()(int /* what */, void* data) {
Data* typedData = reinterpret_cast<Data*>(data);
GLenum glyphFormat = typedData ? typedData->glyphFormat : GL_ALPHA;

16
libs/hwui/GammaFontRenderer.h
View File

@@ -70,7 +70,7 @@ public:
}
}
FontRenderer& getFontRenderer(const SkPaint* paint) {
FontRenderer& getFontRenderer(const SkPaint* /* paint */) {
if (!mRenderer) {
mRenderer = new FontRenderer;
}
@@ -81,7 +81,7 @@ public:
return 1;
}
uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const {
uint32_t getFontRendererSize(uint32_t /* fontRenderer */, GLenum format) const {
return mRenderer ? mRenderer->getCacheSize(format) : 0;
}
@@ -116,7 +116,7 @@ public:
}
}
FontRenderer& getFontRenderer(const SkPaint* paint) {
FontRenderer& getFontRenderer(const SkPaint* /* paint */) {
if (!mRenderer) {
mRenderer = new FontRenderer;
mRenderer->setGammaTable(&mGammaTable[0]);
@@ -128,14 +128,14 @@ public:
return 1;
}
uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const {
uint32_t getFontRendererSize(uint32_t /* fontRenderer */, GLenum format) const {
return mRenderer ? mRenderer->getCacheSize(format) : 0;
}
void describe(ProgramDescription& description, const SkPaint* paint) const {
void describe(ProgramDescription& /* description */, const SkPaint* /* paint */) const {
}
void setupProgram(ProgramDescription& description, Program* program) const {
void setupProgram(ProgramDescription& /* description */, Program* /* program */) const {
}
void endPrecaching();
@@ -171,10 +171,10 @@ public:
return renderer->getCacheSize(format);
}
void describe(ProgramDescription& description, const SkPaint* paint) const {
void describe(ProgramDescription& /* description */, const SkPaint* /* paint */) const {
}
void setupProgram(ProgramDescription& description, Program* program) const {
void setupProgram(ProgramDescription& /* description */, Program* /* program */) const {
}
void endPrecaching();

6
libs/hwui/OpenGLRenderer.cpp
View File

@@ -348,7 +348,7 @@ void OpenGLRenderer::resumeAfterLayer() {
dirtyClip();
}
status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& /* dirty */) {
if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
Rect clip(*currentClipRect());
@@ -401,6 +401,8 @@ void OpenGLRenderer::eventMarkDEBUG(const char* fmt, ...) const {
va_end(ap);
eventMark(buf);
#else
(void)fmt;
#endif
}
@@ -1087,7 +1089,7 @@ public:
}
protected:
virtual void shadeSpan(int x, int y, SkPMColor[], int count) {
virtual void shadeSpan(int /* x */, int /* y */, SkPMColor[], int /* count */) {
LOG_ALWAYS_FATAL("LayerShader should never be drawn with raster backend.");
}

2
libs/hwui/PathCache.cpp
View File

@@ -196,7 +196,7 @@ void PathCache::setMaxSize(uint32_t maxSize) {
// Callbacks
///////////////////////////////////////////////////////////////////////////////
void PathCache::operator()(PathDescription& entry, PathTexture*& texture) {
void PathCache::operator()(PathDescription& /* entry */, PathTexture*& texture) {
removeTexture(texture);
}

2
libs/hwui/Program.h
View File

@@ -285,6 +285,8 @@ struct ProgramDescription {
programid k = key();
PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32),
uint32_t(k & 0xffffffff));
#else
(void)message;
#endif
}

2
libs/hwui/ProgramCache.cpp
View File

@@ -455,7 +455,7 @@ Program* ProgramCache::get(const ProgramDescription& description) {
// Program generation
///////////////////////////////////////////////////////////////////////////////
Program* ProgramCache::generateProgram(const ProgramDescription& description, programid key) {
Program* ProgramCache::generateProgram(const ProgramDescription& description, programid /* key */) {
String8 vertexShader = generateVertexShader(description);
String8 fragmentShader = generateFragmentShader(description);

4
libs/hwui/RenderNode.cpp
View File

@@ -274,7 +274,7 @@ void RenderNode::pushStagingPropertiesChanges(TreeInfo& info) {
}
}
void RenderNode::applyLayerPropertiesToLayer(TreeInfo& info) {
void RenderNode::applyLayerPropertiesToLayer(TreeInfo& /* info */) {
if (CC_LIKELY(!mLayer)) return;
const LayerProperties& props = properties().layerProperties();
@@ -567,7 +567,7 @@ public:
operation->defer(mDeferStruct, saveCount, mLevel, clipToBounds);
}
inline LinearAllocator& allocator() { return *(mDeferStruct.mAllocator); }
inline void startMark(const char* name) {} // do nothing
inline void startMark(const char* /* name */) {} // do nothing
inline void endMark() {}
inline int level() { return mLevel; }
inline int replayFlags() { return mDeferStruct.mReplayFlags; }

4
libs/hwui/RenderState.h
View File

@@ -52,13 +52,13 @@ public:
void debugOverdraw(bool enable, bool clear);
void registerLayer(const Layer* layer) {
void registerLayer(const Layer* /* layer */) {
/*
AutoMutex _lock(mLayerLock);
mActiveLayers.insert(layer);
*/
}
void unregisterLayer(const Layer* layer) {
void unregisterLayer(const Layer* /* layer */) {
/*
AutoMutex _lock(mLayerLock);
mActiveLayers.erase(layer);

4
libs/hwui/SkiaShader.cpp
View File

@@ -163,7 +163,7 @@ void SkiaShader::setupProgram(Caches* caches, const mat4& modelViewMatrix,
///////////////////////////////////////////////////////////////////////////////
void SkiaLayerShader::describe(Caches*, ProgramDescription& description,
const Extensions&, const SkShader& shader) {
const Extensions&, const SkShader& /* shader */) {
description.hasBitmap = true;
}
@@ -339,7 +339,7 @@ static bool isSimpleGradient(const SkShader::GradientInfo& gradInfo) {
}
void SkiaGradientShader::describe(Caches*, ProgramDescription& description,
const Extensions& extensions, const SkShader& shader) {
const Extensions& /* extensions */, const SkShader& shader) {
SkShader::GradientInfo gradInfo;
gradInfo.fColorCount = 0;
gradInfo.fColors = NULL;

9
libs/hwui/SkiaShader.h
View File

@@ -57,12 +57,13 @@ public:
class InvalidSkiaShader {
public:
static void describe(Caches* caches, ProgramDescription& description,
const Extensions& extensions, const SkShader& shader) {
static void describe(Caches* /* caches */, ProgramDescription& /* description */,
const Extensions& /* extensions */, const SkShader& /* shader */) {
// This shader is unsupported. Skip it.
}
static void setupProgram(Caches* caches, const mat4& modelViewMatrix,
GLuint* textureUnit, const Extensions& extensions, const SkShader& shader) {
static void setupProgram(Caches* /* caches */, const mat4& /* modelViewMatrix */,
GLuint* /* textureUnit */, const Extensions& /* extensions */,
const SkShader& /* shader */) {
// This shader is unsupported. Skip it.
}

6
libs/hwui/SpotShadow.cpp
View File

@@ -912,6 +912,8 @@ int SpotShadow::setupAngleList(VertexAngleData* angleDataList,
angleDataList[i].set(currentAngle, isPenumbra, i);
#if DEBUG_SHADOW
ALOGD("%s AngleList i %d %f", name, i, currentAngle);
#else
(void)name;
#endif
}
return maxAngleIndex;
@@ -941,6 +943,8 @@ bool SpotShadow::checkClockwise(int indexOfMaxAngle, int listLength, VertexAngle
if (currentAngle < nextAngle) {
#if DEBUG_SHADOW
ALOGE("%s, is not CW, at index %d", name, currentIndex);
#else
(void)name;
#endif
return false;
}
@@ -1378,7 +1382,7 @@ int SpotShadow::convertPolysToVerticesPerRay(
/**
* Generate a triangle strip given two convex polygon
**/
void SpotShadow::generateTriangleStrip(bool isCasterOpaque, float shadowStrengthScale,
void SpotShadow::generateTriangleStrip(bool isCasterOpaque, float /* shadowStrengthScale */,
Vector2* penumbra, int penumbraLength, Vector2* umbra, int umbraLength,
const Vector3* poly, int polyLength, VertexBuffer& shadowTriangleStrip,
const Vector2& centroid) {

3
libs/hwui/StatefulBaseRenderer.h
View File

@@ -129,7 +129,8 @@ protected:
*
* Subclasses can override this method to handle layer restoration
*/
virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {};
virtual void onSnapshotRestored(const Snapshot& /* removed */,
const Snapshot& /* restored */) {};
virtual void onViewportInitialized() {};

2
libs/hwui/TessellationCache.cpp
View File

@@ -365,7 +365,7 @@ void TessellationCache::clear() {
// Callbacks
///////////////////////////////////////////////////////////////////////////////
void TessellationCache::BufferRemovedListener::operator()(Description& description,
void TessellationCache::BufferRemovedListener::operator()(Description& /* description */,
Buffer*& buffer) {
delete buffer;
}

3
libs/hwui/TessellationCache.h
View File

@@ -178,7 +178,8 @@ private:
// holds a pointer, and implicit strong ref to each shadow task of the frame
LruCache<ShadowDescription, Task<vertexBuffer_pair_t*>*> mShadowCache;
class BufferPairRemovedListener : public OnEntryRemoved<ShadowDescription, Task<vertexBuffer_pair_t*>*> {
void operator()(ShadowDescription& description, Task<vertexBuffer_pair_t*>*& bufferPairTask) {
void operator()(ShadowDescription& /* description */,
Task<vertexBuffer_pair_t*>*& bufferPairTask) {
bufferPairTask->decStrong(NULL);
}
};

14
libs/hwui/font/Font.cpp
View File

@@ -139,7 +139,8 @@ void Font::invalidateTextureCache(CacheTexture* cacheTexture) {
}
void Font::measureCachedGlyph(CachedGlyphInfo *glyph, int x, int y,
uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* bounds,
const float* /* pos */) {
int width = (int) glyph->mBitmapWidth;
int height = (int) glyph->mBitmapHeight;
@@ -161,7 +162,8 @@ void Font::measureCachedGlyph(CachedGlyphInfo *glyph, int x, int y,
}
void Font::drawCachedGlyph(CachedGlyphInfo* glyph, int x, int y,
uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* /* bounds */,
const float* /* pos */) {
float width = (float) glyph->mBitmapWidth;
float height = (float) glyph->mBitmapHeight;
@@ -180,7 +182,8 @@ void Font::drawCachedGlyph(CachedGlyphInfo* glyph, int x, int y,
}
void Font::drawCachedGlyphTransformed(CachedGlyphInfo* glyph, int x, int y,
uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) {
uint8_t* /* bitmap */, uint32_t /* bitmapW */, uint32_t /* bitmapH */, Rect* /* bounds */,
const float* /* pos */) {
float width = (float) glyph->mBitmapWidth;
float height = (float) glyph->mBitmapHeight;
@@ -210,7 +213,8 @@ void Font::drawCachedGlyphTransformed(CachedGlyphInfo* glyph, int x, int y,
}
void Font::drawCachedGlyphBitmap(CachedGlyphInfo* glyph, int x, int y, uint8_t* bitmap,
uint32_t bitmapWidth, uint32_t bitmapHeight, Rect* bounds, const float* pos) {
uint32_t bitmapWidth, uint32_t /* bitmapHeight */, Rect* /* bounds */,
const float* /* pos */) {
int dstX = x + glyph->mBitmapLeft;
int dstY = y + glyph->mBitmapTop;
@@ -427,7 +431,7 @@ void Font::render(const SkPaint* paint, const char* text, uint32_t start, uint32
}
}
void Font::updateGlyphCache(const SkPaint* paint, const SkGlyph& skiaGlyph,
void Font::updateGlyphCache(const SkPaint* /* paint */, const SkGlyph& skiaGlyph,
SkGlyphCache* skiaGlyphCache, CachedGlyphInfo* glyph, bool precaching) {
glyph->mAdvanceX = skiaGlyph.fAdvanceX;
glyph->mAdvanceY = skiaGlyph.fAdvanceY;

6
libs/hwui/renderthread/CanvasContext.cpp
View File

@@ -115,13 +115,13 @@ void CanvasContext::updateSurface(ANativeWindow* window) {
setSurface(window);
}
void CanvasContext::pauseSurface(ANativeWindow* window) {
void CanvasContext::pauseSurface(ANativeWindow* /* window */) {
stopDrawing();
}
// TODO: don't pass viewport size, it's automatic via EGL
void CanvasContext::setup(int width, int height, const Vector3& lightCenter, float lightRadius,
uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
void CanvasContext::setup(int /* width */, int /* height */, const Vector3& lightCenter,
float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
if (!mCanvas) return;
mCanvas->initLight(lightCenter, lightRadius, ambientShadowAlpha, spotShadowAlpha);
}

8
libs/hwui/renderthread/RenderProxy.cpp
View File

@@ -344,14 +344,16 @@ void RenderProxy::trimMemory(int level) {
}
}
template <typename T>
void UNUSED(T) {}
CREATE_BRIDGE0(fence) {
// Intentionally empty
UNUSED(args);
return NULL;
}
template <typename T>
void UNUSED(T t) {}
void RenderProxy::fence() {
SETUP_TASK(fence);
UNUSED(args);

2
libs/hwui/renderthread/RenderThread.cpp
View File

@@ -171,7 +171,7 @@ void RenderThread::initThreadLocals() {
mRenderState = new RenderState();
}
int RenderThread::displayEventReceiverCallback(int fd, int events, void* data) {
int RenderThread::displayEventReceiverCallback(int /* fd */, int events, void* data) {
if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
ALOGE("Display event receiver pipe was closed or an error occurred. "
"events=0x%x", events);