Remove default arguments from IFX_RenderDeviceDriver.

core/fxge/apple/fx_quartz_device.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 "core/fxcrt/include/fx_ext.h"
 
 #ifndef _SKIA_SUPPORT_
 #include "core/fxge/agg/fx_agg_driver.h"
@@ skipping 322 matching lines @@
       break;
     case FXDIB_BLEND_LUMINOSITY:
       mode = kCGBlendModeLuminosity;
       break;
     default:
       mode = kCGBlendModeNormal;
       break;
   }
   return mode;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData* pathData,
                                          const CFX_Matrix* matrix,
                                          const CFX_GraphStateData* graphState,
                                          uint32_t fillArgb,
                                          uint32_t strokeArgb,
                                          int fillMode,
-                                         int alpha_flag,
-                                         void* pIccTransform,
                                          int blend_type) {
   SaveState();
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGAffineTransform m = CGAffineTransformIdentity;
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
@@ skipping 26 matching lines @@
   } else if (pathMode == 2) {
     CGContextEOFillPath(m_context);
   } else if (pathMode == 5) {
     CGContextDrawPath(m_context, kCGPathFillStroke);
   } else if (pathMode == 6) {
     CGContextDrawPath(m_context, kCGPathEOFillStroke);
   }
   RestoreState(false);
   return TRUE;
 }
-FX_BOOL CFX_QuartzDeviceDriver::FillRect(const FX_RECT* rect,
-                                         FX_ARGB fillArgb,
-                                         int alphaFlag,
-                                         void* iccTransform,
-                                         int blend_type) {
+
+FX_BOOL CFX_QuartzDeviceDriver::FillRectWithBlend(const FX_RECT* rect,
+                                                  FX_ARGB fillArgb,
+                                                  int blend_type) {
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGRect rect_fx =
       CGRectMake(rect->left, rect->top, rect->Width(), rect->Height());
   CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, m_foxitDevice2User);
   int32_t a, r, g, b;
   ArgbDecode(fillArgb, a, r, g, b);
   CGContextSetRGBFillColor(m_context, r / 255.f, g / 255.f, b / 255.f,
                            a / 255.f);
   CGContextFillRect(m_context, rect_usr);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, kCGBlendModeNormal);
   }
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
                                                  FX_FLOAT y1,
                                                  FX_FLOAT x2,
                                                  FX_FLOAT y2,
                                                  uint32_t argb,
-                                                 int alphaFlag,
-                                                 void* iccTransform,
                                                  int blend_type) {
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGPoint pt =
       CGPointApplyAffineTransform(CGPointMake(x1, y1), m_foxitDevice2User);
   x1 = pt.x;
   y1 = pt.y;
   pt = CGPointApplyAffineTransform(CGPointMake(x2, y2), m_foxitDevice2User);
   x2 = pt.x;
   y2 = pt.y;
   int32_t a, r, g, b;
   ArgbDecode(argb, a, r, g, b);
   CGContextSetRGBStrokeColor(m_context, r / 255.f, g / 255.f, b / 255.f,
                              a / 255.f);
   CGContextMoveToPoint(m_context, x1, y1);
   CGContextAddLineToPoint(m_context, x2, y2);
   CGContextStrokePath(m_context);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, kCGBlendModeNormal);
   }
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect) {
   CGRect r = CGContextGetClipBoundingBox(m_context);
   r = CGRectApplyAffineTransform(r, m_user2FoxitDevice);
   rect->left = FXSYS_floor(r.origin.x);
   rect->top = FXSYS_floor(r.origin.y);
   rect->right = FXSYS_ceil(r.origin.x + r.size.width);
   rect->bottom = FXSYS_ceil(r.origin.y + r.size.height);
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap* bitmap,
                                           int32_t left,
-                                          int32_t top,
-                                          void* pIccTransform,
-                                          FX_BOOL bDEdge) {
-  if (FXDC_PRINTER == m_deviceClass) {
+                                          int32_t top) {
+  if (FXDC_PRINTER == m_deviceClass || bitmap->GetBPP() < 32 ||
+      !(m_renderCaps | FXRC_GET_BITS)) {
     return FALSE;
   }
-  if (bitmap->GetBPP() < 32) {
-    return FALSE;
-  }
-  if (!(m_renderCaps | FXRC_GET_BITS)) {
-    return FALSE;
-  }
+
   CGPoint pt = CGPointMake(left, top);
   pt = CGPointApplyAffineTransform(pt, m_foxitDevice2User);
   CGAffineTransform ctm = CGContextGetCTM(m_context);
   pt.x *= FXSYS_fabs(ctm.a);
   pt.y *= FXSYS_fabs(ctm.d);
   CGImageRef image = CGBitmapContextCreateImage(m_context);
   if (!image)
     return FALSE;
 
   CGFloat width = (CGFloat)bitmap->GetWidth();
   CGFloat height = (CGFloat)bitmap->GetHeight();
-  if (width + pt.x > m_width) {
+  if (width + pt.x > m_width)
     width -= (width + pt.x - m_width);
-  }
-  if (height + pt.y > m_height) {
+  if (height + pt.y > m_height)
     height -= (height + pt.y - m_height);
-  }
+
   CGImageRef subImage = CGImageCreateWithImageInRect(
       image, CGRectMake(pt.x, pt.y, width, height));
   CGContextRef context = createContextWithBitmap(bitmap);
   CGRect rect = CGContextGetClipBoundingBox(context);
   CGContextClearRect(context, rect);
   CGContextDrawImage(context, rect, subImage);
   CGContextRelease(context);
   CGImageRelease(subImage);
   CGImageRelease(image);
-  if (bitmap->HasAlpha()) {
-    for (int row = 0; row < bitmap->GetHeight(); row++) {
-      uint8_t* pScanline = (uint8_t*)bitmap->GetScanline(row);
-      for (int col = 0; col < bitmap->GetWidth(); col++) {
-        if (pScanline[3] > 0) {
-          pScanline[0] = (pScanline[0] * 255.f / pScanline[3] + .5f);
-          pScanline[1] = (pScanline[1] * 255.f / pScanline[3] + .5f);
-          pScanline[2] = (pScanline[2] * 255.f / pScanline[3] + .5f);
-        }
-        pScanline += 4;
+  if (!bitmap->HasAlpha())
+    return TRUE;
+
+  for (int row = 0; row < bitmap->GetHeight(); row++) {
+    uint8_t* pScanline = (uint8_t*)bitmap->GetScanline(row);
+    for (int col = 0; col < bitmap->GetWidth(); col++) {
+      if (pScanline[3] > 0) {
+        pScanline[0] = (pScanline[0] * 255.f / pScanline[3] + .5f);
+        pScanline[1] = (pScanline[1] * 255.f / pScanline[3] + .5f);
+        pScanline[2] = (pScanline[2] * 255.f / pScanline[3] + .5f);
       }
+      pScanline += 4;
     }
   }
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                           FX_ARGB argb,
                                           const FX_RECT* srcRect,
                                           int dest_left,
                                           int dest_top,
-                                          int blendType,
-                                          int alphaFlag,
-                                          void* iccTransform) {
+                                          int blendType) {
   SaveState();
   CGFloat src_left, src_top, src_width, src_height;
   if (srcRect) {
     src_left = srcRect->left;
     src_top = srcRect->top;
     src_width = srcRect->Width();
     src_height = srcRect->Height();
   } else {
     src_left = src_top = 0;
     src_width = pBitmap->GetWidth();
@@ skipping 96 matching lines @@
   CGContextSetBlendMode(m_context, (CGBlendMode)blend_mode);
   CGContextDrawImage(m_context, rect_usr, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
   if (pBitmap1 != pBitmap) {
     delete pBitmap1;
   }
   RestoreState(false);
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
                                               FX_ARGB argb,
                                               int dest_left,
                                               int dest_top,
                                               int dest_width,
                                               int dest_height,
                                               const FX_RECT* clipRect,
                                               uint32_t flags,
-                                              int alphaFlag,
-                                              void* iccTransform,
                                               int blend_type) {
   SaveState();
   if (clipRect) {
     CGContextBeginPath(m_context);
     CGRect rect_clip = CGRectMake(clipRect->left, clipRect->top,
                                   clipRect->Width(), clipRect->Height());
     rect_clip = CGRectApplyAffineTransform(rect_clip, m_foxitDevice2User);
     CGContextAddRect(m_context, rect_clip);
     CGContextClip(m_context);
   }
   CGRect rect = CGRectMake(dest_left, dest_top, dest_width, dest_height);
   rect = CGRectApplyAffineTransform(rect, m_foxitDevice2User);
-  if (FXDIB_BICUBIC_INTERPOL == flags) {
+  if (FXDIB_BICUBIC_INTERPOL == flags)
     CGContextSetInterpolationQuality(m_context, kCGInterpolationHigh);
-  } else if (FXDIB_DOWNSAMPLE == flags) {
+  else if (FXDIB_DOWNSAMPLE == flags)
     CGContextSetInterpolationQuality(m_context, kCGInterpolationNone);
-  } else {
+  else
     CGContextSetInterpolationQuality(m_context, kCGInterpolationMedium);
-  }
-  CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height);
+
+  CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height, nullptr);
   CFX_DIBitmap* pBitmap1 = nullptr;
   if (pBitmap->IsAlphaMask()) {
-    if (pBitmap->GetBuffer()) {
+    if (pBitmap->GetBuffer())
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
-    } else {
+    else
       pBitmap1 = pBitmap->Clone();
-    }
     if (!pBitmap1) {
       RestoreState(false);
       return FALSE;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
         nullptr, pBitmap1->GetBuffer(),
         pBitmap1->GetPitch() * pBitmap1->GetHeight(), nullptr);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
         pBitmapProvider, nullptr, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
-    if (pBitmap1 != pBitmap) {
+    if (pBitmap1 != pBitmap)
       delete pBitmap1;
-    }
+
     RestoreState(false);
     return TRUE;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
-    if (pBitmap->GetBuffer()) {
+    if (pBitmap->GetBuffer())
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
-    } else {
+    else
       pBitmap1 = pBitmap->Clone();
-    }
   }
   if (!pBitmap1) {
     RestoreState(false);
     return FALSE;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
         RestoreState(false);
         return FALSE;
       }
     }
     for (int row = 0; row < pBitmap1->GetHeight(); row++) {
       uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
       for (int col = 0; col < pBitmap1->GetWidth(); col++) {
         pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
         pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
         pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
         pScanline += 4;
       }
     }
   }
   CGContextRef ctx = createContextWithBitmap(pBitmap1);
   CGImageRef image = CGBitmapContextCreateImage(ctx);
   CGContextDrawImage(m_context, rect, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
-  if (pBitmap1 != pBitmap) {
+  if (pBitmap1 != pBitmap)
     delete pBitmap1;
-  }
+
   RestoreState(false);
   return TRUE;
 }
-FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int nChars,
-                                               const FXTEXT_CHARPOS* pCharPos,
-                                               CFX_Font* pFont,
-                                               CFX_FontCache* pCache,
-                                               const CFX_Matrix* pGlyphMatrix,
-                                               const CFX_Matrix* pObject2Device,
-                                               FX_FLOAT font_size,
-                                               uint32_t argb,
-                                               int alpha_flag,
-                                               void* pIccTransform) {
-  if (nChars == 0) {
+
+FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlyphRun(
+    int nChars,
+    const FXTEXT_CHARPOS* pCharPos,
+    CFX_Font* pFont,
+    CFX_FontCache* pCache,
+    const CFX_Matrix* pGlyphMatrix,
+    const CFX_Matrix* pObject2Device,
+    FX_FLOAT font_size,
+    uint32_t argb) {
+  if (nChars == 0)
     return TRUE;
-  }
+
   CQuartz2D& quartz2d =
       static_cast<CApplePlatform*>(CFX_GEModule::Get()->GetPlatformData())
           ->m_quartz2d;
   if (!pFont->GetPlatformFont()) {
     if (pFont->GetPsName() == "DFHeiStd-W5")
       return FALSE;
 
     pFont->SetPlatformFont(
         quartz2d.CreateFont(pFont->GetFontData(), pFont->GetSize()));
     if (!pFont->GetPlatformFont()) {
       return FALSE;
     }
   }
   CFX_FixedBufGrow<uint16_t, 32> glyph_indices(nChars);
   CFX_FixedBufGrow<CGPoint, 32> glyph_positions(nChars);
   for (int i = 0; i < nChars; i++) {
     glyph_indices[i] = pCharPos[i].m_ExtGID;
     glyph_positions[i].x = pCharPos[i].m_OriginX;
     glyph_positions[i].y = pCharPos[i].m_OriginY;
   }
   CFX_Matrix text_matrix;
-  if (pObject2Device) {
+  if (pObject2Device)
     text_matrix.Concat(*pObject2Device);
-  }
+
   CGAffineTransform matrix_cg =
       CGAffineTransformMake(text_matrix.a, text_matrix.b, text_matrix.c,
                             text_matrix.d, text_matrix.e, text_matrix.f);
   matrix_cg = CGAffineTransformConcat(matrix_cg, m_foxitDevice2User);
   CGContextSetTextMatrix(m_context, matrix_cg);
   CGContextSetFont(m_context, (CGFontRef)pFont->GetPlatformFont());
   CGContextSetFontSize(m_context, FXSYS_fabs(font_size));
   int32_t a, r, g, b;
   ArgbDecode(argb, a, r, g, b);
   CGContextSetRGBFillColor(m_context, r / 255.f, g / 255.f, b / 255.f,
                            a / 255.f);
   SaveState();
   if (pGlyphMatrix) {
     CGPoint origin = CGPointMake(glyph_positions[0].x, glyph_positions[0].y);
     origin = CGPointApplyAffineTransform(origin, matrix_cg);
     CGContextTranslateCTM(m_context, origin.x, origin.y);
     CGAffineTransform glyph_matrix = CGAffineTransformMake(
         pGlyphMatrix->a, pGlyphMatrix->b, pGlyphMatrix->c, pGlyphMatrix->d,
         pGlyphMatrix->e, pGlyphMatrix->f);
-    if (m_foxitDevice2User.d < 0) {
+    if (m_foxitDevice2User.d < 0)
       glyph_matrix = CGAffineTransformInvert(glyph_matrix);
-    }
+
     CGContextConcatCTM(m_context, glyph_matrix);
     CGContextTranslateCTM(m_context, -origin.x, -origin.y);
   }
   CGContextShowGlyphsAtPositions(m_context, (CGGlyph*)glyph_indices,
                                  glyph_positions, nChars);
   RestoreState(false);
   return TRUE;
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int nChars,
                                                const FXTEXT_CHARPOS* pCharPos,
                                                CFX_Font* pFont,
                                                CFX_FontCache* pCache,
                                                const CFX_Matrix* pObject2Device,
                                                FX_FLOAT font_size,
-                                               uint32_t color,
-                                               int alpha_flag,
-                                               void* pIccTransform) {
+                                               uint32_t color) {
   if (!pFont || !m_context)
     return FALSE;
+
   FX_BOOL bBold = pFont->IsBold();
   if (!bBold && pFont->GetSubstFont() &&
       pFont->GetSubstFont()->m_Weight >= 500 &&
       pFont->GetSubstFont()->m_Weight <= 600) {
     return FALSE;
   }
   SaveState();
   CGContextSetTextDrawingMode(m_context, kCGTextFillClip);
   FX_BOOL ret = FALSE;
   int32_t i = 0;
   while (i < nChars) {
     if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
       if (i > 0) {
-        ret =
-            CG_DrawGlypRun(i, pCharPos, pFont, pCache, nullptr, pObject2Device,
-                           font_size, color, alpha_flag, pIccTransform);
+        ret = CG_DrawGlyphRun(i, pCharPos, pFont, pCache, nullptr,
+                              pObject2Device, font_size, color);
         if (!ret) {
           RestoreState(false);
           return ret;
         }
       }
       const FXTEXT_CHARPOS* char_pos = pCharPos + i;
       CFX_Matrix glphy_matrix;
       if (font_size < 0) {
         glphy_matrix.Concat(-1, 0, 0, -1, 0, 0);
       }
       if (char_pos->m_bGlyphAdjust) {
         glphy_matrix.Concat(
             char_pos->m_AdjustMatrix[0], char_pos->m_AdjustMatrix[1],
             char_pos->m_AdjustMatrix[2], char_pos->m_AdjustMatrix[3], 0, 0);
       }
-      ret = CG_DrawGlypRun(1, char_pos, pFont, pCache, &glphy_matrix,
-                           pObject2Device, font_size, color, alpha_flag,
-                           pIccTransform);
+      ret = CG_DrawGlyphRun(1, char_pos, pFont, pCache, &glphy_matrix,
+                            pObject2Device, font_size, color);
       if (!ret) {
         RestoreState(false);
         return ret;
       }
       i++;
       pCharPos += i;
       nChars -= i;
       i = 0;
     } else {
       i++;
     }
   }
   if (i > 0) {
-    ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, nullptr, pObject2Device,
-                         font_size, color, alpha_flag, pIccTransform);
+    ret = CG_DrawGlyphRun(i, pCharPos, pFont, pCache, nullptr, pObject2Device,
+                          font_size, color);
   }
   RestoreState(false);
   return ret;
 }
+
 void CFX_QuartzDeviceDriver::setStrokeInfo(const CFX_GraphStateData* graphState,
                                            FX_ARGB argb,
                                            FX_FLOAT lineWidth) {
   if (!graphState)
     return;
 
   CGContextSetLineWidth(m_context, lineWidth);
   CGLineCap cap;
   switch (graphState->m_LineCap) {
     case CFX_GraphStateData::LineCapRound: {
@@ skipping 67 matching lines @@
                                  points[i + 1].m_PointY, points[i + 2].m_PointX,
                                  points[i + 2].m_PointY);
         i += 2;
       }
     }
     if (points[i].m_Flag & FXPT_CLOSEFIGURE) {
       CGContextClosePath(m_context);
     }
   }
 }
+
 void CFX_QuartzDeviceDriver::CG_SetImageTransform(int dest_left,
                                                   int dest_top,
                                                   int dest_width,
                                                   int dest_height,
                                                   CGRect* rect) {
   int flip_y = m_foxitDevice2User.d * dest_height < 0 ? 1 : -1;
   int flip_x = m_foxitDevice2User.a * dest_width > 0 ? 1 : -1;
-  if (flip_y < 0 || flip_x < 0) {
-    if (dest_height < 0) {
-      dest_height = -dest_height;
-      dest_top -= dest_height;
-    }
-    CGRect rt = CGRectApplyAffineTransform(
-        CGRectMake(dest_left, dest_top, dest_width, dest_height),
-        m_foxitDevice2User);
-    CGFloat offset_x = (rt.origin.x) + rt.size.width / 2.f,
-            offset_y = (rt.origin.y) + rt.size.height / 2.f;
-    CGAffineTransform transform = CGAffineTransformIdentity;
-    transform = CGAffineTransformConcat(
-        transform, CGAffineTransformMake(1, 0, 0, 1, -offset_x, -offset_y));
-    transform = CGAffineTransformConcat(
-        transform, CGAffineTransformMake(flip_x, 0, 0, flip_y, 0, 0));
-    transform = CGAffineTransformConcat(
-        transform, CGAffineTransformMake(1, 0, 0, 1, offset_x, offset_y));
-    CGContextConcatCTM(m_context, transform);
-    if (rect) {
-      *rect = CGRectApplyAffineTransform(*rect, transform);
-    }
+  if (flip_y >= 0 && flip_x >= 0)
+    return;
+
+  if (dest_height < 0) {
+    dest_height = -dest_height;
+    dest_top -= dest_height;
   }
+  CGRect rt = CGRectApplyAffineTransform(
+      CGRectMake(dest_left, dest_top, dest_width, dest_height),
+      m_foxitDevice2User);
+  CGFloat offset_x = (rt.origin.x) + rt.size.width / 2.f,
+          offset_y = (rt.origin.y) + rt.size.height / 2.f;
+  CGAffineTransform transform = CGAffineTransformIdentity;
+  transform = CGAffineTransformConcat(
+      transform, CGAffineTransformMake(1, 0, 0, 1, -offset_x, -offset_y));
+  transform = CGAffineTransformConcat(
+      transform, CGAffineTransformMake(flip_x, 0, 0, flip_y, 0, 0));
+  transform = CGAffineTransformConcat(
+      transform, CGAffineTransformMake(1, 0, 0, 1, offset_x, offset_y));
+  CGContextConcatCTM(m_context, transform);
+  if (rect)
+    *rect = CGRectApplyAffineTransform(*rect, transform);
 }
+
 void CFX_QuartzDeviceDriver::ClearDriver() {
   if (!m_context)
     return;
 
   for (int i = 0; i < m_saveCount; ++i) {
     CGContextRestoreGState(m_context);
   }
   m_saveCount = 0;
   if (m_context) {
     CGContextRelease(m_context);
@@ skipping 44 matching lines @@
   }
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height, format)) {
     delete pBitmap;
     return FALSE;
   }
   m_bOwnedBitmap = TRUE;
   return Attach(pBitmap);
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_