update skia to latest sources

core/fxge/skia/fx_skia_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.
 
 #if defined(_SKIA_SUPPORT_)
 #include <algorithm>
 #include <vector>
 
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxcrt/fx_memory.h"
@@ skipping 709 matching lines @@
       if (m_commands[index] == Clip::kSave)
         pDriver->SkiaCanvas()->restore();
     }
 
     if (m_commandIndex > 0)
       pDriver->SkiaCanvas()->save();
     while (index > 0 && m_commands[index] != Clip::kSave)
       --index;
     while (++index < m_commandIndex) {
       SkASSERT(m_commands[index] == Clip::kPath);
-      pDriver->SkiaCanvas()->clipPath(m_clips[index], SkRegion::kIntersect_Op,
+      pDriver->SkiaCanvas()->clipPath(m_clips[index], SkCanvas::kIntersect_Op,
                                       true);
     }
     m_commands.setCount(m_commandIndex);
     m_clips.resize_back(m_commandIndex);
   }
 
   // returns true if caller should apply command to skia canvas
   bool ClipSave(CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
@@ skipping 336 matching lines @@
   if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
     CFX_FloatRect rectf;
     if (pPathData->IsRect(deviceMatrix, &rectf)) {
       rectf.Intersect(
           CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                         (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
       // note that PDF's y-axis goes up; Skia's y-axis goes down
       SkRect skClipRect =
           SkRect::MakeLTRB(rectf.left, rectf.bottom, rectf.right, rectf.top);
       DebugDrawSkiaClipRect(m_pCanvas, skClipRect);
-      m_pCanvas->clipRect(skClipRect, SkRegion::kIntersect_Op, true);
+      m_pCanvas->clipRect(skClipRect, SkCanvas::kIntersect_Op, true);
       return TRUE;
     }
   }
   SkPath skClipPath = BuildPath(pPathData);
   skClipPath.setFillType((fill_mode & 3) == FXFILL_ALTERNATE
                              ? SkPath::kEvenOdd_FillType
                              : SkPath::kWinding_FillType);
   SkMatrix skMatrix = ToSkMatrix(*deviceMatrix);
   skClipPath.transform(skMatrix);
   DebugShowSkiaPath(skClipPath);
   DebugDrawSkiaClipPath(m_pCanvas, skClipPath);
-  m_pCanvas->clipPath(skClipPath, SkRegion::kIntersect_Op, true);
+  m_pCanvas->clipPath(skClipPath, SkCanvas::kIntersect_Op, true);
 
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,         // path info
     const CFX_Matrix* pObject2Device,      // optional transformation
     const CFX_GraphStateData* pGraphState  // graphic state, for pen attributes
     ) {
   if (m_pCache->SetClipStroke(pPathData, pObject2Device, pGraphState, this))
     return TRUE;
   // build path data
   SkPath skPath = BuildPath(pPathData);
   SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
   SkPaint skPaint;
   PaintStroke(&skPaint, pGraphState, skMatrix);
   SkPath dst_path;
   skPaint.getFillPath(skPath, &dst_path);
   dst_path.transform(skMatrix);
   DebugDrawSkiaClipPath(m_pCanvas, dst_path);
-  m_pCanvas->clipPath(dst_path, SkRegion::kIntersect_Op, true);
+  m_pCanvas->clipPath(dst_path, SkCanvas::kIntersect_Op, true);
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::DrawPath(
     const CFX_PathData* pPathData,          // path info
     const CFX_Matrix* pObject2Device,       // optional transformation
     const CFX_GraphStateData* pGraphState,  // graphic state, for pen attributes
     uint32_t fill_color,                    // fill color
     uint32_t stroke_color,                  // stroke color
     int fill_mode,  // fill mode, WINDING or ALTERNATE. 0 for not filled
@@ skipping 193 matching lines @@
       skClip.transform(skMatrix);
     }
     SkMatrix inverse;
     if (!skMatrix.invert(&inverse))
       return false;
     skPath.addRect(skRect);
     skPath.transform(inverse);
   }
   m_pCanvas->save();
   if (!skClip.isEmpty())
-    m_pCanvas->clipPath(skClip, SkRegion::kIntersect_Op, true);
+    m_pCanvas->clipPath(skClip, SkCanvas::kIntersect_Op, true);
   m_pCanvas->concat(skMatrix);
   m_pCanvas->drawPath(skPath, paint);
   m_pCanvas->restore();
   return true;
 }
 
 uint8_t* CFX_SkiaDeviceDriver::GetBuffer() const {
   return m_pBitmap->GetBuffer();
 }
 
@@ skipping 68 matching lines @@
                                             uint32_t flags,
                                             int blend_type) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
   CFX_Matrix m(dest_width, 0, 0, -dest_height, dest_left,
                dest_top + dest_height);
 
   m_pCanvas->save();
   SkRect skClipRect = SkRect::MakeLTRB(pClipRect->left, pClipRect->bottom,
                                        pClipRect->right, pClipRect->top);
-  m_pCanvas->clipRect(skClipRect, SkRegion::kIntersect_Op, true);
+  m_pCanvas->clipRect(skClipRect, SkCanvas::kIntersect_Op, true);
   void* dummy;
   FX_BOOL result = StartDIBits(pSource, 0xFF, argb, &m, 0, dummy, blend_type);
   m_pCanvas->restore();
 
   return result;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                           int bitmap_alpha,
                                           uint32_t argb,
@@ skipping 238 matching lines @@
       SkA32Assert(a);
       SkASSERT(r <= a);
       SkASSERT(g <= a);
       SkASSERT(b <= a);
     }
   }
 #endif
 }
 
 #endif