Fix the noisiest variable shadowing warnings in pdfium.

core/include/fxcrt/fx_coordinates.h

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #ifndef _FXCRT_COORDINATES_
 #define _FXCRT_COORDINATES_
 
 #include "fx_basic.h"
 
 template<class baseType> class CFX_PSVTemplate;

[Tom Sepez, 2015/04/10 21:33:04]

I don't think there's a need to forward declare any of these.

 template<class baseType> class CFX_VTemplate;
 template<class baseType> class CFX_PRLTemplate;

[Tom Sepez, 2015/04/10 21:33:05]

I didn't see an implementation of CFX_PRLTemplate anywhere.

 template<class baseType> class CFX_RTemplate;
 template<class baseType> class CFX_ETemplate;

[Tom Sepez, 2015/04/10 21:33:04]

CFX_ETemplate appears unused.

 template<class baseType> class CFX_ATemplate;

[Tom Sepez, 2015/04/10 21:33:05]

CFX_ATemplate appears unused.

 template<class baseType> class CFX_RRTemplate;

[Tom Sepez, 2015/04/10 21:33:04]

CFX_RRTemplate appears unused.

 class CFX_Matrix;
 template<class baseType>
 class CFX_PSVTemplate : public CFX_Object
 {
 public:
     typedef CFX_PSVTemplate<baseType>   FXT_PSV;
     typedef CFX_PSVTemplate<baseType>   FXT_POINT;

[Tom Sepez, 2015/04/10 21:33:04]

FXT_POINT appears unused, shadowed in subclass. maybe used once subclass loses
it def'n/

     typedef CFX_PSVTemplate<baseType>   FXT_SIZE;

[Tom Sepez, 2015/04/10 21:33:05]

FXT_SIZE ditto

     void                Set(baseType x, baseType y)

[Tom Sepez, 2015/04/10 21:33:05]

Same issue with shadowing parameters. Then we can lose the PSV::

     {
         FXT_PSV::x = x, FXT_PSV::y = y;
     }
     void                Set(const FXT_PSV &psv)
     {
         FXT_PSV::x = psv.x, FXT_PSV::y = psv.y;
     }
     void                Add(baseType x, baseType y)
     {
         FXT_PSV::x += x, FXT_PSV::y += y;
@@ skipping 23 matching lines @@
         x *= lamda;
         y *= lamda;
         return *this;
     }
     FXT_PSV&    operator /= (baseType lamda)
     {
         x /= lamda;
         y /= lamda;
         return *this;
     }
     friend      FX_BOOL         operator == (const FXT_PSV &obj1, const FXT_PSV &obj2)

[Tom Sepez, 2015/04/10 21:33:05]

why "friend"? x, y are public.
I think they wanted this to be a function, not a class method, since it is the
two-arg form? I'm confused.

     {
         return obj1.x == obj2.x && obj1.y == obj2.y;
     }
     friend      FX_BOOL         operator != (const FXT_PSV &obj1, const FXT_PSV &obj2)
     {
         return obj1.x != obj2.x || obj1.y != obj2.y;
     }
     friend      FXT_PSV         operator + (const FXT_PSV &obj1, const FXT_PSV &obj2)
     {
         CFX_PSVTemplate obj;
@@ skipping 26 matching lines @@
     {
         CFX_PSVTemplate t;
         t.x = obj.x / lamda;
         t.y = obj.y / lamda;
         return t;
     }
     baseType x, y;
 };
 typedef CFX_PSVTemplate<FX_INT32>                       CFX_Point;
 typedef CFX_PSVTemplate<FX_FLOAT>                       CFX_PointF;
 typedef CFX_PSVTemplate<FX_INT32>                       CFX_Size;

[Tom Sepez, 2015/04/10 21:33:05]

I'm deeply offended by anyone who thinks a size contains x,y instead of w,h.

 typedef CFX_PSVTemplate<FX_FLOAT>                       CFX_SizeF;
 typedef CFX_ArrayTemplate<CFX_Point>            CFX_Points;
 typedef CFX_ArrayTemplate<CFX_PointF>           CFX_PointsF;
 typedef CFX_PSVTemplate<FX_INT32> *                     FX_LPPOINT;

[Tom Sepez, 2015/04/10 21:33:05]

can we use the typdef's above here to save some typing and ensure consistency.

 typedef CFX_PSVTemplate<FX_FLOAT> *                     FX_LPPOINTF;
 typedef CFX_PSVTemplate<FX_INT32> const *       FX_LPCPOINT;
 typedef CFX_PSVTemplate<FX_FLOAT> const *       FX_LPCPOINTF;
 #define CFX_FloatPoint  CFX_PointF

[Tom Sepez, 2015/04/10 21:33:05]

should be typedef.

 template<class baseType>

[Tom Sepez, 2015/04/10 21:33:04]

probably should be typename baseType, since we instantiate it only with things
that are intrinsically promotable to float (below).

 class CFX_VTemplate: public CFX_PSVTemplate<baseType>
 {
 public:
     typedef CFX_PSVTemplate<baseType>   FXT_PSV;
     typedef CFX_PSVTemplate<baseType>   FXT_POINT;

[Tom Sepez, 2015/04/10 21:33:05]

nit: this types are shadows?

     typedef CFX_PSVTemplate<baseType>   FXT_SIZE;
     typedef CFX_VTemplate<baseType>             FXT_VECTOR;
-    void                Set(baseType x, baseType y)
+    void                Set(baseType newx, baseType newy)

[Tom Sepez, 2015/04/10 21:00:04]

why do we even need this method?  Isn't there one in the base class that does
the same thing?

[brucedawson, 2015/04/10 21:29:50]

A quick check shows that it is needed. fpdf_text_int.cpp(1925) (and possibly
other locations) fails to compile if it is commented out.

     {
-        FXT_PSV::x = x, FXT_PSV::y = y;
+        FXT_PSV::x = newx, FXT_PSV::y = newy;

[Tom Sepez, 2015/04/10 20:36:53]

Can we get rid of the FXT_PSV:: qualifiers throughout here now that the
shadowing is gone?
nit: one statement per line, lose the comma.

[brucedawson, 2015/04/10 21:29:50]

I started doing that initially, and I'd be happy to do it. I only stopped
because the other methods use FXT_PSV:: as well, so changing it would be
inconsistent, and changing it throughout the class seemed like excessive churn.

Thoughts?

     }
     void                Set(const FXT_PSV &psv)
     {
         FXT_PSV::x = psv.x, FXT_PSV::y = psv.y;
     }
     void                Set(const FXT_POINT &p1, const FXT_POINT &p2)
     {
         FXT_PSV::x = p2.x - p1.x, FXT_PSV::y = p2.y - p1.y;
     }
     void                Reset()
@@ skipping 10 matching lines @@
     }
     void                Normalize()
     {
         FX_FLOAT fLen = FXSYS_sqrt(FXT_PSV::x * FXT_PSV::x + FXT_PSV::y * FXT_PSV::y);
         if (fLen < 0.0001f) {
             return;
         }
         FXT_PSV::x = ((baseType)FXT_PSV::x) / fLen;
         FXT_PSV::y = ((baseType)FXT_PSV::y) / fLen;
     }
-    baseType    DotProduct(baseType x, baseType y) const
+    baseType    DotProduct(baseType otherx, baseType othery) const
     {
-        return FXT_PSV::x * x + FXT_PSV::y * y;
+        return FXT_PSV::x * otherx + FXT_PSV::y * othery;
     }
     baseType    DotProduct(const FXT_VECTOR &v) const
     {
         return FXT_PSV::x * v.x + FXT_PSV::y * v.y;
     }
-    FX_BOOL             IsParallel(baseType x, baseType y) const
+    FX_BOOL             IsParallel(baseType otherx, baseType othery) const
     {
-        baseType t = FXT_PSV::x * y - FXT_PSV::y * x;
+        baseType t = FXT_PSV::x * othery - FXT_PSV::y * otherx;
         return FXSYS_fabs(t) < 0x0001f;
     }
     FX_BOOL             IsParallel(const FXT_VECTOR &v) const
     {
         return IsParallel(v.x, v.y);
     }
-    FX_BOOL             IsPerpendicular(baseType x, baseType y) const
+    FX_BOOL             IsPerpendicular(baseType otherx, baseType othery) const
     {
-        baseType t = DotProduct(x, y);
+        baseType t = DotProduct(otherx, othery);
         return FXSYS_fabs(t) < 0x0001f;
     }
     FX_BOOL             IsPerpendicular(const FXT_VECTOR &v) const
     {
         return IsPerpendicular(v.x, v.y);
     }
     void                Translate(baseType dx, baseType dy)
     {
         FXT_PSV::x += dx, FXT_PSV::y += dy;
     }
@@ skipping 307 matching lines @@
         FXT_RECT rect = rt;
         rect.Intersect(*this);
         return !rect.IsEmpty();
     }
     FX_BOOL             IntersectWith(const FXT_RECT &rt, FX_FLOAT fEpsilon) const
     {
         FXT_RECT rect = rt;
         rect.Intersect(*this);
         return !rect.IsEmpty(fEpsilon);
     }
     friend      FX_BOOL operator == (const FXT_RECT &rc1, const FXT_RECT &rc2)

[Tom Sepez, 2015/04/10 21:33:05]

ditto on friend.

     {
         return rc1.left == rc2.left && rc1.top == rc2.top && rc1.width == rc2.width && rc1.height == rc2.height;
     }
     friend      FX_BOOL operator != (const FXT_RECT &rc1, const FXT_RECT &rc2)
     {
         return rc1.left != rc2.left || rc1.top != rc2.top || rc1.width != rc2.width || rc1.height != rc2.height;
     }
     baseType left, top;
     baseType width, height;
 };
@@ skipping 76 matching lines @@
 struct FX_SMALL_RECT {
 
     FX_SHORT    Left;
 
     FX_SHORT    Top;
 
     FX_SHORT    Right;
 
     FX_SHORT    Bottom;
 };
 class CFX_FloatRect : public CFX_Object

[Tom Sepez, 2015/04/10 21:33:05]

And yet this isn't a template.

 {
 public:
 
     CFX_FloatRect()
     {
         left = right = bottom = top = 0;
     }
 
     CFX_FloatRect(FX_FLOAT left1, FX_FLOAT bottom1, FX_FLOAT right1, FX_FLOAT top1)
     {
@@ skipping 234 matching lines @@
     void                        TransformRect(CFX_RectF &rect) const;
     void                        TransformRect(CFX_Rect &rect) const;
 
     void                        TransformRect(FX_FLOAT& left, FX_FLOAT& right, FX_FLOAT& top, FX_FLOAT& bottom) const;
 
     void                        TransformRect(CFX_FloatRect& rect) const
     {
         TransformRect(rect.left, rect.right, rect.top, rect.bottom);
     }
 
     FX_FLOAT            GetA() const

[Tom Sepez, 2015/04/10 21:33:05]

|a| is public and we don't need this, or make |a| protected below.

     {
         return a;
     }
 
     FX_FLOAT            GetB() const
     {
         return b;
     }
 
     FX_FLOAT            GetC() const
@@ skipping 16 matching lines @@
         return f;
     }
 public:
     FX_FLOAT a;
     FX_FLOAT b;
     FX_FLOAT c;
     FX_FLOAT d;
     FX_FLOAT e;
     FX_FLOAT f;
 };
 #define CFX_AffineMatrix        CFX_Matrix

[Tom Sepez, 2015/04/10 21:33:05]

typedef.

 #endif