Remove some casts to same type in cfx_graphics.cpp

xfa/fxgraphics/cfx_graphics.cpp

 // 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
 
 #include "xfa/fxgraphics/include/cfx_graphics.h"
 
 #include <memory>
 
@@ skipping 813 matching lines @@
     return RenderDeviceFillPath(path, fillMode, matrix);
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::ClipPath(CFX_Path* path,
                                  FX_FillMode fillMode,
                                  CFX_Matrix* matrix) {
   if (!path)
     return FWL_Error::ParameterInvalid;
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
-    FX_BOOL result = m_renderDevice->SetClip_PathFill(
-        path->GetPathData(), (CFX_Matrix*)matrix, fillMode);
+    FX_BOOL result =
+        m_renderDevice->SetClip_PathFill(path->GetPathData(), matrix, fillMode);
     if (!result)
       return FWL_Error::Indefinite;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::DrawImage(CFX_DIBSource* source,
                                   const CFX_PointF& point,
                                   CFX_Matrix* matrix) {
@@ skipping 318 matching lines @@
   if (!m_info.strokeColor)
     return FWL_Error::PropertyInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   switch (m_info.strokeColor->m_type) {
     case FX_COLOR_Solid: {
-      FX_BOOL result = m_renderDevice->DrawPath(
-          path->GetPathData(), (CFX_Matrix*)&m, &m_info.graphState, 0x0,
-          m_info.strokeColor->m_info.argb, 0);
+      FX_BOOL result =
+          m_renderDevice->DrawPath(path->GetPathData(), &m, &m_info.graphState,
+                                   0x0, m_info.strokeColor->m_info.argb, 0);
       if (!result)
         return FWL_Error::Indefinite;
       return FWL_Error::Succeeded;
     }
     case FX_COLOR_Pattern:
       return StrokePathWithPattern(path, &m);
     case FX_COLOR_Shading:
       return StrokePathWithShading(path, &m);
     default:
       return FWL_Error::PropertyInvalid;
   }
 }
 
 FWL_Error CFX_Graphics::RenderDeviceFillPath(CFX_Path* path,
                                              FX_FillMode fillMode,
                                              CFX_Matrix* matrix) {
   if (!m_info.fillColor)
     return FWL_Error::PropertyInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   switch (m_info.fillColor->m_type) {
     case FX_COLOR_Solid: {
       FX_BOOL result = m_renderDevice->DrawPath(
-          path->GetPathData(), (CFX_Matrix*)&m, &m_info.graphState,
+          path->GetPathData(), &m, &m_info.graphState,
           m_info.fillColor->m_info.argb, 0x0, fillMode);
       if (!result)
         return FWL_Error::Indefinite;
       return FWL_Error::Succeeded;
     }
     case FX_COLOR_Pattern:
       return FillPathWithPattern(path, fillMode, &m);
     case FX_COLOR_Shading:
       return FillPathWithShading(path, fillMode, &m);
     default:
       return FWL_Error::PropertyInvalid;
   }
 }
 
 FWL_Error CFX_Graphics::RenderDeviceDrawImage(CFX_DIBSource* source,
                                               const CFX_PointF& point,
                                               CFX_Matrix* matrix) {
   CFX_Matrix m1;
   m1.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
          m_info.CTM.f);
   if (matrix) {
     m1.Concat(*matrix);
   }
   CFX_Matrix m2;
   m2.Set((FX_FLOAT)source->GetWidth(), 0.0, 0.0, (FX_FLOAT)source->GetHeight(),
          point.x, point.y);
   m2.Concat(m1);
   int32_t left, top;
   std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(FALSE, TRUE));
-  std::unique_ptr<CFX_DIBitmap> bmp2(
-      bmp1->TransformTo((CFX_Matrix*)&m2, left, top));
+  std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->TransformTo(&m2, left, top));
   CFX_RectF r;
   GetClipRect(r);
   CFX_DIBitmap* bitmap = m_renderDevice->GetBitmap();
   CFX_DIBitmap bmp;
   if (bmp.Create(bitmap->GetWidth(), bitmap->GetHeight(), FXDIB_Argb) &&
       m_renderDevice->GetDIBits(&bmp, 0, 0) &&
       bmp.TransferBitmap(FXSYS_round(r.left), FXSYS_round(r.top),
                          FXSYS_round(r.Width()), FXSYS_round(r.Height()),
                          bmp2.get(), FXSYS_round(r.left - left),
                          FXSYS_round(r.top - top)) &&
@@ skipping 12 matching lines @@
   if (matrix) {
     m1.Concat(*matrix);
   }
   std::unique_ptr<CFX_DIBitmap> bmp1(
       source->StretchTo((int32_t)rect.Width(), (int32_t)rect.Height()));
   CFX_Matrix m2;
   m2.Set(rect.Width(), 0.0, 0.0, rect.Height(), rect.left, rect.top);
   m2.Concat(m1);
   int32_t left, top;
   std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->FlipImage(FALSE, TRUE));
-  std::unique_ptr<CFX_DIBitmap> bmp3(
-      bmp2->TransformTo((CFX_Matrix*)&m2, left, top));
+  std::unique_ptr<CFX_DIBitmap> bmp3(bmp2->TransformTo(&m2, left, top));
   CFX_RectF r;
   GetClipRect(r);
   CFX_DIBitmap* bitmap = m_renderDevice->GetBitmap();
   if (bitmap->CompositeBitmap(FXSYS_round(r.left), FXSYS_round(r.top),
                               FXSYS_round(r.Width()), FXSYS_round(r.Height()),
                               bmp3.get(), FXSYS_round(r.left - left),
                               FXSYS_round(r.top - top))) {
     return FWL_Error::Succeeded;
   }
   return FWL_Error::Indefinite;
@@ skipping 10 matching lines @@
   CalcTextInfo(text, charCodes, charPos, rect);
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   m.Translate(0, m_info.fontSize * m_info.fontHScale);
   if (matrix) {
     m.Concat(*matrix);
   }
   FX_BOOL result = m_renderDevice->DrawNormalText(
       length, charPos, m_info.font, CFX_GEModule::Get()->GetFontCache(),
-      -m_info.fontSize * m_info.fontHScale, (CFX_Matrix*)&m,
-      m_info.fillColor->m_info.argb, FXTEXT_CLEARTYPE);
+      -m_info.fontSize * m_info.fontHScale, &m, m_info.fillColor->m_info.argb,
+      FXTEXT_CLEARTYPE);
   if (!result)
     return FWL_Error::Indefinite;
   FX_Free(charPos);
   FX_Free(charCodes);
   return FWL_Error::Succeeded;
 }
 
 FWL_Error CFX_Graphics::StrokePathWithPattern(CFX_Path* path,
                                               CFX_Matrix* matrix) {
   return FWL_Error::MethodNotSupported;
@@ skipping 19 matching lines @@
   if (hatchStyle < FX_HATCHSTYLE_Horizontal ||
       hatchStyle > FX_HATCHSTYLE_SolidDiamond) {
     return FWL_Error::IntermediateValueInvalid;
   }
   const FX_HATCHDATA& data = hatchBitmapData[hatchStyle];
   CFX_DIBitmap mask;
   mask.Create(data.width, data.height, FXDIB_1bppMask);
   FXSYS_memcpy(mask.GetBuffer(), data.maskBits, mask.GetPitch() * data.height);
   CFX_FloatRect rectf = path->GetPathData()->GetBoundingBox();
   if (matrix) {
-    rectf.Transform((const CFX_Matrix*)matrix);
+    rectf.Transform(matrix);
   }
   FX_RECT rect(FXSYS_round(rectf.left), FXSYS_round(rectf.top),
                FXSYS_round(rectf.right), FXSYS_round(rectf.bottom));
   CFX_FxgeDevice device;
   device.Attach(&bmp, false, nullptr, false);
   device.FillRect(&rect, m_info.fillColor->m_info.pattern->m_backArgb);
   for (int32_t j = rect.bottom; j < rect.top; j += mask.GetHeight()) {
     for (int32_t i = rect.left; i < rect.right; i += mask.GetWidth()) {
       device.SetBitMask(&mask, i, j,
                         m_info.fillColor->m_info.pattern->m_foreArgb);
     }
   }
 
   m_renderDevice->SaveState();
-  m_renderDevice->SetClip_PathFill(path->GetPathData(), (CFX_Matrix*)matrix,
-                                   fillMode);
+  m_renderDevice->SetClip_PathFill(path->GetPathData(), matrix, fillMode);
   SetDIBitsWithMatrix(&bmp, &pattern->m_matrix);
   m_renderDevice->RestoreState(false);
   return FWL_Error::Succeeded;
 }
 
 FWL_Error CFX_Graphics::FillPathWithShading(CFX_Path* path,
                                             FX_FillMode fillMode,
                                             CFX_Matrix* matrix) {
   CFX_DIBitmap* bitmap = m_renderDevice->GetBitmap();
   int32_t width = bitmap->GetWidth();
@@ skipping 99 matching lines @@
       result = true;
       break;
     }
     default: {
       result = false;
       break;
     }
   }
   if (result) {
     m_renderDevice->SaveState();
-    m_renderDevice->SetClip_PathFill(path->GetPathData(), (CFX_Matrix*)matrix,
-                                     fillMode);
+    m_renderDevice->SetClip_PathFill(path->GetPathData(), matrix, fillMode);
     SetDIBitsWithMatrix(&bmp, matrix);
     m_renderDevice->RestoreState(false);
   }
   return result ? FWL_Error::Succeeded : FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::SetDIBitsWithMatrix(CFX_DIBSource* source,
                                             CFX_Matrix* matrix) {
   if (matrix->IsIdentity()) {
     m_renderDevice->SetDIBits(source, 0, 0);
   } else {
     CFX_Matrix m;
     m.Set((FX_FLOAT)source->GetWidth(), 0, 0, (FX_FLOAT)source->GetHeight(), 0,
           0);
     m.Concat(*matrix);
     int32_t left, top;
     std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(FALSE, TRUE));
-    std::unique_ptr<CFX_DIBitmap> bmp2(
-        bmp1->TransformTo((CFX_Matrix*)&m, left, top));
+    std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->TransformTo(&m, left, top));
     m_renderDevice->SetDIBits(bmp2.get(), left, top);
   }
   return FWL_Error::Succeeded;
 }
 
 FWL_Error CFX_Graphics::CalcTextInfo(const CFX_WideString& text,
                                      uint32_t* charCodes,
                                      FXTEXT_CHARPOS* charPos,
                                      CFX_RectF& rect) {
   std::unique_ptr<CFX_UnicodeEncoding> encoding(
@@ skipping 57 matching lines @@
   CTM = other.CTM;
   isActOnDash = other.isActOnDash;
   strokeColor = other.strokeColor;
   fillColor = other.fillColor;
   font = other.font;
   fontSize = other.fontSize;
   fontHScale = other.fontHScale;
   fontSpacing = other.fontSpacing;
   return *this;
 }