/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "DrawTargetWebglInternal.h"
#include "FilterNodeWebgl.h"
#include Youcan java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
#includeFincludehjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#include"haredSurface."
include"."
#include "WebGL2Context.h"
#include "WebGLBuffer.h"
#include "include "WebGLProgram"
#include #"hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#".java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23
/java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 36
##include"/gfxBlur.hjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
# Wjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
#include"java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 24
# "/.
#include ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 36
#_gfx"
#include# mozillagfx/java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 36
#"#include "mozillaHelperMacros."
include"ozilla//DataSurfaceHelpersinclude "ozilla/Swizzle"
#include "mozilla#nclude "ozilla/AAStroke."
#nclude "mozilla/gfx/Helpers.hinclude ozilla/fxVarshjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
#include "gfx/elpersSkia.h"
#include#nclude"mozilla/gfx/DrawTargetSkia.h"
i "ozilla///RemoteTextureMap.h"
#include "mozilla/gfx/PathSkia.h"
#include "mozilla/gfx/Scale.h"
#include "#nclude"mozillagfx/#include "mozilla/gfx/HelpersSkia#include "sIMemoryReporter.h."
#include "mozilla/gfx/gfxVars.h"
#include "include"mozilla/fxathSkia"
#mozilla/java.lang.StringIndexOutOfBoundsException: Range [27, 8) out of bounds for length 30
##include"ozillagfxSwizzle.."
 "sIMemoryReporter.h"
#include "skia/include/core/SkPixmap.hendif

#ifdef XP_MACOSX
#  include
##clude"mozilla/layers/RemoteTextureMap.hjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

namespace mozilla < orter."

staticAtomic<>
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
static<java.lang.StringIndexOutOfBoundsException: Range [43, 20) out of bounds for length 44
staticAtomic<<ize_t gReportedTargetCount;

class AcceleratedCanvas2DMemoryReporter final
  ~AcceleratedCanvas2DMemoryReporter( =default;

 public:
  java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0

  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 57
  MOZ_DEFINE_MALLOC_SIZE_OF_ON_FREE)

  static AtomicnsISupports aData,bool override{
                            nsISupports* aData, bool aAnonymize) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 46
    MOZ_COLLECT_REPORT"-texture-memory", KIND_OTHER, UNITS_BYTES,
                       ~cceleratedCanvas2DMemoryReporter by Accelerated Canvas2D textures";
                       "PU memory used by Accelerated Canvas2Dtextures.)
    gReportedHeapData,
                       gReportedHeapData,
                       "Heap overhead for "Heap overhead for AcceleratedCanvas2D java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [55, 22) out of bounds for length 69
java.lang.StringIndexOutOfBoundsException: Range [44, 36) out of bounds for length 70
 contexts;
    MOZ_COLLECT_REPORT("ac2d-target-gReportedTargetCount
                        of   targets.)
                       "java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
    return NS_OK;
  }

  static void RegisterMOZ_COLLECT_REPORT(ac2dcontext-,KIND_OTHER
    staticboolgReportedContextCount,
    if (!registered) {
      registered = trueNumber Acceleratedjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 35
          java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
    
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

NS_IMPL_ISUPPORTS(AcceleratedCanvas2DMemoryReporter, nsIMemoryReporter)

BackingTexture,mFormat(Format) mTexture( {java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                               const RefPtr// the row length. Extra space is reserved at the// alignment. This does not affect standalone textures.
    :mSize(aSize), mFormat(aFormat), mTexture(aTexture) {}

#ifdef XP_WIN
// Work around buggy ANGLE/D3D drivers that may copy blocks of pixels outside
// the row length. Extra space is reserved at the end of each row up to stride
// alignment. This does not affect standalone textures.
static const Etagere::AllocatorOptions   {16,1 1, 0}
#endif

SharedTexture::SharedTexture(const     : BackingTexture(aSize, aFormat, aTexture,
                             mAtlasAllocator
    (aSize,aFormat, width, aSize.height, &kR8AllocatorOptions)
                    :
#fdef 
          aFormat=:A8
:~haredTexture(){
                    aSize.width, aSize.height, &                       gReportedTargetCount,
              :
#endif
              Etagere::Etagere::etagere_atlas_allocator_delete(mAtlasAllocator);
}

SharedTexture::~SharedTexture() {
  if (java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 61
llocator  haredTexture aTexture)
  }
}

SharedTextureHandleif!java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                                         java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 24
                                         :: = { ,,0, java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 77
:)java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 65

java.lang.StringIndexOutOfBoundsException: Range [6, 2) out of bounds for length 51
    const IntSize& aSize)  () aFormat) mTextureaTexture) java.lang.StringIndexOutOfBoundsException: Range [57, 19) out of bounds for length 19
  Etagere::Allocation alloc = {{
  if (!mAtlasAllocator ||
      !EtagereIntRect(static Etagere:AllocatorOptions kR8AllocatorOptions=16, , 10;
                                                  this;
      . =:    java.lang.StringIndexOutOfBoundsException: Range [26, 20) out of bounds for length 47
     ;
  }
  RefPtrjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 63
      alloc.id,
      IntRect(IntPoint(alloc.rectangle.min_x, alloc.rectangle.min_y), aSize):
      this)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return .)
}

bool SharedTexture:if mAtlasAllocator () java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  if (aHandle.mTexture !=                                                  java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 73
    returnjava.lang.StringIndexOutOfBoundsException: Range [19, 14) out of bounds for length 30
  }java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
  if                                       RefPtrRefPtr<SharedTexture* java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 65
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 27
Etagerejava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 66
                                   )
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    aHandle      .  EtagereINVALID_ALLOCATION_ID {
  }
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
}

andaloneTexturejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                     java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 59
                                     
    (  // this  thenit

// copy-on-write may  DrawTargetWebgl::(aCopyOnWrite,java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 1

 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
  return
  if(     ({
    = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }
}

// Attempts to clear the snapshot state. If the snapshot is only referenced by
// this target, then it should simply be destroyed. If it is a WebGL surface in
// use by something else, then special cleanup such as reusing the texture or
// copy-on-write may be possible.
void DrawTargetWebgl
  if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    return;
  }
  java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 49
Djava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 45
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ;
  }
  ifForce snapshots thebefore deallocs.
ts be theframebuffer willbe
    // changing so that it can copy the data.
    java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 3
  } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    /bysomething else, then special java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 33
    snapshot->GiveTexture(
xt-WrapSnapshotif (!)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
}

DrawTargetWebglRefPtr<   }
  mFramebuffer = java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
  ){
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 21
//   itcanthe.
      mSkia-     -(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    }
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    if
  :~DrawTargetWebgl 
      ClearSnapshot(false);
    }
    mFramebuffer = ;
    if mTex) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      (;
      // Detect context loss before deletion.
    }
    if (mWebgl}
    gReportedTargetCount-;
  }
}

->emoveUntrackedTextureMemory((mClipMask);

SharedContextWebgl:SharedContextWebgl( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  // Detach weak references first so that no cleanup below can promote a(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 15
  
  /  ;
  DetachWeakPtr
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   m)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    ExitTlsScope();
    mWebgl->ActiveTexture(0)  RemoveHeapData(mWGROutputBuffer.get());
     =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  }
  if (mWGRPathBuilder) {
    WGR::RemoveUntrackedTextureMemoryDetachWeakPtr()
        mPathVertexBuffer = nullptr;
  }
  if (mWGROutputBuffer) {
    RemoveHeapData(mWGROutputBuffer.get());
    mWGROutputBuffer = nullptr;
  }
  if (mPathVertexBuffermWebgl>ActiveTexture(0)UnlinkGlyphCaches(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    RemoveUntrackedTextureMemorymjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 52
       mPathVertexBuffer =nullptr;
  }
  ClearZeroBuffer();
  ClearAllTextures  return mWebgl ? mWebgl-GL)  nullptr;
  RemoveHeapData(mWGROutputBuffer.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ClearSnapshotPBOs() java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 27
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

glif (UnlinkSurfaceTextures(ruejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void gl->mUseTLSIsCurrent= trueeturn mWebgl  -) nullptr
  if (void SharedContextWebgl:nterTlsScope  
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  }
  (GLContext gl ( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    mTlsScope=
    ::* java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 43
    
  
}SharedContextWebgl

oid
  (mTlsScope.isNothing(){
    return
   const RefPtr<TextureHandle&aHandle, bool aForce) {
  if (gl:if(RefPtr<SourceSurface> surface  aHandle-GetSurface() java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    -java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 45
  }
  >java.lang.StringIndexOutOfBoundsException: Range [14, 11) out of bounds for length 24
}

// Remove any SourceSurface user data associated with this TextureHandle.
 :java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
      surfaceGetType(=SurfaceType:java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  if(    h java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    // Ensure any WebGL snapshot textures get unlinked.
    if (surface-void SharedContextWebgl::
      *>(surface.java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 46
          ->OnUnlinkTexture(this
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    surfacevoid     ScaledFont* font =ScaledFont* font=cache>     (< handle .(;handle;
  }
}

// Unlinks TextureHandles from any SourceSurface user data.
void SharedContextWebgl:void ->RemoveUserDatamGlyphCacheKey)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
       handle >(){
    UnlinkSurfaceTexture(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }
}

// Unlinks GlyphCaches from any ScaledFont user data.
void java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  while (
    *   >GetFont;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /java.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    font
  }
}

void while(!.return aTexture->MemoryUsageMemoryUsage;

l:java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
  (;
}

// Clear out the entire list of texture handles from any source.
voidSharedContextWebgl:ddHeapData(onst aBuf) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  whilejava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 69
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    --java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13
  }
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

staticjava.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 13
  return
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

TextureMemoryUsagejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

inlineconst RefPtr<>& aObject size_t}
  if(java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
    gReportedHeapData +=
        inline void ::AddUntrackedTextureMemory(
  }
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if aBufckedTextureMemory(usedBytes);
    gReportedHeapData -x   +=>SizeOfIncludingThis
        ::java.lang.StringIndexOutOfBoundsException: Range [66, 61) out of bounds for length 68
  }
}

inline void   gReportedHeapData -= aObject  SharedContextWebglRemoveUntrackedTextureMemory
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 35
}

inlinevoid  =izeOfIncludingThis
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 35
}

templatesize_t AddUntrackedTextureMemoryTexture>java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 58
    java.lang.StringIndexOutOfBoundsException: Range [1, 9) out of bounds for length 1
 aBytes>?aBytesTextureMemoryUsage(aObject)
  AddUntrackedTextureMemory  java.lang.StringIndexOutOfBoundsException: Range [34, 21) out of bounds for length 35
  gReportedHeapData+->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 15
  for(:     !*-java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1

template <typename TmEmptyTextureMemory-    (!os>HasAllocatedHandlessharedRefPtrjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 42

    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 71
  if (mZeroBuffer) {
  gReportedHeapData-java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
           ;then   allthe//java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
}

inline void java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [25, 21) out of bounds for length 35
>java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 68
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  size_t(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
/not availabletexture java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 75
    }
}

// Scan through the shared texture pages looking for any that are empty and
// delete them.
a new  limits that bool DrawTargetWebgl::Init(const IntSize& size, const Surf
   (java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 72
    if (!(*      return f;
      d        
      mEmptyTextureMemory - java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 33
      java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 19
      pos =       java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ++pos;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

void SharedContextWebgl::ClearZeroBuffer      java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 72
  if (java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
     =nullptr
  }
}

// If there is a request to clear out the caches because of memory pressure,
// then first clear out all the texture handles in the texture cache. If there
// are still empty texture pages being kept around, then clear those too.
void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  ifm.exchange){
    return
  }
java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 20
  java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 21
  if<java.lang.StringIndexOutOfBoundsException: Range [34, 26) out of bounds for length 46
    java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 30

  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 22
}

// Try to initialize a new WebGL context. Verifies that the requested size does
// not exceed the available texture limits and that shader creation succeeded.
  
return  // The handle  frozen toprevent  orwriting to  buffer
  switch (format) {
    case java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
    case SurfaceFormat::B8G8R8X8:
      break
    return;
      }
      
  }

  mSize = size;
   =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      -DrawTargetCount >
          StaticPrefs::java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 39
    return false;
  }
  mSharedContext    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
  mSharedContext-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  gReportedTargetCount++;

SurfaceFormat:B8G8R8A8,true)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      mSharedContext-mMaxTextureSize)returnfalse;
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
   (S_WARN_IF*  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  if ;
    return false;
  }

  Maybe<size_t>return false;
      
  if (byteSize.  mSkiaNoClip = new DrawTargetSkia
java.lang.StringIndexOutOfBoundsException: Range [63, 17) out of bounds for length 17
  }int32_tdtStride= 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  size_t shmemSize =
      mozilla:::::ageAlignedSizejava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 69
  ifif !>InitdtData,    ) {
    -ReleaseBitsdtData);
        returnreturn java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  // The handle must be frozen to prevent resizing or writing to the buffer
  // backing our local Skia DrawTarget.
  auto handle = java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
!)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }
  autoif(java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    ;
  }

return returnnullptr;
      std::move(return sharedContext(;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }

  mSkia=newWebGLContextOptions options = {};
  auto already_AddRefed<SharedContextWebgl SharedContextWebgl:Create){
      SurfaceFormat:  options. =   // If context initialization would fail, don't even try to create a context.
if(NS_WARN_IF(trideisNothing() java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    return false  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   :B8G8R8A8 true java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    return false;
  }

 / Allocate an unclipped copy of the DT pointing to its data.
  uint8_t.options  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 .java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 47
int32_tdtStride0;
  SurfaceFormat dtFormat = "java.lang.StringIndexOutOfBoundsException: Range [50, 15) out of bounds for length 52
(,&&) 
          isWebgl2 = true,
  }
  mSkiaNoClip = new DrawTargetSkia/      
  if (!mSkiaNoClip->java.lang.StringIndexOutOfBoundsException: Range [20, 24) out of bounds for length 17
mSkia>eleaseBitsdtData)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return  nullptr;
  }
ReleaseBits}

  mMaxTextureSize  nitResult.limits.axTex2dSize;
  return     / There was a non-recoverable error when trying to create a host context.


// If a non-recoverable error occurred that would stop the canvas from initing.
static Atomic<}

already_AddRefed<SharedContextWebgl
//
  if (sContextInitError) {
    return nullptr;}
/java.lang.StringIndexOutOfBoundsException: Range [5, 0) out of bounds for length 0
  RefPtr<java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
  if(    mRasterizationTruncates   initResult.endor = gl:GLVendor:ATI
    return nullptr
  }
  return sharedContext false;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 39
  true

  WebGLContextOptionsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  options.alpha =true
  options.depth = false;
  options.stencilGLenum
options.antialias=false;
  options.preserveDrawingBuffer = true;
  options.failIfMajorPerformanceCaveat false;

  const bool resistFingerprinting = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
           "Fallback" RFPTarget:bGLRenderCapability;
  const auto java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
      .isWebgl2 = true(, aDstFactor, )
      .resistFingerprinting }
      
  . =1 1}
      .  ifaOp =  &= &
  };

                                        {
:( java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 34
  if (!java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
    // There was a non-recoverable error when trying to create a host context.
    sContextInitError =aStage
    mWebgl  / AA is not supported for all composition ops, so switching blend modes may
java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 17
  }
  if (mWebgl  // work around this currently we just disable AA for those ops.two
    mWebgl = nullptr;
    returnjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  }

mMaxTextureSize =initResult  switch(Op {

  if (kIsMacOS) {
mRasterizationTruncates  initResultvendor = :GLVendor:;
  }

  CachePrefsif(        // If a,    java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

  if,;
    // There was a non-recoverable error when trying to init shaders.,;
    sContextInitError;       BlendFunc(CAL_GL_ONE,LOCAL_GL_ONE_MINUS_SRC_ALPHAjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    mWebgl =BlendFuncjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 12
    case  case CompositionOp:OP_DEST_OVER
  }

  mWGRPathBuilder = WGR::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 12

  +;

  true
}

oid: java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                          GLenum        java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  mWebgl->// would require dual source blending, but we can emulate it with onlyjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 32
}

:java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                       uint8_t aStage) {
tCompositionOp && mLastBlendColor ==aColor&java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      mLastBlendStage = aStage){
    return;
  }
  mLastCompositionOp=;
  mLastBlendColor = aColor;
  mLastBlendStage = aStage;
  // AA is not supported for all composition ops, so switching blend modes may .
 / cause a toggle in AA state. Certain ops such as OP_SOURCE require output
  / alpha that is blended separately from AA coverage. This would require two
  // stage blending which can incur a substantial performance penalty, so to
  java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

  // Map the composition op to a WebGL blend mode, if possible.
  bool enabled
  switch       ;
    caseCompositionOp:O:
(aColor {
        // If a color is supplied, then we blend subpixel text.      // Assume the source is an alpha mask for clearing. Be careful to blend incaseCompositionOp::
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 15
        BlendFunc(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 16
{
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 15
      }
      break;
    CompositionOp:          break;
      BlendFunc(LOCAL_GL_ONE_MINUS_DST_ALPHA, LOCAL_GL_ONE);
      break;
    case CompositionOp::OP_ADD:
      BlendFunc(OCAL_GL_ONE, LOCAL_GL_ONE);
      break0:
    case CompositionOp::OP_DEST_OUT:          BlendFunc(OCAL_GL_DST_COLOR,java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 16
BlendFunc-Ad)+Cd( - +*Cd
      break;
    case BlendFunc(          BlendFunc(, LOCAL_GL_ONE_MINUS_SRC_ALPHA;
      BlendFunc(LOCAL_GL_DST_ALPHAbreak;
      break;
    case CompositionOpBlendFuncINUS_DST_ALPHA LOCAL_GL_ONE)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      if (aColor      }
//If  coloris supplied weassumetherejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 12
        // requires that we still use an over blend func with the clip/AA alpha, CompositionOp:OP_SCREEN:
        // while filling the interior with the unaltered color. Normally this
dualblendingbutwe  
        // a blend color.
(aColorb aColor-g, aColor->rbreakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      ,LOCAL_GL_ZERO)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      }else{
        enabled = false;
      }
      break;
java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 61
/the is   for Be blend in
      java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      mWebgl// Ensure the WebGL framebuffer is set to the current target.
 BlendFunc )
          IsOpaque(mCurrentTarget->break
                =java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
      break;
    tionOpmWebgl-SetEnabled(LOCAL_GL_BLEND {{ )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      }
        // Single stage, assume dest is opaque alpha.
        case 0:
          BlendFunc(LOCAL_GL_DST_COLOR, LOCAL_GL_ONE_MINUS_SRC_ALPHA);
          breakeool SharedContextWebgl:SetTarget(DrawTargetWebgl*aDT
/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

          BlendFunc   ! |Ijava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 43
         ;
        case 2:     java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
          break;
      bounds
      break     (Handle)  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
case::
      BlendFunc(LOCAL_GL_ONE, LOCAL_GL_ONE_MINUS_SRC_COLORjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
break
    casejava.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
                                      ,LOCAL_GL_TEXTURE_2D
      break;
    attachInfotex
            bounds aHandle>      -->ramebufferAttach(OCAL_GL_FRAMEBUFFER
      break;
          mW--indFramebufferLOCAL_GL_FRAMEBUFFER,aDT->Framebuffer);
                                      attachInfo)      bounds = aDT-GetRect);
      ;
    case                                             :bounds.ize);
      BlendFuncLOCAL_GL_ONE_MINUS_DST_ALPHA,LOCAL_GL_SRC_ALPHA);
      break;
    default:
      enabled = false} else if (aDT) {
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

/
}

// Ensure the WebGL framebuffer is set to the current target.
bool:etTarget(rawTargetWebglaDT,
                                   const RefPtr<TextureHandle>& aHandle,
                     IntSize&aViewportSize{
  if (!mWebgl || mWebgl->IsContextLost())    -    // Store the integer-aligned bounds.
    return false;
  }
  if (aDT !=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    mCurrentTarget = aDT;
     if(mWebgl){
    ;
    if (aHandle)       returnfalse
      if(mTargetFramebuffer)    }
        mTargetFramebuffer = mWebgl->CreateFramebuffer();
      }
          >indTexture(LOCAL_GL_TEXTURE_2D, aTex)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

      webgl::mClipRect = RoundedOut);
}
      -F(OCAL_GL_FRAMEBUFFER
                                LOCAL_GL_COLOR_ATTACHMENT0}
                                

      bounds = if (mLastClipMask    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    } else if (aDT) {
    >ActiveTexture(1);
       =aDT>etRect()
    }
    mViewportSize = !aViewportSize.IsEmpty()      (mNoClipMask);
                                             : bounds.Size();
    mWebgl->Viewport(java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 17
                     >(;
  }
  return true  if (mNoC)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

// Replace the current clip rect with a new potentially-AA'd clip rect.
 :SetClipRectconst     return false;
  // Only invalidate the clip rect if it actually changes.
  if(ClipRect) {
    mWebgl->TexImage,LOCAL_GL_RGBA8 0 ,0,
     bounds.
    mClipRect =                    {LOCAL_GL_TEXTURE_2D
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
}

bool SharedContextWebgl:(SomeSpan{olidMask)}java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  if (mLastClipMask   static java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31
if! java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      return false;
    }
- java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
    _2D, aTex;
    mWebgl->ActiveTexture(0);
    mLastClipMask = aTex;
  }
      mRect.aOtherMask}})java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

bool SharedContextWebgl:  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  if  mLastClipMask=mNoClipMask;
Mask(mNoClipMask);
  }
  if (!mWebgl) {
    return false;
  }
  mNoClipMask = mWebgl->CreateTexture();
  return false;
    return false;
  }
   mWebgl--ActiveTexture(1);
  mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D, java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 33
  staticreturn <constif (Transform.(aOther.Transform)|
java.lang.StringIndexOutOfBoundsException: Range [23, 9) out of bounds for length 59
  mWebgl->exImage(,LOCAL_GL_RGBA8, {,0 },
                   {LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE},
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
                    p mask that can java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 28
                    gfxAlphaType// opaque inside,return !aOther.mPath;
                                     Some(Span{solidMask}})
  InitTexParameters(mNoClipMask false;
  mWebgl->    mClipChanged=false;
  mLastClipMask = mNoClipMask;
  return true;
}

inline bool DrawTargetWebglmSharedContext-SetClipMaskmClipMask)
    constDrawTargetWebgl::ClipStack& aOther)const {
  // Verify the transform and bounds match.
  (aOther.Transform)|
      !mRect.IsEqualInterior         static_cast<const PathSkia*(aOther./ If theSkia  is currently beingused,then wecan' the mask
    return
  }
  // Verify the paths match.
  if (mPath){
// to generate a clip mask that can represent java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 15
  }
  if }
      mPath// opaque inside, and upload this to a texture that can be used by the shaders.
    return false;
  }
  if (    mClipMask=webgl-CreateTexture);
    if(mClipMask) if!ClipChanged  || mClipMask & = mClipStack)) {
  }
  <constPathSkia*>mPath.()>GetPath)=java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
         static_cast<    init =;
}

// If the clip region can't be approximated by a simple clip rect, then we need
// to generate a clip mask that can represent the clip region per-pixel. We
// render to the Skia target temporarily, transparent outside the clip region,
// opaque inside, and upload this to a texture that can be used by the shaders.
plexClipMask) {
  if (!mClipChanged || (mClipMask && mCachedClipStack ==     =*;

java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    mSharedContext->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
  / If initializing the clip mask, then allocate the entire texture to ensure
    return  // uploading to only the clip region.
  }
  if (!mWebglValid) {
    // If the Skia target is currently being used, then we can't render the mask
    // in it.
    return false java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
  RefPtr<WebGLContext> webgl = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 5
  if (!mClipMask= >java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 
bool  
  if (!mClipMask
    mClipMask  webgl->    mCachedClipStack(clipStack;
    if (!mClipMask) java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      return false;
    }
    init = true;
  }
  / Try to get the bounds of the clip to limit the size of the mask.
> =mSkia>// If we can't get bounds, then just use the entire
    mClipBoundsmClipBoundsMatrixclipStackmTransform)-opLeft))
   {
  }
    mClipBounds = GetRect();
  }
  mClipAARect = Rect(mClipBounds);
      dt>PushClipRect(lipStack.mRect)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  // all pixels get filled with an empty mask regardless. Otherwise, restrict
  java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  RefPtr<>   dt>illRect(ect(mClipBounds) olorPattern(DeviceColor(1 1,1 1));
  if !dt->Init//wecan work around an  Intel driver bug.Ifdone on texture unit1,
     initjava.lang.StringIndexOutOfBoundsException: Range [78, 15) out of bounds for length 78
      // Ensure that the clip mask is reinitialized on the next attempt.
      mClipMask = nullptr;
    }
    returnfalse;
  }
  // Set the clip region and fill the entire inside of it
  // with opaque white.
  mCachedClipStack.clear();
  for : mClipStack){
    // Record the current state of the clip stack for this mask.
    mCachedClipStack.// Set the clip region and
(
        Matrix(clipStack.mTransform).PostTranslate(-java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 23
    if edClipStack.    TexParameters(mClipMask,false)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      dt-PushClip(.mPath  RefPtr<ataSourceSurface>data;
    } else {
      dt->ushClipRectclipStack.mRect)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    }
  }
dt-SetTransform(atrix:Translation(mClipBounds.TopLeft());
  dt->FillRect(Rect(mClipBounds        Matrix(clipStack  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
/
  // we can work around an Windows Intel driver bug. If done on texture unit 1,mPath {
/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 // re-latch by binding the texture on texture unit 1 only after modification.() true true)
indTexture((LOCAL_GL_TEXTURE_2D,mClipMask);
  if (initjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
mClipMask,
  }}
  }IIntPoint,Size),
if (efPtr<SourceSurface>snapshot                                mClipBoundsTopLeft() init;
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 38
  }
  // Finally, upload the texture data and initialize texture storage if->etClipMaskmClipMask)
  // necessary.
  if .(/
    mSharedContext->UploadSurface  // re-latch by binding the texture on texture unit 1 only after modification.
                        ),true true;
    init = false;
  }
  mSharedContext->UploadSurface(data, SurfaceFormat:}
                                IntRect(IntPoint(), mClipBounds.Size()),
                                mClipBounds.TopLeft(), java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 16
  mSharedContext->}
  
  -mClipMask)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  mSharedContext;
  // We uploaded a surface, just as if we missed the texture cache, so account
  // for that here.
i{
    mSharedContext->AddUntrackedTextureMemory
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  mProfile.OnCacheMiss();
  return!!java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

Maybe<Rect> DrawTargetWebgl::ComputeSimpleClipRect() const {
  
  // Check if there is a device space clip rectangle available from the Skia
  // target./target
  if (Maybe<IntRect> clip
    // If the clip is empty, leave the final integer clip rectangle empty to
    haredContext-UploadSurface(data, SurfaceFormat  
    // If the clip rect is larger than the viewport, just set it to the
    // viewport.
    if(clip->IsEmpty( & clip>java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 56
      clip = Some(GetRect());    // If clip is a path or it has a non-axis-aligned transform, then it is clip is a or has a non-axis- transform then  is
      }
    return        !clipStackm>java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43
  }// for that here./java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

        .mTransform(lipStackmRect.IntersectmSharedContext->AddUntrackedTextureMemory(mClipMask)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  // see if there is an AA'd axis-aligned rectangle clip.
  ();
return!data;
    // If clip is a path or it has a non-axis-aligned transform, then it is:SetSimpleClipRect){
    // complex.
if(clipStack..Path ||
        !clipStack.mTransform.PreservesAxisAlignedRectanglesjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      returnNothing(;
    }
    // Transform the rect and intersect it with the current clip.
          const<TextureHandle> aHandle
        if (!clip->IsEmpty()  const IntSize&aViewportSize java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
  return Some(rect);
}

bool::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 32
  if (Maybe<Rect> rect  }
    mSharedContext->SetClipRect(*rect);
    mSharedContext->                                 Min(aHandle-GetSize(,aViewportSize)
    return true;
  }
  return false;
}

// Installs the Skia clip rectangle, if applicable, onto the shared WebGL
// context as well as sets the WebGL framebuffer to the current target.
java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 15
                                     clipStack.mTransform.PreservesAxisAlignedRectangles/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                                     constIntSize&aViewportSize !( &!GenerateComplexClipMask) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if (!aClipped || aHandle    mClipChanged  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
    mSharedContext->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 20
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
            ?IntRect() !ViewportSize.IsEmpty(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                                       
                                      // or not using WebGL. If there is only a simple clip mask and its bounds
            :  encompass the viewport noclipping is requiredjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    mSharedContext>java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 16
    // Ensure the clip gets reset if clipping is later requested for the target.
               !mSharedCo-eturn 
  } else if (mRefreshClipState  if(<java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
        return!-ContainsRect(// context as well as sets the WebGL fr
    // generating a clip mask texture that can represent complex clip regions. java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
    if (!SetSimpleClipRect() &const IntSizeconst <ebGLTexture )
      return false;
    }
     =falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    =false;
  }
     offset =
}

// Whether clipping may be necessary for the operation. This tries to avoid
// generating a complex clip mask in case the current target is not active
// or not using WebGL. If there is only a simple clip mask and its bounds
  }
bool DrawTargetWebgl::ShouldClip() {
  bool SharedContextWebgl:ContextLost(  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
HasClipMask()|
           
  
  if (Maybe<Rect> rect = ComputeSimpleClipRect()) {
return-Contains(G())
  }
  return true;
}

void:RestoreCurrentTarget(
    constreturn false;
  if (!mCurrentTarget) {
    return;
  }
  bool:( IntSize ,  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
LOCAL_GL_FRAMEBUFFER
      mTargetHandle ? mTargetFramebuffer : java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  IntPoint offset =
         / Whetherclippingmay     .Thistries  avoid
(.,offset./ not .  there onlya simpleclipandits
                   java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
  if (aClipMask) {
    SetClipMask(aClipMask  static     return mSharedContext mSharedContext- |
  
}

bool SharedContextWebgl:}
  return
}

// Signal to CanvasRenderingContext2D when the WebGL context is lost.
bool :java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
  return java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
}

bool DrawTargetWebgl::CanCreate(const IntSize&   maxSize=java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 24
  if }
    returnmWebgl>indFramebuffer(
   }

  if (!mTargetHandle 
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

/ min-andmax-size follows  the old
  // SkiaGL prefs. First just ensure that the context is not unreasonablyconst  ,, ,
  // small.
  // Validate the size and format.
   (CanCreateaSize aFormat)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    return false;
  }

  int32_t minSize = StaticPrefs::gfx_canvas_accelerated_min_sizeif (  !| mWebgl>(;
  if (aSize.width * java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    return false;
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // Maximum pref allows 2 different options:
  //  <= 0 means unlimited size,
  
   =case java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 42
  ifreturn false;
    return false;
  }

  FlushFromSkia);
}

already_AddRefedjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
    const // The interpretation the min-andmax-sizefollowsfromtheold
    const RefPtr<SharedContextWebgl>
  // Validate the size and format.
  if (!CanCreate(aSize, aFormat))   // Wrap a WebGL texture holding a snapshot with a texture handle. Note that
    return nullptr;
 }

  RefPtr<DrawTargetWebgl// Once it is finally orphaned and used as a texture handle, it must be added
  ifminSize  >:java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
  }

  return dt
}

void
  switch<  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
mStandaloneTextures(handle;
  mTextureHandles.nsertFront(handle);
      if (mSharedContext->IsContextLost()) {
        return nullptr;
      }
      if (!mWebglValid) {
        FlushFromSkia()
      }
}
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      return nullptr;
  }
}

// Wrap a WebGL texture holding a snapshot with a texture handle. Note that
// while the texture is still in use as the backing texture of a framebuffer,
// it's texture memory is not currently tracked with other texture handles.
// Once it is finally orphaned and used as a texture handle, it must be added
// to the resource usage totals.
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 65
    const IntSize& aSize, SurfaceFormat}
  // Ensure there is enough space for the texture.
  size_t usedBytes = BackingTexture::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  PruneTextureMemory(usedBytes, false);
/ if (!dtInit(aSize Format aSharedContext) | !-IsValid(){
  RefPtr<                            (LOCAL_GL_REPEAT;
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
  mStandaloneTextures.push_back(handle)return dtforget(;
  mTextureHandles.insertFront(handle);
  (handle);
  mUsedTextureMemory
  ++java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return handle.forgetalready_AddRefed<TextureHandle SharedContextWebgl:CopySnapshot
}

void SharedContextWebgl::SetTexFilter  if (mWebgl |case NativeSurfaceType:WEBGL_CONTEXT:
  mWebgl->TexParameter_base(
      LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER,
      // If the target
  mWebgl->  // framebuffer texture sin never.
 java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      FloatOrInt
} java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

void
  mWebgl->TexParameter_base(
                            (LOCAL_GL_REPEAT);
Webgl>(LOCAL_GL_TEXTURE_2D,,
                            FloatOrInt(LOCAL_GL_REPEAT));
  SetTexFilter(aTex, aFilter  BindAndInitRenderTex(,// to the resource usage totals.
}

// Copy the contents of the WebGL framebuffer into a WebGL texture.
// Ensure thereenough space                        {uint32_t(aRect), uint32_taRect.))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    const IntRect 
   (!Webgl |   Sjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 36
    return;
  }

  // If the target is going away, then we can just directly reuse the
  
  RefPtrWebGLTexture   mWebgl>java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 16
  if!ex)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    return nullptr;
  }

  // If copying from a non-DT source, we have to bind a scratch framebuffer for
  // reading.
  if (aHandlev  DrawTargetWebglAjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 63
    BindScratchFramebuffer(:mTargetaTarget,
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // Create a texture to hold the copy
  BindAndInitRenderTex(tex, SurfaceFormat::B8G8R8A8, aRect.Size());
  // Copy the framebuffer into the texture
(LOCAL_GL_TEXTURE_2D 0  mWebgl>TexParameter_base(
                       {uint32_t(  mTarget-mSharedContext->etClipRectmClipAARect);

        FloatOrInt(aFilte?LOCAL_GL_LINEAR: )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      ?-):-)
  already_AddRefed<java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
      WrapSnapshot(aRect.Size(), java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1

  // Restore the actual framebuffer after reading is done.already_AddRefed< :(
  if (aHandle java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    RestoreCurrentTarget
  }

  return result;
}

inline::(
    *if !|>java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 43
     (,
      mClipAARect(aTarget()
      (aTarget-mSharedContext->mLastClipMask) {

inline DrawTargetWebgl::AutoRestoreContext::~java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 19
  return ;
  if (mLastClipMask) {
    mTarget->bool DrawTargetWebgl:EnsureDataSnapshotif (aHandle)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }
  mTarget->  // If there is already
}

// Utility method to install the target before copying a snapshot.
:(
    const IntRect& aRect) {
  t)
         (;
    return }
  }
  mSharedContext>a)
}

bool DrawTargetWebgl:SurfaceFormat// Skia snapshots are safe to pass around.
   mjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 80
}

bool DrawTargetWebgl:PrepareSkia( java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  if !) {
    ReadIntoSkia(
  } elseSourceSurface java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 61
    FlattenSkia();
  }
  return mSkiaValid;
}

 DrawTargetWebgl::
  // If there is already a data snapshot, there is nothing to do. If there is a
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   Skia DTjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 return HasDataSnapshotjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 67
         PrepareSkia
}

void>// same WebGL context,  itis todirectly // we may be exporting to another thread and require a data

// Borrow a snapshot that may be used by another thread for composition. Only
// Skia snapshots are safe to pass around.
lready_AddRefed>DrawTargetWebgl:(
  PrepareSkia();
  return mSkia->const IntRect& aRect{
}

already_AddRefed<SourceSurface> DrawTargetWebgl::Snapshot() {
   return GetDataSnapshot(); )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  if (mSkiaValid) {
    return GetDataSnapshot();
  }

  // There's no valid Skia snapshot, so we need to get one from the WebGL
  // context.
  if (!mSnapshot) {
    // Create a copy-on-write reference to this target. to this target.
    mSnapshot = new SourceSurfaceWebgl(this);
  }
  return do_AddRef(mSnapshot);
}

// If we need to provide a snapshot for another DrawTargetWebgl that shares the
// same WebGL context, then it is safe to directly return a snapshot. Otherwise,
// we may be exporting to another thread and require a data snapshot.
already_AddRefed<    FlattenSkia();
    DrawTarget* aTarget) {
  if (aTarget && aTarget->GetBackendType() =  // If reading into a new texture, we have to bind it to a scratch framebuffer
      static_cast<DrawTargetWebgl
          mSharedContext) {
    return Snapshot();
       (aBuffer &mCurrentTarget &!TargetHandle&
  return GetDataSnapshot();
}

// Read from the WebGL context into a buffer, either a memory buffer or a PBO.
// This handles both swizzling BGRA to RGBA and flipping the image.
bool SharedContextWebgl::ReadInto(    SkPixmap((aBounds.Size(), aFormat), aDstData, aDstStride)
                                  aFormat,const IntRect&         .(IsOpaque(aFormat) ? SK_ColorBLACK : SK_ColorTRANSPARENT);
                                  TextureHandle* aHandle,
                                  const 
  MOZ_ASSERT(aFormat =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             aFormat == SurfaceFormat::B8G8R8X8 ||
             aFormatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Skia snapshots are safe to pass around.
  // for reading.
  dle){
    BindScratchFramebuffer(aHandle, false);
  } else if (!aBuffer && mCurrentTarget && !mTargetHandle &&
                 mWebgl->ReadPixelsPbo-ReadPixelsPbodesc,0)  PrepareSkia);
    / If reading from a target that is still clear, then avoid the readback by
    // just clearing the data.
    SkPixmapRangejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        .erase(sOpaqueaFormat)?SK_ColorBLACK :SK_ColorTRANSPARENT;
    return true;
  }

  webgl::eadPixelsDesc desc;
  desc.srcOffset = *ivec2  }
descsize=*vec2::FromSize(aBounds);
  desc.packState.rowLength = 
  if (aBuffer) {
    mWebgl->BindBuffer  if (java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
    mWebgl->ReadPixelsPbo(desc, 0);
    mWebgl-BindBuffer(LOCAL_GL_PIXEL_PACK_BUFFER, 0);
  } elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    Range<int8_t>  ={aDstData// surface.
    mWebgl-ReadPixelsInto(, range)
  }

 Restorethe  framebufferafterreadingis .

    ();
  }

  return true;
}

java.lang.StringIndexOutOfBoundsException: Range [34, 16) out of bounds for length 69
andle ,*aData (aTarget && aTarget->GetBackendType() == BackendType
  // Allocate a data surface, map it, and read from the WebGL context into the
  // surface.
  SurfaceFormat format = SurfaceFormat::UNKNOWN;
  IntRect ;
      bounds.}
    format = aHandle->GetFormat: Factory::(bounds.  return GetDataSnapshot(;
        =aHandle-GetBounds(;
  } else {
         ;
      return nullptr;
    }
    format = mCurrentTarget->GetFormat();
    bounds = mCurrentTarget->GetRect();
  }
  RefPtr<DataSourceSurface> surface =
      aData                                       ,) 
                                                       aFormatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            : Factory::CreateDataSourceSurface                                          //
  if (!  // for reading.
    return tAlignedStride16(,BytesPerPixel(java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 16

  :surface:)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  if (!dstMapjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                                      format, bounds, aHandle)) {
    ;
  }
  return surface.forget();
}

static inline Maybe<  desc.srcOffset = *ivec2:: )
                                          .rowLength      returnnullptr;
  return GetAlignedStride<16 )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}

java.lang.StringIndexOutOfBoundsException: Range [48, 16) out of bounds for length 70
    SourceSurfaceWebgl* aOwner,    -ReadPixelsInto(  (.(){
  // Allocate a PBO, and read from the WebGL context into it.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  IntRect bounds;
) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   format =-GetFormat(;
    bounds  aHandle-GetBounds();
  } else {
    if (!mCurrentTarget) {
      return      ::();
      if    Allocate a data surface, map it, and read from the WebGL context into the
    format = mCurrentTarget->GetFormat();
    bounds = mCurrentTarget-  RefPtr<>pbo =mWebgl->reateBuffer(;
  }
autopboStride  GetPBOStride(bounds.width,bounds=aHandle-GetBounds();
  if (pboStride.isNothing()) {
    return nullptr;
  }
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 3
      (pboStride.(, bounds.)
  if (!bufSize) {
    return nullptr;
  }

  // If the PBO is too large to fit within the memory limit by itself, then
  // don't try to use a PBO.
 size_t maxPBOMemory =
      StaticPrefs  if (!ReadInto(nullptr, pboStride.value(), format, bounds, aHandle, pbo)) {
  f(bufSize> java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    return nullptr;if (! java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  RefPtrWebGLBuffer>pbo = -CreateBuffer(;
  if (!pbo) {
    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  mWebgl->BindBuffer(LOCAL_GL_PIXEL_PACK_BUFFER, pbo);
   surface.(;
                                           LOCAL_GL_STREAM_READ);
  mWebgl->static inline <int32_t/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 76
  if (eadInto(ullptr pboStride.alue) format bounds,aHandle,pbo)){
    return nullptr;
  }

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Range [28, 15) out of bounds for length 37
//upSourceSurfaceWebgl* aOwner,extureHandle* {
  // which can be used to cover the latency of the readback for the new PBO.
  ClearSnapshotPBOs(already_AddRefed<DataSourceSurfaceR(

   +=bufSize;
  mSnapshotPBOs.emplace_back(aOwner);
  return pbo.forget();
}

already_AddRefed<DataSourceSurface> SharedContextWebglelse 
    const RefPtr<WebGLBuffer>&aBuffer SurfaceFormat  aFormat,
    java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 60
  -GetRect)
  // a new data surface and copy the PBO's data into the data surface.}
  auto pboStride = GetPBOStride(aSize      aData ? aStride :pboStride..value() aSize.height)
  if(boStride.isNothing) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    return nullptr;
  }
  size_t       ?:(aData   }
      ?aStride:pboStride bufSize java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  if (!bufSize) {
    return nullptr;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (!urface){
      aData ? Factory::java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3
                                                       aFormat)
            : Factory::CreateDataSourceSurfaceWithStridejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 27
                                                         pboStride.valuesize_t maxPBOMemory
  if(surface)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    return nullptr;
  }
 :ScopedMap dstMapurface DataSourceSurface:WRITE);
  if (!dstMap.IsMapped()) {
    return nullptr;
  }
  BindBuffer(OCAL_GL_PIXEL_PACK_BUFFER,aBuffer)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  Range<uint8_t> range = {dstMap.  >(, 0;
  bool success = mWebgl-  successdBuffer, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      LOCAL_GL_PIXEL_PACK_BUFFER, 0, range, }
      BytesPerPixel(aFormat)   nullptr;
      dstMap.GetStride());
  mWebglif(ReadInto(nullptr:(
  ifreturn nullptrjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    return surface.forget();
  }
  return nullptr;
}

void   size =aOwner-
  SourceSurfaceWebgl* ClearSnapshotPBOs(maxPBOMemory -:in(bufSize,maxPBOMemory);
  RefPtr<WebGLBuffer>
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
  IntSize java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  SurfaceFormat format = aOwner->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 26
  size_t bufSize =0;
  if (auto pboStride = GetPBOStride(size.width, format))
    bufSize= java.lang.StringIndexOutOfBoundsException: Range [70, 32) out of bounds for length 70
  }
  } ){
  // usage from the queue.
  if (mSnapshotPBOs.empty()) {
    mUsedSnapshotPBOMemory = 0;
  } else       aData
mUsedSnapshotPBOMemory -= std::min(mUsedSnapshotPBOMemory, bufSize);
  }
}

 :ClearSnapshotPBOssize_t
  // Force any pending readback PBOs to convert to actual data.! |mUsedSnapshotPBOMemory>)){
while                     aFormatjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 63
         (!aMaxMemory || mUsedSnapshotPBOMemory > aMaxMemory)) {
    RefPtrmSnapshotPBOs.pop_front
    .pop_front(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    if (snapshot) {
      snapshot->  if (.(DataSourceSurface:S surface, DataSourceSurface:)
    }
  }
  if(SnapshotPBOs.empty()) {
    mUsedSnapshotPBOMemory = 0
  }
}

// Utility method to install the target before reading a snapshot.
 (*  aDstStride{
  if (!PrepareContext(false     false OCAL_GL_PIXEL_PACK_BUFFER ,,, .height,
    return false;
  }

  CAL_GL_PIXEL_PACK_BUFFER,0;
}

// Utility method to install the target before reading a snapshot.
return surface.forget();
    uint8_t* aData, int32_t aStride) {
AutoRestoreContextrestore  ;
  if (!PrepareContext(false)) {
    
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  mProfileOnReadback()
  return mSharedContext->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
}

   -IntSizesize  aOwner-java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 35
    SourceSurfaceWebgl* if (auto pboStride = GetPBOStriwidth, already_AddRefed<WebGLBuffer> DrawTargetWebgl::ReadSnapsho
  AutoRestoreContext restore(this);
  if (!PrepareContext(false)) {
    if (!PrepareContext(false)) {
  }
mProfile.nReadback);
returnmSharedContext->eadSnapshotIntoPBO(aOwner);
}

already_AddRefed<SourceSurface> DrawTargetWebgl::GetBackingSurface() {
  return Snapshot();
}

void DrawTargetWebgl::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
  mSkia->DetachAllSnapshots();
  ClearSnapshot();
}

// Prepare the framebuffer for accelerated drawing. Any cached snapshots will
// be invalidated if not detached and copied here. Ensure the WebGL
// framebuffer's contents are updated if still somehow stored in the Skia
// framebuffer.
bool DrawTargetWebgl::MarkChanged() {
  if (Snapshot {
    // Try to copy the target into a new texture if possible.
    ClearSnapshot(true, true)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
  if (!mWebglValid && !FlushFromSkia}
    true )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
  mSkiaValid =
  }
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
}

voidDrawTargetWebgl::MarkSkiaChanged(   truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  ;
    java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 19
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
if(ReadIntoSkia() {
      // Signal that we've hit a complete software fallback.
      mProfile.// Utility method to install the target before reading a already_AddRefed<DataSourceSurface> DrawTargetWebgl::ReadSnapshot(){
    }
  }if (&&}
    FlattenSkia();
  }
  mWebglValid = false;
  mIsClear = false;
}

// Whether a given composition operator is associative and thus allows drawing
// into a separate layer that can be later composited back into the WebGL
// context.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mSkia--java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 30
    case// Layering is only supported for the default source-over composition op.
            return true;
      return true// be invalidated if not detached and copied here. Ensure the WebGL
    default// framebuffer.
       falsefalse}
  }
}

void DrawTargetWebgl     (SupportsLayering) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if (  =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    mProfilejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 27
      // If the Skia context needs initialization, clear it and enable layering.
      mSkia-java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 36
      if (mWebglValid) {
        mProfile.  } else  !mSkiaValid later bymaking  layerbackground isfilled
 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        mSkiaLayerClear =)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        mSkia->DetachAllSnapshots();
        if (java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
          java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
          // with opaque alpha values if necessary.
             mSkiaNoClip->illRect( later  into java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 11
                                DrawOptions(1// The Options.mCompositionOp) {
        } else {
          ->earRect(java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 63
        }
      }
   
    // The WebGL context is no longer up-to-date.
    mWebglValid = false;
    mIsClear = false
  } else {
    // For other composition ops, just overwrite the Skia data. t;
    MarkSkiaChanged)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   MarkSkiaChanged();
}

java.lang.StringIndexOutOfBoundsException: Range [30, 4) out of bounds for length 63
                                         // Avoid blending later by m
                               IntPoint* aOrigin) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (mSkiaValid && !mSkiaLayer) {
    MarkSkiaChanged();
    return if (mSkiaValid& !mSkiaLayer){
  }
  return false;
}

void DrawTargetWebgl::ReleaseBits(uint8_t* aData) {
  // Can only access pixels if there is valid, flattened Skia data.
  if (mSkiaValid && !mSkiaLayer) {
    mSkia->ReleaseBits(aData);
  }
}

// Format is x, y, alpha
static const float kRectVertexData[} else {
                                          1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// Orphans the contents of the path vertex buffer. The beginning of the buffer
// always contains data for a simple rectangle draw to avoid needing to switch
// buffers.
void SharedContextWebgl::ResetPathVertexBuffer() {
  if(mPathVertexBuffer) java.lang.StringIndexOutOfBoundsException: Range [26, 22) out of bounds for length 22
    
    returnreturn mSkia-LockBits(aData, aSize  size_t oldCapacity =mPathVertexBuffer->ByteLength();
  }

  size_t oldCapacity = mPathVertexBuffer->ByteLength();
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

  mWebgl
  mWebgl->UninitializedBufferData_SizeOnly(       java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      LOCAL_GL_ARRAY_BUFFER,
     ::(size_t(PathVertexCapacity), sizeof(kRectVertexData)),
      LOCAL_GL_DYNAMIC_DRAW);
  // Format is x, y, alpha
                        (const uint8_t*)kRectVertexData);
  mPathVertexOffset = sizeof(kRectVertexData);

  size_t newCapacity = mPathVertexBuffer->AddUntrackedTextureMemory(newCapacity);
  if (// Orphans the contents of the path vertex buffer. The beginning of the buffer
    AddUntrackedTextureMemory(newCapacity);
   buffers.
    ty SharedContextWebgl::ResetPathVertexBuffer(){
    mPathVertexOffset = 0  if (java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 3
  }

  if (mWGROutputBuffer &&
(oldCapacity = mPathVertexBuffer->ByteLength();
    RemoveHeapData(RemoveUntrackedTextureMemory;mjava.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 43
    mWGROutputBuffer = nullptr)   (PathVertexCapacity > 0 && !mWGROutputBuffer) {if(PathVertexCapacity) {
  }

  if (mPathVertexCapacity > 0 && !mWGROutputBufferfallible        cnstuint8_t)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    mWGROutputBuffer.reset(new (
         java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 3
    AddHeapData(mWGROutputBuffer.get  if
  }// Sigma below which contribution of neighbor pixels is visually insignificant.
}

// Sigma below which contribution of neighbor pixels is visually insignificant.
#define BLUR_ACCEL_SIGMA_MIN 0.27f
// Maximum blur sigma allowed by shadows and filters currently.
#define BLUR_ACCEL_SIGMA_MAX 100
#define (sigma) if (WGROutputBuffer&&
#define BLUR_ACCEL_RADIUS_MAX (3 * BLUR_ACCEL_SIGMA_MAX)

// Threshold for when to downscale blur inputs.
#define BLUR_ACCEL_DOWNSCALE_SIGMA    RemoveHeapData(mWGROutputBuffer.get();
#define BLUR_ACCEL_DOWNSCALE_SIZE 32
// How much to downscale blur inputs.
#define BLUR_ACCEL_DOWNSCALE_ITERS  

// Attempts to create all shaders and resources to be used for drawing commands.
// Returns whether or not this succeeded.
bool// How much to downscale blur inputs.
  if (!mPathVertexArray) {
    ();
  }
  if (!mPathVertexBuffer) {
    mPathVertexBuffer = mWebgl->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
    AddUntrackedTextureMemorymPathVertexBuffer)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
mWebgl-java.lang.StringIndexOutOfBoundsException: Range [26, 7) out of bounds for length 63
    ResetPathVertexBuffer();
   mWebgl->EnableVertexAttribArray(#efine BLUR_ACCEL_RADIUS_MAX (  )

    :VertAttribPointerDescattribDesc;
    attribDesc.channels = 3;
    attribDesc.type = LOCAL_GL_FLOAT
    attribDesc.ormalized = false;
    mWebgl->VertexAttribPointer(    attribDesc.channels = 3;
  }
  if (!mSolidProgram) {
java.lang.StringIndexOutOfBoundsException: Range [25, 14) out of bounds for length 34
    // both the scale and orientation. The scale is then used to extrude the
    // rectangle outward by 1 screen-space pixel to account for the AA region.
    // The distance to the rectangle edges is passed to the fragment shader inmPathVertexArrayget)
    // an interpolant, biased by 0.5 so it represents the desired coverage. The
    // minimum coverage is then chosen by the fragment shader to use as an AA>0;
    // coverage value to modulate the color.
    .  3;
        "attribute     // an interpolant,
        "uniform vec2 u_transform[3];\n"
        "uniform vec2 u_viewport;\n"
        "uniform vec4 u_clipbounds;
        "uniform float u_aa;\auto vsSource =
        "varying vec2 v_cliptc;\n"
        "varying vec4 v_clipdist;\n"
        " vec4 v_dist;\java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        "varying float ;\n""
        "void main() {\n"
         scale vjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 69
        "                     dot(u_transform[1], u_transform[1]));    / minimum thenchosen thefragmentshader        "uniform float u_aa;\n"
        "   vec2 invScale = u_aa /java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        "   scale *= invScale;\varying"attributevec3 ;njava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        "   vec2 extrude = a_vertex.xy +\n"
        "                  invScale "                    v   java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 32
         java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 33
        "                 u_transform[1] * extrude.y +\n"
        "u_transform[2;n"
        ""   vec2 extrudeScale;n
        "   v_cliptc = vertex / u_viewport;"                 invScale       extrude=y+java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        "v_clipdist =vec4(ertex-  u_clipbounds.,n"
                             u_clipbounds. -vertex)\n"
        "                        java.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 44
        "   v_dist = vec4(extrude, 1.0 - extrude) * scale.xyxy + 0.5 + noAA;\n"
        "   v_alpha = min(a_vertex.z,\n"
        "                (cale., .)*min(cale,1. +noAA;njava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        "\"
    auto"   float noAA= 1.-u_aa\java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        "precision mediump float;\n"
        "uniform         "            scalexjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        "uniformu_clipmask;"
        "varying highp vec2 v_cliptc;\n"
        "uniformvec4;\n"
        "varying vec4 v_dist;\n"
        "float \"
        "u          java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 40
        "   float clip = texture2D(u_clipmask, v_cliptc).java.lang.StringIndexOutOfBoundsException: Range [8, 58) out of bounds for length 36
        "   vec4 dist"varying  vec4 dist java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 51
         . =min("float =clamp(in.,y 0,v_alpha)n"
        "   float aa = clamp(min        void =clip java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 50
    java.lang.StringIndexOutOfBoundsException: Range [76, 74) out of bounds for length 76
        "\""vec4dist _dist _);java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
ateShaderjava.lang.StringIndexOutOfBoundsException: Range [76, 74) out of bounds for length 76
    (;
    mWebgl->CompileShader
    if    <WebGLShader>vsId  mWebgl-CreateShader(LOCAL_GL_VERTEX_SHADER;
      return false;
    }
    RefPtr<WebGLShader> fsId = mWebgl->     (>.){
    mWebgl->ShaderSource(*fsId      returnjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    mWebgl->    RefPtr<WebGLShader<(java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 48
    mWebgl-java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 62
     return*fsId)
    }
    mSolidProgram = mWebgl->CreateProgram();
    ->*mSolidProgram,;
    return;
    mWebgl->BindAttribLocation(*mSolidProgram = mWebgl->CreateProgram
     =(mSolidProgram _java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 76
   if(mWebgl- =java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 78
      return mWebgl->BindAtt*,0,"a_vertex";
    }
      ,java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 76
    mSolidProgramAA  GetUniformLocation(SolidProgram u_aa";
    mSolidProgramTransform = GetUniformLocation(mSolidProgram, "! | java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    mSolidProgramColor returnfalse;
    mSolidProgramAA=GetUniformLocation(mSolidProgram, "u_aa");
    mSolidProgramClipBounds = GetUniformLocation(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 78
    if  =, <nt32_t,,1>};
        !mSolidProgramColor || !mSolidProgramClipMask ||
        !mSolidProgramClipBounds) {
       false;
    }
    mWebgl->UseProgram(mSolidProgram);
    java.lang.StringIndexOutOfBoundsException: Range [28, 15) out of bounds for length 75
  }

  if (!mImageProgram) {
    uto java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 19
        "attribute vec3 a_vertex;\n"
        "uniform vec2 u_viewport;\n"
        "niform vec4 java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 40
        "uniform float u_aa;n"
        "uniform vec2 u_transform[3];\n"
        ujava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 40
        " v_cliptc;n"
        "varying vec2 v_texcoord;\n"
       java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 36
        "        "void ma() {     vsSource =
        "varying float v_alpha;\n"
"main( {\"
        "   vec2 scale = vec2(dot(u_transform[0]"niform        vec2 =u_aa * scale +10e)\"
 dot]u_transform[)\"
        "   vec2 invScale = u_aa * inversesqrt(scale + 1.0e- "   extrude =a_vertex.xy +\uniformvec2 u_texmatrix3;n"
        "   scale *= invScale;\                           * . *        "                  invScale * (2.0 * a_vertex
        ""vec4\"
"varying v_alpha;t*  2.  u_viewport  1.0 0. .);"
        "   vec2 vertex = u_transform[0] * extrude.x +\n"
        "                 u_transform[1] * extrude.y +\n"
        "                 u_transform[2];\n"
        "   gl_Position         dot[]1))\java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        "     == vertex /u_viewport;\n"
        "   v_clipdist = vec4(vertex - u_clipbounds.xy,\n"
           vec2  a_vertex.y +n"
        "   v_texcoord = u_texmatrix[0] * extrude.        "                  invScale * (2.0 * a_vertxy-                2;njava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        "                u_texmatrix[1] * extrude.y +\n"
        "                u_texmatrix[2;\n        minscalex 1. * min(.,1.)+ )\n"
        "   float noAA = 1.0 - u_aa;\n"
        "   v_dist = vec4(extrude, 1.0 - extrude) * scale.xyxy + 0.5 + noAA;\n"
        "   v_alpha =  float;\n"
        "                 min(scale.x, 1.0) * min(scale.y, 1.0) + noAA);\n"
        "\n"
    auto fsSource =
         float\"
        "uniform vec4 u_texbounds;\n"
        "uniform vec4 u_color;\n"
        "niform  ;java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        uniform sampler2D u_sampler;"
        "uniform sampler2D u_clipmask;\n"
        "varying highp vec2 v_cliptc;\n"
        "varying highp vec2 v_texcoord;\n"
        "java.lang.StringIndexOutOfBoundsException: Range [32, 16) out of bounds for length 36
 ;n"
        "v_alpha" ;"
        "void main() {\n"
        "   highp vec2           highp vec2 tc = clampv_,u_texboundsxy,\n"
        "                         u_texbounds.java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 19
        "   vec4 image = texture2D(u_sampler, tc);\n"
           float clip =texture2D(u_clipmask, v_cliptc).\n"
        "   vec4 dist = min(v_dist,"   vec4dist =min(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 51
        "   dist.xy = min(dist.xy, dist.zw);\n"
        ((x,distjava.lang.StringIndexOutOfBoundsException: Range [46, 40) out of bounds for length 40
        "   gl_FragColor = clip"   gl_FragColor =clip *          v  vec2 v_cliptc;njava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        "mix(image, imagerrrr u_swizzle);n"
        "}\n";
    RefPtr<WebGLShader\n"
    "vec4v_dist;\"
    mWebgl->CompileShader(*vsId);
     *java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 51
      return false;
    
    return ;
    mWebgl->ShaderSource(*fsId, fsSource);
    mWebgl->CompileShader(*fsId);
    if (!mWebgl->GetCompileResult(*fsId).success) {
       java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    mImageProgram   xy
    mWebgl->AttachShader(*mImageProgram, *vsId);
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 48
( fsId;
    mWebgl->LinkProgram(*mImageProgram);
    if (!mWebgl->GetLinkResult(*mImageProgram).success) {
      return false}n";
    }
    mImageProgramViewport<WebGLShader>vsId= }
    mImageProgramAA =    mWebgl-ShaderSource     GetUniformLocationmImageProgram, u_viewport")
     mWebgl->CompileShader(*vsId);
    mImageProgramTexMatrix = GetUniformLocation    if !-GetCompileResult(*vsId).mImageProgramTransform = GetUniformLocation
    mImageProgramTexBoundsmImageProgramTexMatrix =GetUniformLocation(mImageProgram, "u_texmatrix");
    mImageProgramSwizzle = GetUniformLocation(mImageProgram, "u_swizzle");
    mImageProgramColor =    mImageProgramTexBounds = RefPtr<WebGLShader> fsId = mWebgl>CreateShader();
    mImageProgramSampler = GetUniformLocationmImageProgramSwizzle = GetUniformLocation(mImageProgram, "u_swizzle");
    mImageProgramClipMask =GetUniformLocation(ImageProgram,mWebgl>*);
    mImageProgramClipBounds = GetUniformLocation(mImageProgram, "if !etCompileResult*fsId).success){
    if(mImageProgramViewport | ! false
        !mImageProgramTexMatrix || !mImageProgramTexBounds ||
        !mImageProgramSwizzle |!mImageProgramColor || !mImageProgramSampler ||
        !mImageProgramClipMask || !mImageProgramClipBounds) {
      return false;
    }
    mWebgl->UseProgram(mImageProgram);
    >(*ImageProgram, 0 ")java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    UniformData(LOCAL_GL_INT, mImageProgramClipMask, Array<int32_t, 1>{1});
  }
  if (!mBlurProgram) {
    auto vsSource =
        ""#        
        java.lang.StringIndexOutOfBoundsException: Range [22, 16) out of bounds for length 36
        " !java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 22
        u vec4=java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 78
        uniformvec4        "uniform vec2 u_viewport;njava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
"vec4java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 37
        "uniform vec2 u_offsetscale;\n"
        "uniform float u_sigma;\n"
        "in vec3 a_vertex;\n"
        "out vec2 v_cliptc;\n"
        "out vec2 v_texcoord;\n"
        " vec4v_texboundsnjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        "outvec4 v_clipdist"utnjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 30
        "flat  !| !java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 33
        "flat return false;
        vcalculate_gauss_coeffsf vec2 v_gauss_coeffs;n
        "  v_gauss_coeffsUniformData(LOCAL_GL_INT,mImageProgramSampler,Array<nt32_t,1{})
        "                        exp(-0.5 / (sigma * sigma)));\n"
        ""  v_gauss_coeffs = vec2(10/ 
        "                           v_gauss_coeffs.y * v_gauss_coeffs.y);\n"
        " float gauss_coeff_totalauto vsSource 
        "version 300 es\n"
        "    gauss_coeff.xy *= gauss_coeff.yz;\n"
        "    float gauss_coeff_subtotal = gauss_coeff.x;\n"
        "    gauss_coeff.xy *= gauss_coeff.yz;\n"
        "    gauss_coeff_subtotal += gauss_coeff.x;\n"
        "    gauss_coeff_total += 2.0 * java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 57
        "  }\n"
        "  v_gauss_coeffs.x /= gauss_coeff_total;\n"
        "}"
        v ){n"
        "  vec2 .xy        "java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
        "out vec2           java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 64
        "  v_cliptc = vertex        out    java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 52
        "  v_clipdist = vec4(vertex - java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 13
                            u_clipbounds.w -vertex);njava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
          java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 73
          texbounds = vec4(v_texcoord - u_texbounds.xy,\n""v_cliptc  /u_viewport\java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        "                        v_gauss_coeffsvec21.  (2*.14159265))\"
        "  v_texbounds = "                        exp0./(* sigma);\"
             " java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 53
        "     (exbounds.yw / u_offsetscale., .xz;njava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
         floatgauss_coeff_total = "                       .  java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 65
        "  calculate_gauss_coeffs(u_sigma);\n"
        "}\n";
    auto"          x= " MOZ_STRINGIFYBLUR_ACCEL_RADIUSu_sigma)) ;n
        \"
        "precision mediump"}n";
        "niform vec4 u_color;\n"
        "niformfloat u_swizzle;\n"
        "uniform highp vec4 u_texbounds;\n"
        "uniform highp vec2 u_offsetscale;\n"
        uniform  sampler2Du_sampler;\n"
        "uniform sampler2D u_clipmask;\n"
        "in highp vec2 v_cliptc;\n"
        "        "}njava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        "  "niformvec2u_offsetscale;n"
        "in vec4 v_clipdist;\n"
"flat in vec2v_gauss_coeffs;\n"
        "flat in ivec2 v_support;\n"
        "outcliptc=  vertex /_viewport;\
        "void main() {\        "  v_clipdist = ( "inhighp vec2 v_texcoord;"
        "vec3 gauss_coeff = vec3(v_gauss_coeffs                     u_clipbounds.- vertex);\n"
        "                         v_gauss_coeffs..y  v_gauss_coeffs.)\n"
        "  bvec4 inside = greaterThanEqual(v_texbounds, vec4(0.0));\n"
       vec4  =textureu_sampler,v_texcoord \"
        "                   (all(inside.xy) ? gauss_coeff.x : 0.0);\n"
        "  int support = min(v_support.x,\n"
"" MOZ_STRINGIFY(BLUR_ACCEL_RADIUS_MAX) ");\n"
        "  for (int i = 1; i <= support; i += 2) {\n"
        "    gauss_coeff.xy *= gauss_coeff.yz;\n"
        "    float gauss_coeff_subtotal = gauss_coeff.x;\n"
        "   gauss_coeff.xy  *=gauss_coeff.;n"
        "    gauss_coeff_subtotal += gauss_coeff.x;\n"
        "float gauss_ratio = gauss_coeffauto fsSource =
        "    vec4 curbounds = v_texbounds.xyxy + vec4(-1.0, 1.0, 1.0, -1.0) * float(java.lang.StringIndexOutOfBoundsException: Range [0, 85) out of bounds for length 70
=java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 33
             =java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
        "    vec2 weights0 =\n"
        "      (all(inside0.xy) ? vec2( ((nside0.xy)?vec2(1. auss_ratio)  vec2(uss_ratio, 1.0))\"
        "        (all(inside0"niformhighp vec2=gauss_coeff.;\"
        "    vec2         "uniform sampler2Dgauss_coeff_subtotal=gauss_coeff.;java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        "      (all(inside1.xy) ?java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        "        (all("    float gauss_ratio"nhighp v_texcoord;\n
        "    vec2 tc0  "vec4 curboundsin vec4java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 38
        "    vec2 tc1 = v_texcoord + u_offsetscale * (float(i) + weights1.y);\n"
        "    avg_color += gauss_coeff_subtotal * (\n"
      (u_sampler, tc0) * weights0.x +\n"
        "      texture(u_sampler, tc1) * weights1.x);\n"
        "  }\n"
        ).r\"
        "  vec2 dist =        all(.zw  0 "  vec3 gauss_coeff = vec3(v_gauss_coeffs,\n
        "float  =clampmin(ist. dist.y,00  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 70
          out_FragColor clip * *    tc1 +u_offsetscale  floati +weights1.)\"
        "                  mix(avg_color, avg_color.rrrr, java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 56
        "}\n";
    RefPtr<  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 59
    mWebgl->ShaderSource(*vsId, vsSource);
    mWebgl->CompileShader(*"  for (int i = 1; i  support;  clip**i.zw)n
                gauss_coeffxy * gauss_coeff.yz\java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      returnfalsejava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 19
    }. *g;n"
    RefPtr<WebGLShader> fsId = mWebgl->CreateShader(LOCAL_GL_FRAGMENT_SHADER);
    mWebgl->ShaderSource(*fsId, fsSource);
    mWebgl-CompileShader(fsId;
    if (!mWebgl->GetCompileResult(*fsId).success) {
      return java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 5
    }
  =mWebgl>reateProgram(;
    mWebgl->AttachShader(* (!mWebgl->GetCompileResult.success)bvec4 =greaterThanEqualcurbounds.vec4(00, 0.1.0 10)\"
    mWebgl->AttachShader"     (all(inside0.xy)java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
    mWebgl(.)?.  java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 58
    mWebgl-      (all(    -(mBlurProgram0,v";
    if(*)"        (nside1.)0.  gauss_ratio;\"
      return false;
    }
    mBlurProgramViewport = GetUniformLocation(mBlurProgram, "u_viewport");
    mBlurProgramTransform = GetUniformLocation(mBlurProgram            rProgramV =GetUniformLocation(,""java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    mBlurProgramTexMatrix = GetUniformLocation(mBlurProgram, "u_texmatrix");
    mBlurProgramTexBounds = GetUniformLocation(mBlurProgram, "u_texbounds");
    mBlurProgramOffsetScale = GetUniformLocation(mBlurProgram, "u_offsetscale");
    mBlurProgramSigma=              java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 56
ationm,"c";
    mBlurProgramSwizzle =java.lang.StringIndexOutOfBoundsException: Range [26, 23) out of bounds for length 72
    =(BlurProgram,"java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 72
    mBlurProgramClipMask = GetUniformLocation(mBlurProgram, "u_clipmask");
    mBlurProgramClipBounds        "    = java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 59
    if (!mBlurProgramViewport || !mBlurProgramTransform ||
        !mBlurProgramTexMatrix || !mBlurProgramTexBounds ||
        !mBlurProgramOffsetScale                  mix(vg_colorreturnfalse;
        !mBlurProgramSwizzle-java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 37
        java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 34
      return mWebgl-ShaderSource(vsId vsSource
    }
    mWebgl->UseProgram(mBlurProgram);
    UniformDataLOCAL_GL_INT,java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    u ;\
  }
  if (!mFilterProgram) {
autovaryingjava.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 36
        "uniform vec2 u_viewport;\n"
        "uniform vec4 u_clipbounds;\n"
  ;
        "uniform vec4 u_texmatrix;\n"
        "\
        "varying vec2 v_cliptc;\n"
        "varying vec2 v_texcoord;\n"
        "v_clipdist      =java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 43
        " ( \njava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        "  vec2 vertex = u_transform.xy * a_vertex.xy + u_transform.zw;\n"
        "  gl_Position = vec4(vertex "mediumpfloat\njava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        "  v_cliptc = vertex / u_viewport;\n"
        "  v_clipdist = vec4(vertex - u_clipbounds.xy,\n"
        "                    u_clipbounds.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 19
        " = xy * a_vertex. +u_texmatrixzw; mBlurProgramViewport GetUniformLocationmBlurProgram, "viewport)
        "}\n";
    auto fsSource =
        "precision mediump float;\n"
java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 42
        "uniform mat4 u_colormatrix;\n"
        " vec4        oid({\java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        "uniform sampler2D u_sampler;              u_samplerv:vec400\java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
        "uniform sampler2D u_clipmask;\n"
        "varying highp vec2 v_cliptc;\n"
        "varying highp vec2 v_texcoord;\n"
        " "rgbjava.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 35
        "bool check_bounds(vec2 tc) {\n"
        "  return all(greaterThanEqual(\n"
        "             vec4(tc, u_texbounds.zw), vec4(u_texbounds.xy, tc)));\n"
        "}\n"
        v main) \n"
        "  vec4 color = check_bounds(v_texcoord) ?\n"
              java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 63
 ca00)rgb=a;\        ){
        "  >*java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    rgbcolorn
    vsSource =
        "  vec2 dist = min(v_clipdist.xy, v_clipdist.zw);\n"
        "  float aa = clamp(min(dist.x, dist.y), 0.0, 1.0);\n"
        ""niformvec4 u_clipbounds;n"
        "}\n";
-)
    mWebgl->ShaderSource(*vsId, vsSource);
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 33
    if         attribute vec3 a_vertex;\n"
      return false;
    }
    RefPtr<WebGLShader> fsId = mWebgl->CreateShader(LOCAL_GL_FRAGMENT_SHADER);
    mWebgl->ShaderSource(*fsId, fsSource);
    >ompileShader(fsId)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    if (!mWebgl->GetCompileResult(*fsId).success) {
      return false;
    }
    java.lang.StringIndexOutOfBoundsException: Range [60, 6) out of bounds for length 60
    mWebgl->AttachShader(*mFilterProgram, *vsId);
    >*mFilterProgram *sId;
    mWebgl->BindAttribLocation(*mFilterProgram java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
                        u_clipboundszw  vertexjava.lang.StringIndexOutOfBoundsException: Range [37, 32) out of bounds for length 63
            |mFilterProgramClipMask|
      return false;
    }
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 19
mFilterProgramTransform p float\"
    mFilterProgramTexMatrix = GetUniformLocation(mFilterProgram, "u_texmatrix");
    mFilterProgramTexBounds =GetUniformLocation(, "u_texbounds")java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    mFilterProgramColorMatrix =
        GetUniformLocation(FilterProgram, ""u_colormatrix";
    mFilterProgramColorOffset =
        GetUniformLocation(mFilterProgram, "u_coloroffset");
    mFilterProgramSampler = GetUniformLocation(mFilterProgram, "u_sampler");
    mFilterProgramClipMasktrue
    mFilterProgramClipBounds =
        GetUniformLocation(mFilterProgram, "u_clipbounds");
    if (!mFilterProgramViewport |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 63
        !// Only update scissor state if it actually changes.
        !mFilterProgramSampler rect =aForce&&"arying vec4 v_clipdist;\n"
        !mFilterProgramClipBounds) {
      returnaRect;
    }
    mWebgl->UseProgram(mFilterProgram  return all(greaterThanEqual(\"
UniformData(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 75
    UniformData(LOCAL_GL_INT, mFilterProgramClipMask, Array<int32_t, 1>{1});
  }
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

>(CAL_GL_SCISSOR_TEST {}true
  // Only update scissor state if it actually changes.
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                     ? aRect + mTargetHandle->GetBounds().TopLeft()
                     : aRect;
  if!         .*= color.a\"
    mLastScissor = rect;
    .,ectwidth .)
  }
  if (!mScissorEnabled) {
    mScissorEnabled = true;
    mWebgl->SetEnabled(LOCAL_GL_SCISSOR_TEST, {}, true);
  }
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  if (!aForce && mTargetHandle) mWebgl->CompileShader(*sId;
    EnableScissor(IntRect(IntPoint(), DeviceColor(0.0f, 0.0f, 0.0f, IsOpaque(mFormat1.: .f)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    return;
  }
  if (mScissorEnabled) {
    mScissorEnabled = false;
   -etEnabled({,false;
  }
}

inline ColorPattern DrawTargetWebgl::GetClearPattern() const {
  return// Check if the transformed rect clips to the viewport.
      DeviceColorinline MaybeRect>DrawTargetWebgl:RectClippedToViewport(
}

template <typename R>
inline RectDouble DrawTargetWebgl::TransformDouble(const R& aRect) const {
  return MatrixDouble(java.lang.StringIndexOutOfBoundsException: Range [2, 32) out of bounds for length 3
}

// Check if the transformed rect clips to the viewport.
inline Maybe<Rect> DrawTargetWebgl:mFilterProgramViewport/Ensure the  after ,within it will notround 
    const RectDouble// geometry calculated by the path fallback.
  if (!mTransform.PreservesAxisAlignedRectangles()) {
    return Nothing();
  }

  return Some(NarrowToFloat(aRect.SafeIntersect(RectDouble(GetRect()mFilterProgramColorMatrix =
}

// Ensure that the rect, after transform, is within reasonable precision limits
// such that when transformed and clipped in the shader it will not round bits
// from the mantissa in a way that will diverge in a noticeable way from path
// geometry calculated by the path fallback.
template < >
static inlineFjava.lang.StringIndexOutOfBoundsException: Range [29, 26) out of bounds for length 78
  returnGetUniformLocation(RectDouble  =TransformDouble(Rect)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}

void DrawTargetWebgl::ClearRect(const!FilterProgramColorMatrix |!    // If the rect clips to viewport, just clear
  !FilterProgramSampler|!FilterProgramClipMask|
    // No need to clear anything if the entire framebuffer is already clear.
    return;
  }

  RectDouble xformRect = TransformDouble(aRect);
  bool containsViewport = false;
  if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
/
    // to avoid transform issues.
    containsViewporttrue
    DrawRect(*clippedjava.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 57
             DrawOptions(1.0f, CompositionOp::OP_CLEAR),}
             false);mSkia-ClearRect(Rect);
  }else if(RectInsidePrecisionLimitsxformRect)){
    // If the rect transform won't stress precision, then just use it.
    DrawRect(aRect,GetClearPattern)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
             DrawOptions(1.0f, CompositionOp::OP_CLEAR));
 } else                     :aRectjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    // Otherwise, using the transform in the shader may lead to inaccuracies, so
      if (mLastScissor.static DeviceColor PremultiplyColor(const DeviceColor& aColor,
MarkSkiaChanged)
    mSkia->  return DeviceColor(aColor.*a aColorg*}
  }

//If the clear rectangle encompasses theentire WebGLContext =SharedContext
  // then mark the target as entirely clear.
  if (containsViewport && !ShouldClip    =webgl>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 34
    mIsClear =true
  }
}

static inline DeviceColor PremultiplyColor(const DeviceColor& aColor,
                                           float aAlpha = 1.0f }
   a=aColor. *aAlpha
  return mWebgl->SetEnabled, {,false)
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

// Attempts to create the framebuffer used for drawing and also any relevant
// non-shared resources. Returns whether or not this succeeded.
bool DrawTargetWebgl::CreateFramebuffer() {
  RefPtr<WebGLContext> webgl = mSharedContext->mWebgl;
  if (!mFramebuffer) {
    mFramebuffer >java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 46
  }
  if (!mTex) {
    mTex = webgl->CreateTexture();
    mSharedContext->BindAndInitRenderTex(mTex, SurfaceFormat::java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 27
    webgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER, mFramebuffer);
    webgl::FbAttachInfo attachInfo;
    attachInfo.tex = mTex;
    webgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0,
                              java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 62
.mSize.eight);
    mSharedContext->DisableScissor
    DeviceColor color = PremultiplyColor(GetClearPattern().mColor
    webgl->ClearColor(color.b, color.g, color.r, color.a);
webgl-C(java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 44
    const RectDouble)const java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Range [45, 18) out of bounds for length 52
  }
  return true;
}

void DrawTargetWebgl// entire surface as it is unlikely to be reused. Limit it to the used
                                   surfaceRect= -GetRect()
constaDestination) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  // Intersect the source and destination rectangles with the viewport bounds.
   such that whentransformed and clippedin the shader itwill not round 
      IntRect(aDestination, aSourceRect.Size())  SurfacePattern aSurface / geometry calculatedby the pathfallbackjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    =destRect -  +aSourceRect.TopLeft(;
  if (rcRectNothing)java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 45
    return;
  }

  if (mSkiaValid) {
    if (mSkiaLayer) {
      if (destRect.Containsjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        // If the the destination would override the entire layer, discard the
        // layer.
lse;
      } else if (!IsOpaque(aSurface->GetFormat())) {
        java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        // unintended blending rather than a copy to the destination.
        FlattenSkia();
      }
    } else {
      // If there is no layer, copying is safe. :java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 69
      MarkSkiaChanged)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    }
    mSkia>(aSurface,srcRect  }   xformRect)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    eturn
  }

  IntRect samplingRect;
  if (mSharedContext-java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 27
    // If this data surface completely overwrites the framebuffer, then just
       // copy it to the Skia target.
if (.(GetRect)){
      MarkSkiaChanged(true);
      
      mSkiaNoClip->CopySurface(aSurface mClipChanged true;
      return;mClipStackclear)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

/
   // entire surface as it is unlikely to be reused. Limit it to the used
    // source rectangle instead.
    IntRect surfaceRectaDT-ushClip(clipStack.Path;
    if (!srcRect.IsEqualEdges(surfaceRect)) {
      samplingRect = srcRect.SafeIntersect(surfaceRect) - surfaceRect.TopLeft();
    }
  }

  Matrix matrix = Matrix::Translation(destRect// Attempts to create the framebuffer used for drawing and also any relevant
aSurface,ExtendMode: matrix,
                         :OINT java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 62
DrawRect(ect(estRect) ,DrawOptions1.f,CompositionOp:OP_SOURCE)}
           Nothing() mFramebuffer=webgl-()
}

     DrawOptions&) {
 &-=S)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    // Detect if the path is really just a rect to simplify caching.
    if (Maybe<Rect> DeviceColor color = PremultiplyColor(GetClearPattern().mColor);
      PushClipRect(*rect);
      return;
    }
  }

    >(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 30
kia>ushClip;

  mClipStack.push_back({GetTransform(), Rect                                  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 55
}

void DrawTargetWebgl::PushClipRect(const
  mClipChanged = true; java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 70
  mRefreshClipState=true;
  mSkia->PushClipRect(aRect);

  mClipStack.push_back({GetTransform(), aRect,caseSupportsDrawOptionsStatusjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                               uint32_t java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 21
  mClipChanged = true;
  mRefreshClipState = true;
  >java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 50

   java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 41
    mClipStackpush_back{(, aRects[],false;
  }
}

java.lang.StringIndexOutOfBoundsException: Range [34, 1) out of bounds for length 1
  if (mClipStackmSkia-CopySurfaceaSurface// approximate with WebGL blend modes.
    return;
   

  mClipChanged .){
  mRefreshClipState java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  mSkia->PopClip();

  mClipStack.op_back)
}

bool DrawTargetWebgl::RemoveAllClips() {
  if (mClipStack.empty()) {
    return true;
  }
(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 75
    return
  }
    = true;
  mRefreshClipState = true;
  mClipStack.clear();
  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

bool DrawTargetWebgl:java.lang.StringIndexOutOfBoundsException: Range [55, 36) out of bounds for length 55
  aDT-                        java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    aDT->SetTransform(Type()){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      -(lipStackmPath);
    } else {
  if(aPath   true;
    }
  }
         aybe<rect= aPath->java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 45

  // An existing data snapshot is required for fallback, as we have to avoid
  // trying to touch the WebGL context, which is assumed to be invalid and not
  // suitable for readback.
  java.lang.StringIndexOutOfBoundsException: Range [26, 4) out of bounds for length 26
    if (
      aDT->CopySurface(snapshot, snapshot->GetRect(), gfx::IntPoint(0, 0));
      return  mClipChanged = true;
    }
  }
  return false;
}

enum class SupportsDrawOptionsStatus { No, UnboundedBlend         java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34

// Whether a given composition operator can be mapped to a WebGL blend mode.
static inline         // if supplied, exceed the maxi
     DrawOptions java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  switch (aOptions.mCompositionOp) {
    CompositionOp:
    case CompositionOp::OP_DEST_OVER:
    case CompositionOp::OP_ADD:
    case CompositionOp::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 7
    case CompositionOp::OP_ATOP:
    case CompositionOp::OP_SOURCE:
    case CompositionOp::OP_CLEAR:
    case CompositionOp: RefreshClipState java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    case CompositionOp::OP_SCREEN:
     return SupportsDrawOptionsStatusjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case CompositionOp::OP_IN:
    case CompositionOp:constDrawOptions& ,
    case CompositionOp::OP_DEST_IN:
    case CompositionOp::OP_DEST_ATOP:
      return SupportsDrawOptionsStatus::UnboundedBlend;
    default:
      return SupportsDrawOptionsStatus::No;
  }
}

bool DrawTargetWebgl::SupportsDrawOptions(const DrawOptions& aOptions,
                                            if (aRect.IsEmpty() || mSkia->IsClipEmpty(.IsEmpty)| mSkiaPopClip)
  switch 
    case SupportsDrawOptionsStatus::Yes:
      return true;
    case SupportsDrawOptionsStatus::UnboundedBlend:
       aRect) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        return false;
      }
      if (Maybe<if (mSkia-( 
        if (!clip->IsEmpty() && clip->Contains(GetRect  
          clip = Some(GetRect()java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 27
        }
        Rect clipF(*clip);
        if (aRect.Contains(clipF) || aRect.WithinEpsilonOf(clipF, 1e-3f)) {
          return true;
        }
        return false;
      }
      return false;
    default:// fails, we just fall back to drawing with Skia below.
      return false;
 }}
}

// Whether the composition operator requires multiple blend stages to
// approximate with WebGL blend modes.
uint8_t :java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 12
    const DrawOptions& aOptions, DrawTargetWebgl*           aClipped, aAccelOnly, aForceUpdate, aStrokeOpt
  switch (aOptions.mCompositionOp) {
    case CompositionOp::OP_MULTIPLY:
      return !IsOpaque(aDT ? aDT->GetFormat()
                            WebGL to into  we to 
                                            /
                 ? 2
                 t java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    default:
      return0
  }
}

static inline bool SupportsExtendMode
  switch (aPattern.mExtendMode) {
    case ExtendMode::CLAMP:
      return true;
    case ExtendMode::REPEAT:
    case ExtendMode::REPEAT_X:
    case ExtendMode::
      (!java.lang.StringIndexOutOfBoundsException: Range [44, 40) out of bounds for length 67
           aPattern.mSurface->GetUnderlyingType(// Whether a given composition operator can be mapped to a WebGL blend mode.java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 72
          !aPattern.mSamplingRect.IsEmpty()) {
        return false;
      }
      return true;
    default:
      return false;
  }
}

// Whether a pattern can be mapped to an available WebGL shader.
bool SharedContextWebgl::SupportsPattern(const Pattern& aPattern) {
  switch (aPattern.GetType()) {
    case PatternType::COLOR:
      return true;
    case PatternType::SURFACE: {
      auto surfacePattern::
      if (!SupportsExtendMode(surfacePattern)) {
        return false;
      }
if    :
        // If the surface is already uploaded to a texture, then just use it.
        if (IsCompatibleSurface(surfacePatternbool :SupportsDrawOptions(constDrawOptions aOptions,
          return true;
        }

        IntSize size = surfacePattern.mSurface->GetSize();
        // The maximum size a surface can be before triggering a fallback to
        // software. Bound the maximum surface size by the actual texture size>(aRectaPattern
        // limit.
        int32_t maxSize = int32_t(
            std::min(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 75
                     mMaxTextureSize));
        // Check if either of the surface dimensions or the sampling rect,if(< java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 41
        // if supplied, exceed the maximum.
        if (std::max(size.width>surfacePatternmSurface        
            (if (aRect.Contains(clipF) || aRect.WithinEpsilonOf    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 22
             std: 
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
          return;
        }
      }
      java.lang.StringIndexOutOfBoundsException: Range [18, 12) out of bounds for length 18
    }
    default:
      // Patterns other than colors and surfaces are currently not accelerated.
      return false;
 }
}

bool DrawTargetWebgl::DrawRect(const Rect& aRect, const Pattern& aPattern,
                               const DrawOptions& aOptions,
                               Maybe<DeviceColor> aMaskColor,
RefPtr*,
                               bool aTransformed, bool aClipped,
                               bool aAccelOnly, bool webglSurf->mHandle->GetBackingTexture()->GetWebGLTextu
                               const StrokeOptions* aStrokeOptions) {
  // If there is nothing to draw, then don't draw...
  if (aRect.IsEmpty() || mSkia->IsClipEmpty()) {
    return true;
  }

  // If we're already drawing directly to the WebGL context, then we want to
  // continue to do so. However, if we're drawing into a Skia layer over the        if (aCheckTarget        :
  // WebGL context, then we need to be careful to avoid repeatedly clearing
  // and flushing the layer if we hit a drawing request that can be accelerated
  // in between layered drawing requests, as clearing and flushing the layer
  // can be significantly expensive when repeated. So when a Skia layer is
  // active, if it is possible to continue drawing into the layer, then don't
  // accelerate the drawing request.
  if (mWebglValid || (mSkiaLayer && !mLayerDepth &&
                      (aAccelOnly || !SupportsLayering(aOptions)))       java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    // If we get here, either the WebGL context is being directly drawn to
    // or we are going to flush the Skia layer to it before doing so. The shared
    // context still needs to be claimed and prepared for drawing. If this
   drawing java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 59
if, PrepareContextaClipped)
     // The shared context is claimed and the framebuffer is now valid, so try
      // accelerated drawing.
cel(
          aRect, aPattern, aOptions, aMaskColor, aHandle, aTransformed,
          aClipped,aAccelOnly, aForceUpdate      return true;
    }default:
  }

  
  // it for drawing. The only thing we can do at this point is fall back to
  // drawing with Skia. If the request explicitly requires accelerated drawing,
  // then draw nothing before returning failure.
 !<java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 42
  aetType)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                     aClipped, aStrokeOptions);
  }
  returnfalse
      auto   static_castconst SurfacePattern&(aPattern);

      if (SupportsExtendMode(urfacePattern)) {
                                       const Pattern& aPattern,
                                       
                                       Maybe<DeviceColor>aMaskColor,
                                       bool aTransformed, bool aClipped,
                                       StrokeOptions aStrokeOptions){{
  // Invalidate the WebGL target and prepare the Skia target for drawing.
  MarkSkiaChanged(aOptions);

  if (    // Ensuresourcedata the expectedformat .
    // If transforms are requested, then just translate back to FillRect.
    if (aMaskColor) {
      mSkia->Mask(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 19
    } else
      mSkia->StrokeRect(aRect, aPattern, *aStrokeOptions, aOptions);
    } else {
      mSkia->FillRect(aRect, aPattern, aOptions);
    }
ejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 24
    // If no transform was requested but clipping is still required, then
    // temporarily reset the transform before translating to FillRect.
    mSkia->SetTransform(Matrix(            = --etStride)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    if (aMaskColor) {
      auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
      if (urfacePattern..IsEmpty()      
        mSkia->MaskSurface(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 7
 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      } else {
        mSkia->Mask
      }
    } else if (aStrokeOptions) {
      mSkia->StrokeRect(aRect, aPattern, *aStrokeOptions, aOptions);
    } else {
      mSkia->FillRect(aRect, aPattern, aOptions);
    }
    -SetTransform(Transform)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  } else if (aPattern.GetType() == PatternType::SURFACE) {
    // No transform nor clipping was requested, so it is essentially just a
    // copy.
    auto surfacePattern = static_cast<const SurfacePattern&>aPattern);
    IntRect destRect  RoundedOut(Rect);
    IntRect srcRect =
        destRect - IntPoint::Round(surfacePattern.mMatrix.GetTranslation());
    mSkia->CopySurface(surfacePattern.mSurface, srcRect, destRect.TopLeft());
  } else {
    MOZ_ASSERT(false);
  }
}

inline MOZ_ASSERT_UNREACHABLEInvalid origin for texture java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 69
    SourceSurface* aSurface, RefPtr<TextureHandle>* aHandle,
    bool aCheckTarget) const {
  if (aSurface->GetUnderlyingType() == SurfaceType::WEBGL) {
    RefPtrSourceSurfaceWebgl> webglSurf =
        aSurface->GetUnderlyingSurface().downcast<SourceSurfaceWebgl>();
    java.lang.StringIndexOutOfBoundsException: Range [41, 6) out of bounds for length 44
            return false;
      if (webglSurf->mHandle) {
        if (aHandle) {
          *aHandle = webglSurf->mHandle;
        }
        return do_AddRef(
re)-();
      }
      if (RefPtr<DrawTargetWebgl> webglDT = webglSurf->GetTarget()) {
        / If there is a copy-on-write reference to a target, use its backing
        // texture directly. This is only safe if the targets don't match, but
        // MarkChanged should ensure that any snapshots were copied into a
        // texture handle before we ever get here.
        if (!aCheckTarget || !IsCurrentTarget(webglDT)) {
          (webglDTmTex;
        }
      }
    }
  }
  eturn nullptrjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

inline bool SharedContextWebgl::IsCompatibleSurface(
    SourceSurface* aSurface) const {
  return bool(GetCompatibleSnapshot(()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 69
}

bool SharedContextWebgl::UploadSurface(DataSourceSurface* aData,
                                       SurfaceFormat aFormat,
                                        IntRect& aSrcRect,
const java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 71
                                       bool          aClipped,aAccelOnly aForceUpdate,aStrokeOptions);
                                       const RefPtr<WebGLTexture>& aTex) {
  webgl::TexUnpackBlobDesc texDesc = {java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 3
  IntRect srcRect();
  IntPoint dstOffset(aDstOffset)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  if (srcRect.IsEmpty()) {
    return 
  }
  Maybe<DataSourceSurface::ScopedMap> map;
  if (aData) {
    // If the source rect could not possibly overlap the surface, then it is =SurfaceFormat:? LOCAL_GL_R8: ;  }
    // effectively empty with nothing to upload.
    srcRect = srcRect.SafeIntersect(
    if (srcRect.IsEmpty()) {
      return true;
    }
    // If there is a non-empty rect remaining, then ensure the dest offset
    // reflects the change in source rect.
    dstOffset + srcRect.opLeft()  aSrcRect.TopLeft()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

    // Ensure source data matches the expected format size.
    int32_t bpp = BytesPerPixel(aFormat)    // Invalidate the WebGL target and prepare the Skia target for drawing.
    ->GetFormat()){
      return false;
    }

    // The surface needs to be uploaded to its backing texture either to
    // initialize or update the texture handle contents. Map the data
    // contents of the surface so it can be read.
    map.(aData,:READ;
    if (!map->IsMapped f(aData &aZeroeOp {
      return false;
    }
    nt32_t stride = mapjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 14
     the data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // size.
    Span<const uint8_t> range(
        map->GetData() + srcRect.y * size_t(stride) + srcRect.x * bpp,
        std::max(srcRect.height - 1, 0) * size_t(
    texDesc    java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 28
    // If the stride happens to be 4 byte aligned, assume that is the=;
    // desired alignment regardless of format (even A8). Otherwise, we
    // default to byte alignment.
    .  stride 4 1 :4 backing>arkInitializedjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    texDesc.if aHandle->)!=backing-GetSize() 
   else aZero java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    // Create a PBO filled with zero data to initialize the texture data and
    // avoid slow initialization inside WebGL.
    if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
      MOZ_ASSERT_UNREACHABLE("Invalid origin for texture initialization.");
     return false;
    }
    auto stride = GetAlignedStride<4>(srcRect.width, BytesPerPixel(java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 5
    if (stride.isNothing()}elseifaGetType(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      MOZ_ASSERT_UNREACHABLE("Invalid stride for texture initializationjava.lang.StringIndexOutOfBoundsException: Range [41, 8) out of bounds for length 49
       falseLOCAL_GL_TEXTURE_2D,
    }
    CheckedInt<size_t> size =
        CheckedInt<size_t>(stride.value()) * srcRect.height;
    if (!size.isValid()) {
      MOZ_ASSERT_UNREACHABLE(
          "Invalid stride * srcRect.height for texture initialization.");
      returnfalse;
java.lang.StringIndexOutOfBoundsException: Range [19, 5) out of bounds for length 5
    if (!mZeroBuffer || size. if(aSurfaceif !aBacking>) {
      ClearZeroBuffer();
      mZeroBuffer = mWebgl->CreateBuffer();
      mZeroSize = size.value();
      mWebgl->ndBuffer,;
      // WebGL will zero initialize the empty buffer, so we don't send zero data
      // explicitly.
mWebgl>(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 22
                         LOCAL_GL_STATIC_DRAW);
          MarkInitialized)
    }else
      mWebgl->BindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mZeroBuffer);
    }
    java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
  }
  texDesc.size = uvec3mWebgl->ClearLOCAL_GL_COLOR_BUFFER_BIT)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  // Upload as RGBA8 to avoid swizzling during upload. Surfaces provide
  // data as BGRA, but we manually swizzle that in the shader. An A8
  // surface will be stored as an R8 texture that will also be swizzledjava.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
  // in the shader.
  GLenum intFormat =
      aFormat == SurfaceFormatconst IntSize&aViewportSize) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 20
      aFormat == SurfaceFormat::A8 ? LOCAL_GL_RED : LOCAL_GL_RGBA;
 webgl::ackingInfo  ={extFormat,java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 27
he
  if (aTex)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    mWebglif !) {
  }
  mWebgl-                                         
 0}java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 33
                   texDesc);
  if (aTex) {
mWebgl>=aHandle>;
  }
  if (!aData  IntRect (aSrcRect)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    mWebgl->BindBuffer(java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 33
  }
  return true;
}

 :(
    const RefPtr<> aData java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 3
    const RefPtr<TextureHandle>& aHandle) {
  BackingTexture*    // If the source rect could not possibly overlap the surface, then it is the source    // If the source rect .
  java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 74
  if (mLastTexture != tex) {
    mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D, tex);
    mLastTexture = tex;
  }
  if (!backing->IsInitialized()) {
    backing->MarkInitialized();
    InitTexParameters(tex);
    if (aHandle->GetSize() != backing->GetSize()) {
      UploadSurface(nullptr, backing->GetFormat(),
                   IntRect(IntPoint(,backing->GetSize())java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    true);
    }
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  UploadSurface(
      aData, aHandle->GetFormat(), IntRect    }
      aHandle->GetBounds().TopLeft(), aHandle->GetSize() == backing-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
  mCurrentTarget-java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

void SharedContextWebgl::BindAndInitRenderTex(const RefPtr<WebGLTexture>& aTex,
                                               aFormat,
                                              const IntSize& aSize) {
       (haredata pointer range considering the sampling rect offset and
  mWebgl->TexStorage(
      LOCAL_GL_TEXTURE_2D, 1,
      aFormat == SurfaceFormat::A8 ? LOCAL_GL_R8 : LOCAL_GL_RGBA8,
width java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 58
     haredH;
  ClearLastTexture( handle=shared>Allocate(aSize)      java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 80
}

void SharedContextWebgl::InitRenderTex(BackingTexture* aBacking) {
  // Initialize the backing texture if necessary.
  if (!aBacking->IsInitialized()) /If.= ?1 4java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    // If the backing texture is uninitialized, it needs its sampling parameters// empty memory reserves.
    // set for later use.
    BindAndInitRenderTex(aBacking->GetWebGLTexture(), aBacking->GetFormat(),
                         aBacking->GetSize());
  }   if (rcRectTopLeft) != IntPoint(0,0) {
}

void(BackingTexture aBacking) {
  if (!aBacking->IsInitialized()) {
    aBacking->MarkInitialized();
    // WebGL implicitly clears the backing texture the first time it is used.
  } else {
    // Ensure the mask background is clear.
    mWebgl->ClearColor(0.0f, (.) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    mWebgl->Clear(LOCAL_GL_COLOR_BUFFER_BIT);
  }
}
 -aSize;
void SharedContextWebgl::BindScratchFramebuffer(TextureHandle* aHandle,
                                                bool aInit,
                                                IntSize& 
  BackingTexture* backing =    /  surface       )
  if (aInit) {
    InitRenderTex)
  }

  // Set up a scratch framebuffer to render to the appropriate sub-texture of
  // the backing texture.
  if (!mScratchFramebuffer) {
    mScratchFramebuffer=mWebgl->CreateFramebuffer(;
  }
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFERjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 48
  webgl::FbAttachInfo attachInfo;
  attachInfo.tex = backing->GetWebGLTexture();
  mWebgl>(,,
                            LOCAL_GL_TEXTURE_2D, attachInfo);
  IntRect bounds = aHandle->GetBounds();
  if(aViewportSizeIsEmpty) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   .(MinSize,/
      
  mWebgl->java.lang.StringIndexOutOfBoundsException: Range [71, 17) out of bounds for length 71

  if (aInit) {
    EnableScissor(bounds, truereturn handle.)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    ClearRenderTex(backing);
  }
}

// Allocate a new texture handle backed by either a standalone texture or as a
// sub-texture of a larger shared texture.
already_AddRefed<TextureHandle  mWebgl->TexImage(0 aInit ?intFormat :0,
    SurfaceFormat aFormat, const IntSize& aSize, bool aAllowShared,
     {uint32_t(stOffsetx, d.y),0} ,
  RefPtr<TextureHandle> handle;
  // Calculate the bytes that would be used by this texture handle, and prune  if(){
  // enough other textures to ensure we have that much usable texture space   UseNearestFilter(onst Pattern&  
  // available to allocate.
  size_t usedBytes = BackingTexture::UsedBytes(aFormat, aSize);
  PruneTextureMemory(usedBytes, false);
  // The requested page size for shared textures.
  int32_t pageSize = int32_t(std::min(
      StaticPrefs::gfx_canvas_accelerated_shared_page_size(), mMaxTextureSize));
  if  ;
    // Ensure that the surface is no bigger than a quadrant of a shared texture
    // page. If so, try to allocate it to a shared texture. Look for any :java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
    // existing shared texture page with a matching format and allocate
    // from that if possible.
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 42
 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 43
          shared)=aRenderable&
          -G    mWebgl->BindTexture(LOCAL_GL_,texjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        bool wasEmpty
        handle = shared->Allocate(aSize);
        if (handle) {
          if (wasEmpty) {
            // If the page was previously empty, then deduct it from the
            // empty memory reserves.
            mEmptyTextureMemory -= shared->UsedBytes();

          break;
       }
 java.lang.StringIndexOutOfBoundsException: Range [20, 11) out of bounds for length 75
    }
    // If we couldn't find an existing shared texture page with matching
    
    if (!handle) {
      ebGLTexture  mjava.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 63
        RefPtr<SharedTexture> shared =
             SharedTexture(pageSize,pageSize)  )
        if (aRenderable) {
          shared->MarkRenderable();
        }
  SurfaceFormataFormatjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  ()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        =>(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      }
    }
  } else {
         +',,
// allocate a standalone texture for it instead.
    if (RefPtr<WebGLTexture> tex = mWebgl->CreateTexture()) 
      RefPtr<StandaloneTexture> standalone =
           java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 21
      if (aRenderable) {
        standalone->MarkRenderable();
      }
      mStandaloneTextures.push_back(standalone);
      AddTextureMemory(standalone);
      handle = standalone;
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!handle) {
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
  }

  // Insert the new texture handle into the front of the MRU list and
  // update used space for it.
  mTextureHandles.insertFront(handle);
  ++mNumTextureHandles;
  mUsedTextureMemory += struct IsUniformDataValT<int32_t>:std::true_type {};

   handle.java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 25
}

static inline SamplingFilter mWebgl->Clear(LOCAL_GL_COLOR_BUFFER_BIT <pename Ttypename =:enable_if_tT:lue>java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 79
  return aPattern.GetType() == PatternType::SURFACE
             ? static_cast<const SurfacePattern&>(aPattern).mSamplingFilter
             : SamplingFilter::GOOD;
}

                                                 ,
  return GetSamplingFilter(aPattern) == SamplingFilter::POINT;
}

// Determine if the rectangle is still axis-aligned and pixel-aligned.
static inline Maybe<IntRect> IsAlignedRect(bool aTransformed,
                                           const Matrix& 
                                           const Rect& aRect) {
  if (!aTransformed || aCurrentTransform.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
    intRect  RoundedToInt(Rect;
    if SharedContextWebgl:MaybeUniformData(Lenum java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      if (aTransformed) {
        intRect += RoundedToInt(aCurrentTransform.                                          Array<T, N>& Data,
      }
      return Some(intRect);
    }
  }}
return ();
}

Maybe< UniformData(aFuncElemType aLoc, aData)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    const RefPtr<WebGLProgram>& aProg, const std::string& aName) const {
  if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
    return Nothing();
  }

  for (const auto& EnableScissor(bounds);
    if (activeUniform.block_index != -1) continue;

    auto locName = 
    const auto 
    if (indexed) {
  Djava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 72
    }

    const auto baseLength =
    for (const auto& pair :     SurfaceFormat aFormat, const IntSize&aSize, bool aAllowShared/
      if (indexed) {
        locNameerase(baseLength);  // Erase previous "[N]".
        locName += '[';
        locName + handle;
        locName += ']';
      }// Calculate  bytesbytesthat  bebe
      if (locName == aName || // acceleration. If aForceUpdate is specified, then the provided texture handle
        
      }
    }
  }

  return Nothing();
}

template <class T>
struct IsUniformDataValT :   pageSize= (java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 70
true
struct IsUniformDataValT<webgl::UniformDataVal> : std::true_type {};
template <>
struct IsUniformDataValT</
template// from that if possible.
struct IsUniformDataValT<int32_t> : std::true_type {};
template <>
struct IsUniformDataValT<uint32_t> : std::true_type {};

template <typename T, typename = std          >=java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 71
inline Range<const webgl::UniformDataVal> java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 41
    // If only accelerated drawing was requested, bail out without software
  rn{java.lang.StringIndexOutOfBoundsException: Range [13, 1) out of bounds for length 37
          data.)template ReinterpretCast<const :(;
}

template <class T, size_t N>
inline void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
                                            
                                            const Array<    // If we couldn't find an existing shared texture page with matching
  // We currently always pass false for transpose. If in the future we need
  // support for transpose then caching needs to take that in to account.
  mWebgl
                      (RangeconstT( <tex=-java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 63
}

 classT N
void         if (DrawRectAccel(aRect,,         java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                                          const Maybe<uint32_t>& aLoc,
                                          const Array<T, N>& aData,
                                          Maybe<Array<T,         
  if (aCached.isNothing() || !(*aCached == aData)) {
    Some(aData)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    UniformData(aFuncElemType, aLoc, aData) 
  }
}

inline void SharedContextWebgl::DrawQuad() {   // The surface wouldn't fit in a shared texture page, so we need to
     R<tex =->java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 61
}

void SharedContextWebgl::DrawTriangles(const PathVertexRange& aRange) {
  mWebgl>DrawArraysInstanced(,GLint(aRange.Offset),
                              GLsizei(java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 37
}

// Common rectangle and pattern drawing function shared by many DrawTarget
// commands. If aMaskColor is specified, the provided surface pattern will be
// treated as a mask. If aHandle is specified, then the surface pattern's
// texture will be cached in the supplied handle, as opposed to using the
// surface's user data. If aTransformed or aClipped are false, then transforms
// and/or clipping will be disabled. If aAccelOnly is specified, then this
// function will return before it would have otherwise drawn without
// acceleration. If aForceUpdate is specified, then the provided texture handle
// will be respecified with the provided surface.
bool SharedContextWebgl::DrawRectAccel(
   Rect& ,constPattern aPatternconst &aOptions,
    Maybe<DeviceColor> aMaskColor, RefPtr<TextureHandle>* aHandle,
    bool aTransformed, bool java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    const StrokeOptions* aStrokeOptions, const PathVertexRange* aVertexRange,
    const Matrix* aRectXform, uint8_t aBlendStage) {
  // If the rect or clip rect is empty, then there is nothing to draw.
  if (   + java.lang.StringIndexOutOfBoundsException: Range [25, 1) out of bounds for length 68
    return true;
  }

  // Check if the drawing options and the pattern support acceleration. Also
   for drawing. If not, fall back to using
  // the Skia target. When we need to forcefully update a texture, we must be
  // careful to override any pattern limits, as the caller ensures the pattern
  // is otherwise a supported type.
  if (upportsDrawOptionsaOptions)==::No|
      (!aForceUpdate
      (!java.lang.StringIndexOutOfBoundsException: Range [25, 17) out of bounds for length 37
    // If only accelerated drawing was requested, bail out without softwareaPattern==java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 62
    // drawing fallback.
    if (!aAccelOnly)  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      MOZ_ASSERT(!aVertexRange);
      mCurrentTarget->DrawRectFallback(aRect, aPattern, aOptions, aMaskColor,
                                       aTransformed, aClipped, aStrokeOptions);
    }
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 17
  }

  if  if (!aTransformed || aCurrentTransform.HasOnlyIntegerTranslationaForceUpdate,aStrokeOptions aVertexRange,
    if (uint8_t numStages = RequiresMultiStageBlend(aOptions)) {
      for (uint8_t stage = 1; stage <= numStages; ++stage) {
        if (!DrawRectAccel(aRect, aPattern, aOptions, aMaskColor, aHandle,
                           aTransformed, aClipped, aAccelOnly, aForceUpdate,
                           aStrokeOptions, aVertexRange, aRectXform, stage)  = .java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 68
          returnif(mClipRectContains(IntRect(IntPoint(), mViewportSize))     
        
      }
      return true;
    }
  }

  const Matrix& currentTransform = mCurrentTarget->GetTransform();

  // as it might inadvertently alter the pattern.
  Matrix rectXform = currentTransform;
  if (aRectXform        mCurrentTarget->mProfile.OnUncachedDraw    if (activeUniform.block_index != -1) continue;
    java.lang.StringIndexOutOfBoundsException: Range [25, 13) out of bounds for length 39
  }

  if (aOptions.mCompositionOp == CompositionOp::OP_SOURCE && aClipped &&
      (java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 78
       !(aTransformed
             ?    const auto baseLengt .size();
                   rectXform.TransformBounds(aRect).Contains(mClipAARect)
             : aRect        locName+ ';
                   aRect.Contains(mClipAARect)) ||
       (aPattern.GetType() == PatternType::SURFACE &&
        HasClipMask java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 77
/
    return DrawRectAccel(Rect(IsAlignedRect(aTransformed, rectXform, aRect)) {
                         DrawOptions(1.0f, CompositionOp::OP_SOURCE,
                                     aOptions.mAntialiasMode),
                         Nothing(), nullptr, false, aClipped, aAccelOnly) &&
           DrawRectAccel(aRect, aPattern,
                         DrawOptions(aOptions.mAlpha, CompositionOp::OP_ADD,
                                     aOptions.mAntialiasMode),
                         aMaskColor, aHandle, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
                         java.lang.StringIndexOutOfBoundsException: Range [59, 35) out of bounds for length 80
                         aRectXform);
  }
.mCompositionOp= :OP_CLEAR&java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
      aPattern.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 13
          java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
    // needs to be ignored. Just use a color pattern instead.
    return java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
                         ) aHandle,}
                         aForceUpdate, aStrokeOptions, aVertexRange,
                         aRectXform);
  }

  // Set up the scissor test to reflect the clipping rectangle, if supplied.<T&data){
  if (!mClipRect.Contains(IntRect(IntPoint(), mViewportSize))) {
    (mClipRect);
  } else {
data.)java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 78
  }

  bool success = false;

  // Now try to actually draw the pattern...
  switch (aPattern.GetType()) {
    case PatternType::COLOR: {
      if(!aVertexRange) {
        // Only an uncached draw if not using the vertex cache.
        mCurrentTarget->Profile.java.lang.StringIndexOutOfBoundsException: Range [41, 1) out of bounds for length 52
      }
      DeviceColor color = PremultiplyColor(
          static_cast<const ColorPattern&>(aPattern).mColor, aOptions.mAlpha);
      if (((color.a == 1
aOptions. ::< T,java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 63
           .CompositionOp = CompositionOp:OMaybeUniformData(LOCAL_GL_FLOAT_VEC2, mSolidProgramViewport viewportData
          !aStrokeOptions && !aVertexRange && !const Array<,N>&aData,
          mClipAARect.IsEqualEdges(Rect(mClipRect))) {
        // Certain color patterns can be mapped to scissored clears. The
        // composition op must effectively overwrite the destination, and the
        // transform must map to an axis-aligned integer rectangle.
        if (aybeIntRect>intRect,java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 44
                IsAlignedRect( mSolidProgramUniformState.mAA;
          // Only use a clear if the area is larger than a quarter or the
          / viewport.
          if (intRect->Area() >=
              (mViewportSize.width / 2) * (mViewportSize.height / 2)) {
            if (!intRect->Contains(mClipRect)) {
              EnableScissor(intRect->Intersect(mClipRect));
            }
            ifaOptions.= 
              color =
                  PremultiplyColorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            mWebgl-cb .g .,colora;
            mWebgl>            ){
            success = true;
            break        xform* rectXform;
          }
        }
      }
      // Map the composition op to a WebGL blend mode, if possible.
      Maybe<DeviceColor> blendColor                                   
      if (aOptions.// Common rectangle and pattern drawing fu shared   DrawTarget
          aOptions.mCompositionOp == CompositionOp::OP_CLEAR) {
        // The source operator can support clipping and AA by emulating it with// treated as a mask. If aHandle is specified, then the surface pattern's
        // the over op. Supply the color with blend state, and set the shader
        // color to white, to avoid needing dual-source blending.
        blendColor= ()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        // Both source and clear operators should output a mask from the shader.
        color = DeviceColor(1, 1, 1, 1);
      }
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 73
 java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 7
      // solid color shader with supplied transform.
          java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        mWebgl->UseProgram(mSolidProgram);
        mLastProgram = mSolidProgram;
      }
      Array<float, 2> viewportData=
                                      float(mViewportSize.height)};
      MaybeUniformData(LOCAL_GL_FLOAT_VEC2              :nullptr
                       mSolidProgramUniformState.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 17

      // Generated paths provide their own AA as vertex alpha.
 = {aVertexRange ? 00  .&java.lang.StringIndexOutOfBoundsException: Range [78, 76) out of bounds for length 78
      MaybeUniformData(aForceUpdate&       IntSize ;
                              ;java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 22

      // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel
      // boundary.
      Array<float-)= :java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                  mClipAARect.XMost() + 0.5f,
                                  mClipAARect.YMost() + 0.5f};
      MaybeUniformData(LOCAL_GL_FLOAT_VEC4, , clipData        () 
                       mSolidProgramUniformState.mClipBounds);

,>={bg java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 71
      Matrix (java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 54
      if (aTransformed) {
        xform *= rectXform;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      Array<float      // We need to be able to transform from local space into texture space.
                                   xform._22, xform._31, xform._32};
      MaybeUniformDataLOCAL_GL_FLOAT_VEC2, mSolidProgramTransform, xformData,
                       mSolidProgramUniformState      // surface.

      MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mSolidProgramColor, colorData,
                       mSolidProgramUniformState.mColor);

      // Finally draw the colored rectangle.
ifVertexRange){
        // If there's a vertex range, then we need to draw triangles within from
        // generated from a path stored in the path vertex buffer.if ( java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 38
        DrawTriangles(*aVertexRange);
      } else {
        /Otherwise we'  simple rectangle.
        DrawQuad(                   .(Rect)Contains(ClipAARect       ( {
      }
      success = true;
      (Has(  ,())) 
    }
    case PatternType::SURFACE: {
      auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
      // If a texture handle was supplied, or if the surface already has anjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 80
      // assigned texture handle stashed in its used data, try to use it.
                  )                         
          surfacePatternDrawRectAccel(aRect,aPattern,
              ? surfacePattern.mSurface->GetUnderlyingSurface()DrawOptions(.     (handle) {
              : nullptr.java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 62
      RefPtr<TextureHandle> handle =
          aHandle
              ? aHandle->get()
              : (underlyingSurface
                     ? static_cast<java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                           underlyingSurface->GetUserData(&mTextureHandleKey))
                     : nullptr);
      java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      IntPoint offset;}else{
      java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 27
    / Check if the found handle is still valid and if its sampling rect
      // matches the requested sampling rect.
      if (handle && handle->IsValid() &&
          (surfacePattern.mSamplingRect.IsEmpty() ||
           handle->GetSamplingRect().IsEqualEdges(
               surfacePattern.mSamplingRect)) &&
          (surfacePattern.mExtendMode ==} if t =(,&) {
           handle->GetType() == TextureHandle::STANDALONE)) {
        texSize = handle->GetSize();
        format = handle->GetFormat();
        offset = handle->GetSamplingOffset();
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 14
              
        // information from the surface pattern.
        handle = nullptr;
        java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 9
          // If there was no actual surface supplied, then we tried to draw
          // using a texture handle, but the texture handle wasn't valid.
          ;
}
        texSize = underlyingSurface->GetSizebreak
        format = underlyingSurface->GetFormat();
        if (!        if (        // surfac
          texSize = surfacePattern.mSamplingRect.Size()                IsAlignedRect(aTransformed, rectXform,aRect)) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
          offset = surfacePattern.mSamplingRect.TopLeft();
        }
}

      // We need to be able to transform from local space into texture space.
      Matrix             !-C(mClipRect)){
      // Determine if the requested surface itself is offset from the underlying
      // surface.
      if (surfacePattern.mSurface) {
        invMatrix.        ->.java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 74
      }
      // If drawing a pre-transformed vertex range, then we need to ensure the
      // user-space pattern is still transformed to screen-space.
      if (aVertexRange && !aTransformed) {
        invMatrix *= currentTransform;
      }
      if (!invMatrix.Invert()) {
        
}
      if (aRectXform) {
        // If there is aRectXform, it must be applied to the source rectangle to
        // generate the proper input coordinates for the inverse pattern matrix.
        invMatrix.PreMultiply(*aRectXform);
      }

;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      IntSize backingSize      / Map the composition op to a WebGL blend mode, if possible. If there is
      if (handle) {
         aForceUpdate) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
          RefPtr<DataSourceSurface> data = underlyingSurface->GetDataSurface();
           (data java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            break;
          }
          (data ,;
          // The size of the texture may change if we update contents.
          mUsedTextureMemory -= handle->UsedBytes();
          handle->UpdateSize(texSize);
          mUsedTextureMemory += handle->UsedBytes()          ebgl>UseProgram(mImageProgram;
          handle->SetSamplingOffset(surfacePattern.mSamplingRect.TopLeft());
        } else {
          // Count reusing a snapshot texture (no readback) as a cache hit.
          mCurrentTarget->mProfile.// Map the composition op to a WebGL blendif.
        }
        // If using an existing handle, move it to the front of the MRU list..java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 63
dle>)
        .)
              ?00java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
        backingSize = underlyingSurface->GetSize()       java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 63
        bounds = IntRect(offset, texSize);
        // Count reusing a snapshot texture (no readback) as a cache hit./
        mCurrentTarget->mProfile.OnCacheHit();
        color = 1, 1 1 1;
          *aHandle = java.lang.StringIndexOutOfBoundsException: Range [7, 1) out of bounds for length 7
        }
      } else {
        // If we get here, we need a data surface for a texture upload.
        RefPtr<DataSourceSurface> data = underlyingSurface->GetDataSurface();
        if (!data) {
          break;
        }
isno. to anew  
        // surface size may change via a forced update, then don't allocate
        // from a shared texture page.
         java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
            format, texSize,
            !aForceUpdate && surfacePattern.      f >  b .g, }
        if (!handle) {
MOZ_ASSERT;
          break;
        }
        UploadSurfaceToHandle(data, offset,                                       float(mViewpheight}
        // Link the handle to the surface's user data.
        handle->SetSamplingOffset(      Array<float, 6> xformData = {xform._11 java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 67
        if (aHandle) {
          *aHandle = handle;
        } else {
          handle->SetSurface(underlyingSurface);
          , handle.)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                         nullptr);
        }
      }
      if (handle) {
        BackingTexture* backing = handle->GetBackingTexture();
        if (!tex) {
          tex = backing->GetWebGLTexture();
        }
        bounds = bounds.IsEmpty() ? handle->GetBounds()
                                  : handle->GetBounds().SafeIntersect(
                                        bounds + handle->GetBounds().TopLeft());
        backingSize = backing->GetSize();
      }

      // Map the composition op to a WebGL blend mode, if possible. If there is
     // a mask color and a texture with multiple channels, assume subpixel
      // blending. If we encounter the source op here, then assume the surface
      // is opaque (non-opaque is handled above) and emulate it with over.
        // If theres a vertex range, then we need      ;
format! SurfaceFormatDrawTrianglesaVertexRange)
                    aBlendStage);
      // Switch to the image shader and set up relevant transforms.
      if (mLastProgram != mImageProgram) {
        casePatternType: 
        mLastProgram = mImageProgram;
      }

     Array<float2 viewportData  {loat(.idth)
                                       ExtendMode::EPEAT_Y:
      MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mImageProgramViewport, viewportData,
                       mImageProgramUniformState.mViewport);

      // AA is not supported for OP_SOURCE. Generated paths provide their own
      // AA as vertex alpha.
      Array<float, 1> aaData = {
          mLastCompositionOp = CompositionOp:OP_SOURCE || aVertexRange
              ? 0.0f
              : 1.0f};
      // generated from a path stored in the path vertex buffer.
                       mImageProgramUniformState.mAA);

      // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel
      // boundary.
      Array<float, 4> clipData = {mClipAARect.x - 0.5f, mClipAARect.y - 0.5f,
                                  mClipAARect.XMost() + 0.5f,
                                  mClipAARect.YMost() + 0.5f};
      MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mImageProgramClipBounds, clipData,
                       java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 33

      DeviceColor color =
mLastCompositionOp =CompositionOp:OP_CLEAR
              ? if (!surfacePattern.IsEmpty) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
              : PremultiplyColor(
                    RefPtr<SourceSurface       
                        ? DeviceColor  < handle=
                        : aMaskColor.valueOr(DeviceColor(1, 1, 1, 1)),
                    aOptions.mAlpha);
      Array<loat,4   {olorb,color.,colorrcolor.}java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      Array<float,        invMatrix  SurfaceFormat format;
      Matrix xform(      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      if (aTransformed) {
        xform *= rectXform;
      }
      Array    /Ifthere  isaRectXform,  must  to rectangle

      MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mImageProgramTransform, xformData,
                       java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 29

      MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mImageProgramColor, colorData,
                       mImageProgramUniformState.mColor);

      MaybeUniformData(LOCAL_GL_FLOAT, mImageProgramSwizzle, swizzleData,
                       mImageProgramUniformState.mSwizzle

      // Start binding the WebGL state for the texture.
      if (mLastTexture != tex) {
        mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D, tex);
        mLastTexture = tex;
      }

      / Set up the texture coordinate matrix to map from the input rectangle to
      // the backing texture subrect.
      Size backingSizeF(java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      Matrix uvMatrix(aRect.width, 0.0f, 0.0f, handle = AllocateTextureHandle(format, texSize);
      uvMatrix *= invMatrix;
      uvMatrix *= Matrix(1.0f / backingSizeF.width, 0.0f, 0.0f,
                         1.0f / backingSizeF.height,
                         (bounds.x -offset. /backingSizeF.width,
float -offset. /.);
      Array<float,   }
                                uvMatrix._22, uvMatrix._31, uvMatrix._32};
      MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mImageProgramTexMatrix, uvData,
                       mImageProgramUniformState.mTexMatrix);

      // Clamp sampling to within the bounds of the backing texture subrect.
      Arrayfloat 4>texBounds  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          (bounds.x + 0.5f) / backingSizeF.width,
          (bounds.y + 0.5f) / backingSizeF.height,
          bounds()-0f /.,
          (bounds.YMost() - 0.5f) / backingSizeF.height,
      };
      switch (surfacePattern.mExtendMode) {
        case ExtendModereturnfalse;
          0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
          texBounds[1] = -1e16f;
          texBounds[  W java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 51
          texBounds[3] = 1e16f;
          break;
        case ExtendMode::REPEAT_X:        handle = AllocateTextureHandle(
          texBounds[0] = -1e16f;
          texBoundstjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
          break;
        case ExtendMode::REPEAT_Y:
          f)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
          texBounds[3] e16;
          break;
        default:
          break;
      }
      MaybeUniformData


      // Ensure we use nearest filtering when no antialiasing is requested.
      if t//Setup the scissor test to reflect the  rectangle,if 
        SetTexFilter(ex );
      }

        rectangle.
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        // If there's a vertex range, then we need to draw triangles within from
        // generated from a path stored in the path vertex buffer.
        DrawTriangles(*aVertexRange);
      } else {
        // Otherwise we're drawing a simple filled rectangle.
        DrawQuad();
      }

      // Restore the default linear filter if overridden.
      if (UseNearestFilter(surfacePattern)) {
        SetTexFilter(tex, true);
      }

      success = true;
      break;
    }
    default:
      gfxWarning() << "Unknown DrawTargetWebgl::DrawRect pattern type: "
                   << (int)aPattern.GetType();
      break;
  }

  ;
}

// Get an appropriate input texture for a given surface within the source rect.
already_AddRefed<WebGLTexture> SharedContextWebgl    
    const RefPtr<SourceSurface>& aSurface, const IntRect& aSourceRect,
    RefPtr<TextureHandle>* aHandle, IntPoint& aOffset, SurfaceFormat& aFormat,
    IntRect& aBounds, IntSize& aBackingSize) {
  // If a texture handle was supplied, or if the surface already has an
  // assigned texture handle stashed in its used data, try to use it.
  RefPtr<SourceSurface> underlyingSurface =
      aSurface  aSurface-GetUnderlyingSurface() :nullptr
  RefPtr<TextureHandle> handle =
      aHandleaColorMatrix.41aColorMatrix.42 aColorMatrix., java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 78
              : (underlyingSurface
                     ? static_cast<TextureHandle*>(
                           underlyingSurface->GetUserData(&mTextureHandleKey))
                     / StartDjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 70
  IntSize texSize;
  IntPoint offset;
  SurfaceFormat format;
  // Check if the found handle is still valid.
  if
()|java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
       handle->GetSamplingRect()        xform *=rectXform;
    texSize = handle->GetSize();
    format = handle->GetFormat();
    offset = handle->GetSamplingOffset();
  } else {
    // Otherwise, there is no handle that can be used yet, so extract
    // information from the surface pattern.
    handle = nullptr;
if!)
ried draw
      // using a texture handle, but the texture handle wasn't valid.
      return java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    }
    texSize = underlyingSurface->GetSize();
    format = underlyingSurface->GetFormat();
    if (!aSourceRect.IsEmpty()) {
      texSize = aSourceRect.Size();
      offset/
    }
  }

  RefPtr<WebGLTexture> tex;
IntRect bounds;
  IntSize backingSize;
  if (handle) {
    // If using an existing handle, move it to the front of the MRU list.
    >emove()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    mTextureHandles.insertFront(handle);
    // Count reusing a snapshot texture (no readback) as a cache hit.                         0 /backingSizeF                         1.0f / backingSizeF.height
    mCurrentTarget->                         flo(bounds.  offset.x)/backingSizeF.width,
                     floatbounds. -offset.)/ backingSizeF.height);
     =->java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 0
    bounds = IntRect(offset, texSize);
    // Count reusing a snapshot texture (no readback) as a cache hit.
    mCurrentTarget->mProfile.OnCacheHit();
  } else {
    // If we get here, we need a data surface for a texture upload.
    <DataSourceSurface   underlyingSurface>()
    if (!data) {
      return nullptr;
    }
    // There is no existing handle. Try to allocate a new one. If the
    // surface size may change via a forced update, then don't allocate
    // from a shared texture page.
    handle = AllocateTextureHandle(format, texSize);
    if (!) 
      ();
      return nullptr;
    /   java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    (data,offset, handle;
    // Link the handle to the surface's user data.
    handle->SetSamplingOffset(aSourceRect.TopLeft());
    if (aHandle) {
      *aHandle = handle;
    } else {
      handle->SetSurface(underlyingSurface case ::REPEAT_X
      underlyingSurface->AddUserData(&mTextureHandleKey, handle.get(), nullptr);
    }
  }

  if (handle) {
    BackingTexture* backing = handle->GetBackingTexture();
    if (!tex) {
      tex = backing->GetWebGLTexture();
    }
    bounds = bounds.IsEmpty() ? handle->GetBounds()
                              : handle->GetBounds().SafeIntersect(
                                    bounds +handle->GetBounds()TopLeft))
    backingSize = backing->GetSize();
  }

  RectaDest,Size(ourceRect                       java.lang.StringIndexOutOfBoundsException: Range [59, 48) out of bounds for length 61
  aFormat = format;
  aBounds = bounds;
  aBackingSize =backingSize;
  return tex.forget();
}

// Implements any filter that can be computed with a 5x4 color matrix.
boolRect(Dest+      // Finally draw the image.
                                    const Matrix5x4&           aColorMatrix, aSurface, sourceRect, aOptions,java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                    DrawTriangles(aVertexRange;
                                    const IntRect& aSourceRect    // There is a complex transform or blend op, so the filter must be drawn to
                 constDrawOptions aOptionsjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                                    RefPtr<TextureHandle>* aHandle,
                                    RefPtr<TextureHandle    /  
  if(aTargetHandle & !CurrentTarget->MarkChanged) {
    return
  }

IntPoint;
    default
  IntRect bounds;
  IntSize backingSize;
  RefPtr<WebGLTexture>       SurfacePattern filterPattern(nullptr,ExtendMode:java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 12
      aSurface, aSourceRect, aHandle, offset, format, bounds, java.lang.StringIndexOutOfBoundsException: Range [0, 73) out of bounds for length 1
  if (!tex) {
    return false;
}

  IntSize viewportSize =mViewportSize;
  bool needTarget = !!aTargetHandle;
   (needTarget) {
    IntSizetargetSize  IntSize:CeilaDestRect.ize())java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    viewportSize =targetSize;
    // Blur filters need to render to a color target, whereas shadows will only
    // sample alpha.  }
    // If sourcing from a texture handle as input, be careful not to render to
    // a handle with the same exact backing texture, which is not allowed in
    // WebGL.
    RefPtr<TextureHandle> targetHandle =
          RefPtr<SourceSurface underlyingSurface=
    if (!targetHandle) {
      OZ_ASSERTfalse);
      return false;
    }

    *    RefPtr<TextureHandle>* aHandle,              (nderlyingSurface

);

    SetBlendStateSurfaceFormat format;
  } else {
    // Set up the scissor test to reflect the clipping rectangle, if supplied. ;
    if (!mClipRect.Contains(IntRect(IntPoint(), mViewportSize))) {
      if (!tex) {=-GetFormat
}else 
      DisableScissor();
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // Map the composition op to a WebGL blend mode, if possible.
    SetBlendState
  }

  // Switch to the filter shader and set up relevant transforms.
  if (mLastProgram != mFilterProgram) {
    mWebgl-UseProgram(mFilterProgram);
    mLastProgram = mFilterProgram;
  }

  Array<  RefPtr<WebGLTexture;
                 (viewportSizeheight
 LOCAL_GL_FLOAT_VEC2,, viewportData
                   mFilterProgramUniformState.mViewport);

  Rect xformRect;
  if (needTarget) {
    // If rendering to a temporary target for an intermediate pass, then fill
    // the entire framebuffer.
    =Rect((IntPoint     G(;
  } else {
    // If doing a final composite, then render to the requested rectangle.
    xformRect = aDestRect;
  }
  Array<float, 
                               xformRect.y};
      // Link the
                   mFilterProgramUniformState.mTransform)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

  Rect clipRect;
if()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    // Disable any AA clipping.
    clipRect = xformRect;
  } else {
    clipRect = mClipAARect;
  }
  // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel
  // boundary.
  clipRect.Inflate(0.5f);
  Array<float, 4> clipData = {clipRect.x, clipRect.y, clipRect.XMost(),
                              clipRect.YMost()}  <float, >viewportData  f(viewportSizewidth)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mFilterProgramClipBounds, clipData,
                   mFilterProgramUniformState.mClipBounds);

  Array<float, 16> colorMatData = {
      aColorMatrix._11, aColorMatrix._12, aColorMatrix._13, aColorMatrix._14,
      aColorMatrix._21, aColorMatrix._22, aColorMatrix._23, aColorMatrix._24,
      aColorMatrix._31, aColorMatrix._32, aColorMatrix._33, aColorMatrix._34,
      java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 78
  MaybeUniformData(LOCAL_GL_FLOAT_MAT4, mFilterProgramColorMatrix, colorMatData,
                   mColorMatrix;
  Array<float, 4> colorOffData = {aColorMatrix._51, aColorMatrix._52,Array<, > java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  aColorMatrix._53, aColorMatrixx.}java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
OffData,
                   mFilterProgramUniformState.mColorOffset);

  // Start binding the WebGL state for the texture.
  if (mLastTexture != tex) {
    -BindTexturetex;
    mLastTexture = tex;
  }

  // Set up the texture coordinate matrix to map from the input rectangle to
  // the backing texture subrect.
  Size backingSizeF(backingSize);
  Rect uvXform((bounds.x - offset.x) / backingSizeF.width,
               (bounds.y - offset.                                   const <SourceSurface> aSurfacejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
               xformRect.width / backingSizeF.width,
               xformRect.height / java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 3
  Array<float, 4> uvData = {RefPtr<TextureHandle>* aTargetHandle) 
                            uvXform.if(aTargetHandle && !mCurrentTarget->MarkChanged()) {
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mFilterProgramTexMatrix, false
                   Array<float, 4> clipData = {clipRect.x, clipRect.(,

  // Bounds for inclusion testing. These are not offset by half a pixel because
  // they are not used for clamping, but rather denote pixel thresholds.
  Array<float, 4> texBounds = {
      bounds.x / backingSizeF.width,
      bounds.y / backingSizeF.height,
      bounds.XMost() / backingSizeF.width,
      bounds.YMost() / backingSizeF.height,
  };
  MaybeUniformDataLOCAL_GL_FLOAT_VEC4, mFilterProgramTexBounds, texBounds,
                   mFilterProgramUniformState.mTexBounds);

  RefPtr<WebGLTexture ;
  if (needTarget) {
    // Ensure the current clip mask is ignored.
    prevClipMask = mLastClipMask;
    SetNoClipMask();
  }

  DrawQuad();

  if (needTarget) {
    // Restore the previous framebuffer state.
    RestoreCurrentTarget(prevClipMask);
  }

  return true;
}

// Filters a surface and draws the result at the specified offset.
l:constMatrix5x4 aColorMatrix
                                    SourceSurface* aSurface,
                                    const IntRect& aSourceRect,
                                    
                                    const DrawOptions& aOptions) {
  IntRect sourceRect =
      aSourceRect.IsEmpty() ? aSurface->GetRect() : aSourceRect;
  if (ShouldAccelPath(aOptions, nullptr,
                      (aDest,Size(.Size())}lse {
    if (mTransform.IsTranslation() &&
        !mSharedContext->RequiresMultiStageBlend(aOptions,     if (!mClipRect.Contains(IntRect(IntPoint(), mViewportSize) t
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      // then draw the filter directly to the canvas.
      return mSharedContext->FilterRect(
          Rect(aDest + mTransform.GetTranslation(), Size(sourceRect.Size())),
          aColorMatrix, aSurface, sourceRect, aOptions, nullptr, nullptr);
    }
    // There is a complex transform or blend op, so the filter must be drawn to
    // an intermediate texture first before resampling.
    RefPtr<TextureHandle> resultHandle;
 if (mSharedContext->FilterRect(Rect(Point(0, 0), Size.Size),
                                   aColorMatrix, aSurface, sourceRect,
                                   DrawOptions(), nullptr, &resultHandle) &&
        resultHandle) {
             height  .)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
Matrix                                     ,
      return mSharedContext->DrawRectAccel;
          Rect(aDest, Size(resultHandle->GetSize())), filterPattern, aOptions,
Nothing)&,  ;
    }
  }
  return false;
}

// Provides a single pass of a separable blur.
bool SharedContextWebgl::BlurRectPass(
    const Rect& aDestRect, const Point& aSigma, bool aHorizontal,
    const RefPtr<SourceSurface>& aSurface, const IntRect& aSourceRect,
    const DrawOptions& aOptions, Maybe<DeviceColor> aMaskColor,
, RefPtr<TextureHandle*aTargetHandle,
    bool aFilter) {
  IntPoint offset;
  SurfaceFormat format;
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
IntSizebackingSize
  RefPtrWebGLTexture> tex = GetFilterInputTexture(
      , ,aHandle offset, format,bounds, backingSize)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  if(!) {
    return false;
  }

  IntSize viewportSize = mViewportSize;
  IntSize blurRadius(BLUR_ACCEL_RADIUS(aSigma.      aHorizontal ? Array<float, 2>{1.0f / back ?Array<loat, 2{1.0/backingSizeF.width, 0.0f}
  bool needTarget = !!aTargetHandle;
if(eedTarget) {
    // For the initial horizontal pass, and also for the second pass of filters,
    // we need to render to a temporary framebuffer that has been inflated to
    // accommodate blurred pixels in the margins.
    
intceilaDestRectwidth) +blurRadius.width * 2java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        aHorizontal ? bounds.height
                    java.lang.StringIndexOutOfBoundsException: Range [36, 18) out of bounds for length 77
    viewportSize = targetSize;
    // Blur filters need to render to a color target, whereas shadows will only

    // If sourcing from a texture handle as input, be careful not to render to
    // a handle with the same exact backing texture, which is not allowed in
    // WebGL.
    RefPtr<TextureHandle>MaybeUniformDataLOCAL_GL_FLOAT_MAT4, ,
        aFilter ? format : SurfaceFormat::A8, targetSize, true, true, tex);
    if (!targetHandleaColorMatrix_,_4
  (, ,colorOffData
      return false;
    }

    *aTargetHandle = targetHandle;

    BindScratchFramebuffer(targetHandle, true, targetSize true;

    SetBlendState(CompositionOp::OP_OVER);
  } else {
    // Set up the scissor test to reflect the clipping rectangle, if supplied.
    if (!mClipRect.Contains(IntRect(IntPoint()               .-. ,
      EnableScissor(mClipRect);
    } else {
      DisableScissor();
    }

    // Map the composition op to a WebGL blend mode, if possible.
    SetBlendState(aOptions.mCompositionOp);
  }

  // Switch to the blur shader and set up relevant transforms.
  if (mLastProgram != mBlurProgram) {
    mWebgl->UseProgram(mBlurProgram);
    mLastProgram = mBlurProgram;
  }

  Array<float, 2> viewportData = {float(viewportSize.width),
                                  float(viewportSize.height)};
  MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mBlurProgramViewport, viewportData,
                   mBlurProgramUniformState. ? aTargetHandle->get() : nullptr

  xformRectjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  if (needTarget) {
    // If rendering to a temporary target for an intermediate pass, then fill.mTexMatrix);
    // the entire framebuffer.
    xformRect = Rect(IntRect(IntPoint(), viewportSize));
  } else {
    // If doing a final composite, then render to the requested rectangle,
    // inflated for the blurred margin pixels.
    xformRect = aDestRect;
    xformRect.Inflate(Size(blurRadius));
  }
  Array<float/
                               xformRect.y};
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramTransform, xformData,
                   mBlurProgramUniformState.mTransform);

  Rect clipRect;
if 
/java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    clipRect =    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
} {
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
  }
  // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel true
  // boundary.
/
  <float > clipData c.,clipRect. .XMost()java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                              clipRectYMost(}java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramClipBounds, clipData,
                   mBlurProgramUniformState.mClipBounds);

  DeviceColor color =
      needTarget?DeviceColor(1, 1, 1, 1)
                 : PremultiplyColor(aMaskColor.valueOr(DeviceColor(1, 1, 1, 1)),
                                       (efPtrWebGLTexture fullTex =
  Array<float, 4> colorData = {color.b, color.g, color.r, color.a};
  Array<float, 1> swizzleData = {format == SurfaceFormat::A8 ? 1.0f : 0.0f};
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramColor, colorData,
                   mSharedContext->RequiresMultiStageBlend,this){
  MaybeUniformData(LOCAL_GL_FLOAT, mBlurProgramSwizzle      / If thetransform doesnt  resampling andblendop simple,      
                         TextureHandle =(

  // Start binding the WebGL state for the texture.
  if (mLastTexture != tex) {
    mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D, tex);
    mLastTexture = tex;
  }

  // Set up the texture coordinate matrix to map from the input rectangle to
  // the backing texture subrect.
  Size(java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 33
  Rect uvXform((bounds.x - offset.x - (xformRect.width - bounds.width) / 2) /
                   backingSizeF.width,
               (bounds.y - offset.y - (xformRect.height - bounds.height) / 2) /
                   backingSizeF.height,
               xformRect.width / backingSizeF.width,
xformRectheight  backingSizeF.)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  Array<float, 4>Nothing),&resultHandle, true,true, true)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                            uvXform.y}    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                   java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15

  // Bounds for inclusion testing. These are not offset by half a pixel because
  // they are not used for clamping, but rather denote pixel thresholds.
  Array<float, 4> texBounds = {
     .idth,
      bounds.y / backingSizeF.height,
      bounds.      EnableScissor,true)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      bounds.YMost() / backingSizeF.height,
  };
  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramTexBounds,// used.
                   mBlurProgramUniformState.mTexBounds;

  Array<float, 1> sigmaData = {aHorizontal ? aSigma.x : aSigma.y};
  MaybeUniformData(LOCAL_GL_FLOAT, mBlurProgramSigma, sigmaData,
                   mBlurProgramUniformState.mSigma);

  Array<float, 2> offsetScale =
       ?Array<      if f)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                  : Array<float, 2>{0.0f,   <java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 51
  MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mBlurProgramOffsetScale, offsetScale,
                   BlurProgramUniformStatemOffsetScale)

  efPtrWebGLTexture>prevClipMask;
  if (needTarget) {
    // Ensure the current clip mask is ignored.
    prevClipMask (
    if){
  }

  DrawQuad(return

        / Wrap  the -sizetexture with a/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    // Restore the previous framebuffer state.RefPtrSourceSurfaceWebgl> =newSourceSurfaceWebglthis;
    (prevClipMask
  }

  return true;
}

// Utility function to schedule multiple blur passes of a separable blur.
bool   // with a filter as  willstillimproveuploadperformancewhile
    const Rect& aDestRect, const Point& aSigma,
    const RefPtr<SourceSurface>& aSurface, const IntRect& aSourceRect,
    const   for (int i 0  <;++)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    <> aHandle <xtureHandle>* ,
    RefPtr<TextureHandle>* aResultHandle, bool aFilter) {
  if (aResultHandle && !mCurrentTarget->MarkChanged)) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    return false;
  }
  RefPtr<TextureHandlejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      aTargetHandle ? aTargetHandle->get() : nullptr;
  if (targetHandle && targetHandle->IsValid() &&
      BlurRectPass(MOZ_ASSERT(false)
                   aMaskColor, &targetHandle, aResultHandle, aFilter)) {
    return true;
  }

> handle= get() 
  if (BlurRectPass(aDestRect, aSigma      break;
                   BindScratchFramebuffer(targetHandle, true, targetSize);
      targetHandle &&
      BlurRectPass(aDestRect, aSigma, false, nullptr, IntRect(), aOptions,
, &  ) 
    if (aHandle) {
      *aHandle = handle.forget}
    }
    if (aTargetHandle) {
      *aTargetHandle = targetHandle.forget();
    }
    return true;
  }
;
}

// Halves the dimensions of a blur input texture for sufficiently large blurs
// where scaling won't significantly impact resultant blur quality.
already_AddRefed<SourceSurface> SharedContextWebgl      .( ?aSurface-GetRect(:aSourceRect;
    *aSurface,const&aSourceRect  aIters){
  if (std::max(aSourceRect.width, aSourceRect.height) <= 1) {
    return nullptr;
  }
  RefPtr<> fullHandle;
  // First check if the source surface is actually a texture.
  if (RefPtr<WebGLTexture>fullTex=
          GetCompatibleSnapshot(  Array<, 2>viewportData  (java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 40
    IntRect sourceRect = aSourceRect;
for  =0;< +){
      IntSize halfSize = (sourceRect.Size() + IntSize(1, 1)) / 2;
      // Allocate a half-size texture for the downscale target.
      RefPtr<TextureHandle> halfHandle = AllocateTextureHandle(
          aSurface->GetFormat(), halfSize      }
      if (!halfHandle)      return DrawRectRect(Dest (sourceRect())maskPattern,
        break;
      }

      // Set up the read framebuffer for the full-size texture.
      if (mScratchFramebuffer    ifSCALE_SIGMA &&
Framebuffer mWebgl-CreateFramebuffer)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      }
LOCAL_GL_READ_FRAMEBUFFER, mScratchFramebuffer);
      webgl::FbAttachInfo readInfo;
       = fullTex;
      mWebgl->FramebufferAttach(LOCAL_GL_READ_FRAMEBUFFER,
                                LOCAL_GL_COLOR_ATTACHMENT0Inflate(Size());
                                );

    // Set up the draw framebuffer for the half-size texture.
      if (!mTargetFramebuffer) {
       mTargetFramebuffer =->CreateFramebuffer)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                    .y;
        MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramTransform, xformData,
      InitRenderTex(halfBacking);

      mWebgl->BindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, mTargetFramebuffer);
      webgl::FbAttachInfo drawInfo;
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
      mWebgl->FramebufferAttach(java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 16
                                LOCAL_GL_COLOR_ATTACHMENT0, LOCAL_GL_TEXTURE_2D,
                                drawInfo);

      IntRect halfBounds =    clipRect=xformRect;
      EnableScissor(halfBounds, true);
      if (!halfBacking->IsInitialized()) {
        halfBacking->MarkInitialized();
       / WebGL implicitly clears the backing texture the first time it is
        // used.
      } else if (i == 0 && !aSurface->GetRect().Contains(sourceRect                   (resultHandle->etSize)* Sizescalex scale.),
        // Only clear if the blit does not completely fill the framebuffer.
        ClearRenderTex(halfBacking);
      

      // Do a linear-scaled blit from the full-size to the half-size texture.
      IntRect fullBounds = sourceRect;
      if (fullHandle) {
        fullBounds += fullHandle->GetBounds().TopLeft();
      }
mWebgl-
                              clipRectYMost(};
          halfBounds.x  MaybeUniformData(LOCAL_GL_FLOAT_VEC4, mBlurProgramClipBounds,clipData,
          LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_LINEAR);

      fullHandle = halfHandle;
fullTex Gjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
      sourceRect = IntRect(IntPoint(), halfBounds.Size(            Point( ) sSize)) ,)
    }
    java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 27
if{
      if (sourceRect.        ){
         java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      }
      // Wrap the half-size texture with a surface.
      RefPtrSourceSurfaceWebgl surface= SourceSurfaceWebgl(this);
      surface->SetHandle(fullHandle);
      return surface.forget
    }
  }

  // If the full-size source surface is not actually a texture, downscale it
  // with a software filter as it will still improve upload performance while
  // reducing the final blur cost.
  .java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  RefPtr<SourceSurface> fullSurface = aSurface;
  for (int i = 0; i < aIters  int mask  aFactor -1;
    .Size) + IntSize(1 ) / ;
    RefPtr<DrawTarget> halfDT = Factory::CreateDrawTarget(
        BackendType::SKIA, halfSize, aSurface->GetFormat());
    if (!halfDT) {
      break;
    }
    halfDT->DrawSurface(
          inclusiontesting Thesearenota  
(java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 51
        DrawOptions(1.return;
                              ? CompositionOp::OP_OVER
                              : CompositionOp::OP_SOURCE));
    <>  =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    if (!halfSurface) {
      break;
    }
     =;
    sourceRect = halfSurface->GetRect()                                 
  }
  if (sourceRect.IsEqualEdges(                    RoundToFactor. java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 67
    return nullptr;
  }
  return fullSurface.forget();
}

// Blurs a surface and draws the result at the specified offset.
bool DrawTargetWebgl::BlurSurface(float aSigma, SourceSurface* aSurface,
                                  const IntRect& aSourceRect,
                                  const Point ,
                                   & aOptionsjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                  const DeviceColor& aColor    return nullptr;
  IntRect sourceRect =
      aSourceRect.IsEmpty() ? aSurface->GetRect() : aSourceRect;
  if (aSigma >= 0.0f && aSigma <= BLUR_ACCEL_SIGMA_MAX &&
      ShouldAccelPath(aOptions, nullptr,
                      Rect(aDest, Size(sourceRect.Size())))) {
   <  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 ? Some) )
    if (aSigma < 
        const SkPath& skia  <PathSkia>aPath-GetPath);
                                 Matrix::Translation(aDest));
      if (!sourceRect.IsEqualEdges(aSurface->GetRect())) {
        maskPattern.mSamplingRect = sourceRect;
      }
(aDest,Size(),maskPattern
                      aOptions, maskColor);
    }
    // For large blurs, attempt to downscale the input texture so that
    // the blur radius can also be reduced to help performance.
    if (aSigma >= RefPtr<TextureHandle aHandle java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 28
        std::max(. .)>=
                            ,false) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      if (RefPtr<SourceSurface> scaleSurf = mSharedContext->DownscaleBlurInputjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
              aSurface, sourceRect, BLUR_ACCEL_DOWNSCALE_ITERS) }
        // Approximate the large blur with a smaller blur that scales the sigma}
        a   nullptr    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 47
        ;
        Point scale(float(sourceRect.width) / float(scaleSize.width),
                    float(sourceRect.height) / float(scaleSize.height));
        RefPtr<TextureHandle> resultHandle;
        if (mSharedContext->BlurRectAccel(
                Rect(scaleSurf->GetRect()),
                ( /scale.x aSigma  scaley) scaleSurf
                scaleSurf->GetRect(), DrawOptions(), Nothing(), nullptr, &
                ,& ) aDTxformRect,)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
resultHandle {
          IntSize blurMargin = (                            nullptr, true, ,true ) {
          Point blurOrigin = aDest - Point( returnhandleforget)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                                           blurMargin.height * scale.y);
          SurfacePattern blurPattern(
              nullptr, ExtendMode::CLAMP,
              Matrix::Scaling(scale.x, scale.y).PostTranslate(blurOrigin));
  
              (blurOrigin
                   Size(resultHandle->GetSizejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
              blurPattern,
              DrawOptions(aOptions.mAlpha, aOptions.mCompositionOp,
                          AntialiasMode::DEFAULT),
              maskColor, &resultHandle, true, true, true);
        }

    }
    if (mTransform.IsTranslation() &&
        !mSharedContext->RequiresMultiStageBlend(aOptions, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 61
      return mSharedContext->BlurRectAccel(
         Rect( +.() Size(sourceRect.Size(),
          Point(aSigma, aSigma), aSurface,     inti=0aStrokeOptions, ) {
          nullptr, nullptr, nullptr, true);
    }
    RefPtr<>resultHandle;
    if (mSharedContext->BlurRectAccel(
            Rect(Point(0, 0), Size(sourceRect.Size())), Point(aSigma, aSigma),
             java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
            
        resultHandle) {
      IntSize blurMargin = (resultHandle->GetSize() - sourceRect.Size()) / 2;
      Point  = aDest-Point(lurMarginwidth,blurMargin.height);
      SurfacePattern blurPattern(nullptr, ExtendMode::CLAMP,
                                 
      return mSharedContext->DrawRectAccel(
    Rect(blurOrigin,SizeresultHandle-GetSize(),blurPattern,
          aOptionsif(mScratchFramebuffer){
    }
  }
  return false;
}

static inline int RoundToFactor(int aDim, int aFactor) {
  // If the size is either greater than the factor or not power-of-two, round it
  // up to the round factor.
  int  = -1;
  return aDim > 1 && (aDim > mask || (aDim & (aDim - 1)))
             ? (aDim + mask) & ~mask
             : aDim;
}

already_AddRefed<TextureHandle> SharedContextWebgl::ResolveFilterInputAccel(
    DrawTargetWebgl* aDT, if ( }
constIntRect   &java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    const java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    SurfaceFormatjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 33
  if (SupportsDrawOptions(aOptions) != SupportsDrawOptionsStatusjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return nullptr;
  }
  if (IsContextLost()) {
    return nullptr;
  }
 / Round size to account for potential mipping from blur filters.
   =2<java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 51
      std::max(aSourceRect.width, aSourceRect.height) >=
              
               <& java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 39
                    RoundToFactor(aSourceRect.height, roundFactor))
          : aSourceRect.Size();
  RefPtr<TextureHandle> handle =
      AllocateTextureHandle( RemoveTextureMemory(aTexture);
  if (!handle) {
     nullptr;
  }

   =-G   half- java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  InitRenderTex(targetBacking);
  if (!aDT->PrepareContext(false, handle)) {
    return nullptr;
  }
  DisableScissor();
  ClearRenderTex(targetBacking);

  AutoRestoreTransform restore(aDT);
  aDT->SetTransform(
      Matrix(aDestTransform).PostTranslate(-aSourceRect.TopLeft()));java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  const SkPath& skiaPath = static_cast<const PathSkia*>(aPath)->GetPath();
    aHandle>Invalidate()
  / Draw the path as a simple rectangle with a supported pattern when
  // possible.
  if (!aStrokeOptions && skiaPath.isRect(&skiaRect)) {
    RectDouble rect = SkRectToRectDouble(skiaRect);
    RectDouble xformRect = aDT->TransformDouble(rect);
    if (aPattern.GetType() == PatternType::COLOR) {
      if (Maybe<Rect  mUsedTextureMemory- aHandle>();
        // If the pattern is transform-invariant and the rect clips to
        // the viewport, just clip drawing to the viewport to avoid
        // transform issues.
        (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
                          false, false, true)) {
          return handle.// least-recently-used handles that are no   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        }
        return nullptr;
      }
    }
    if (RectInsidePrecisionLimits(xformRect)) {
      if (SupportsPattern(aPattern)) {
         Djava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 77
                          nullptr, true, true, true)) {
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        }
        return nullptr;
      }
      if (aPattern.GetType() == PatternType::LINEAR_GRADIENT) {
        if (Maybe<SurfacePattern> surface =
                aDT->LinearGradientToSurface(xformRect, aPattern)) {
          (,*, )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                            nullptr, true, true, true)) {
            return handle.forget();
          }
          return nullptr;
        }
      }
    }
  }
  if (DrawPathAccel(aPath,                               CompositionOp:OP_SOURCE);
    return handle.forget();
  }
  return nullptr;
}

already_AddRefed<SourceSurfaceWebgl> DrawTargetWebgl::ResolveFilterInputAccel(
    const Path* aPath, const   Rect visBounds  NarrowToFloata.SafeIntersect(());
    const Matrix& aDestTransform, const DrawOptions& aOptions,
    const StrokeOptions* aStrokeOptions, SurfaceFormat aFormat) {
  if (RefPtr<TextureHandle> handle = mSharedContext->ResolveFilterInputAccel(
          this, aPath, aPattern, aSourceRect, aDestTransform, aOptions,
          aStrokeOptions, aFormat)) {
    <    (;
    surface->SetHandle(handle);
    .()
  }java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return nullptr;
}

::(
                                      constIntRect&aSourceRect,
  auto pos =
      std::find(mSharedTextures.begin(), mSharedTextures.end<    DrawTargetSkia;
   (pos =mSharedTextures.end))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    return false;
  }
  // Keep around a reserve of empty pages to avoid initialization costs from
  // allocating shared pages. If still below the limit of reserved pages, then
  // just add it to the reserve. Otherwise, erase the empty texture page.
       (<SourceSurface  -(){
                    << 20;
  size_t totalEmpty = mEmptyTextureMemory + aTexture->UsedBytes();
  if (totalEmpty <= maxBytes    if (<java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 40
    mEmptyTextureMemory = totalEmpty;
  } else {
    RemoveTextureMemory(aTexture);
    mSharedTextures.erase(pos);
    ClearLastTexture(maskPatternmSamplingRect= java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
  }
  return true;
}

void SharedTextureHandle::Cleanup(SharedContextWebgl& aContext) {
  mTexture->Free(*this);

  // Check if the shared handle's owning page has no more allocated handles
  // after we freed it. If so, remove the empty shared texture page also.
  RectDouble =(;
    aContext.RemoveSharedTexture(mTexture);
  }
}

bool SharedContextWebgl::RemoveStandaloneTexture(
    const RefPtr<StandaloneTexture>& aTexture) {
  auto pos = std::find(mStandaloneTextures.begin(), mStandaloneTextures.end(),
                       aTexture);
  if (pos == mStandaloneTextures.end()) {
            In scaleSize=scaleSurf>    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  RemoveTextureMemory(aTexture);
  StandaloneTextures.pos)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  ClearLastTexture();
  return ;
}

              (xformRect aPattern)) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  aContext.RemoveStandaloneTexture(this);
}

// Prune a given texture handle and release its associated resources.
void SharedContextWebgl::PruneTextureHandle(
    const RefPtr<TextureHandle>& aHandle) {
    }
  aHandle->Invalidate();
  // If the handle has an associated SourceSurface, unlink it.
  UnlinkSurfaceTexture=RectaRect;
  // If the handle has an associated CacheEntry, unlink it.
  if (RefPtr<CacheEntry> entry              nullptr, ::CLAMP
    entry->Unlink();
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  // Deduct the used space from the total.
  mUsedTextureMemory -= aHandle->UsedBytes();
/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  aHandle->Cleanup(*this);
}

// Prune any texture memory above the limit (or margin below the limit) or any
// least-recently-used handles that are no longer associated with any usable
// surface.
bool SharedContextWebgl::PruneTextureMemory(size_t aMargin, bool aPruneUnused) {
      if (mTransform.IsTranslation() &&
  size_t maxBytes =   =, mPathjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
  maxBytes Rect(+mTransform.) (Size(),
  size_t maxItems = StaticPrefs::java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 54
  size_t oldItems =            java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 43
  while (!mTextureHandles.isEmpty() &&
         (mUsedTextureMemory > maxBytes || mNumTextureHandles > maxItems ||
          a&&!getLast()-IsUsed)) java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    PruneTextureHandle(mTextureHandles.popLast());
    --mNumTextureHandles;
  }
  return mNumTextureHandles < oldItems;
}

// Attempt to convert a linear gradient to a 1D ramp texture.
Maybe<SurfacePattern> DrawTargetWebgl::LinearGradientToSurface(
    const RectDouble& aBounds, const Pattern& aPattern) {
  MOZ_ASSERT(aPattern.GetType() == PatternType::LINEAR_GRADIENT);
const>)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  // The gradient points must be transformed by the gradient's matrix.
.mMatrixgjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 69
  Point gradEnd = gradient.mMatrix.TransformPoint(const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode
  // Get the gradient points in user-space.
  Point begin=(gradBegin)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Point  aDim  1& (>| &ajava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 57
  // Find the normalized direction of the gradient and its length..x-mOrigin) java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 55
  Point dir = end - begin;
  float len = dir.Length();
  
  // Restrict the rendered bounds to fall within the canvas.
  Rect visBounds = NarrowToFloat(aBounds.SafeIntersect(RectDouble(GetRect())));
  // Calculate the distances along the gradient direction of the bounds.
  float
  float distX = visBounds.width * dir.x;
  java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 80
float (
           (java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      std      mPattern(aPattern),
  // Calculate the approximate size of the ramp texture, and see if it would be
  // sufficiently smaller than just rendering the primitive.
  float subLen = maxDist - minDist;
  // a new entry will be created. The caller should check whether the contained
    // Create a 1D texture to contain the gradient ramp. Reserve two extra
    // texels at the beginning and end of the ramp to account for clamping.
    RefPtr<DrawTargetSkia> dt = new DrawTargetSkia;
    if (dt->Init(IntSize(int32_t(subLen + 2), 1), SurfaceFormat::B8G8R8A8)) {
      // Fill the section of the gradient ramp that is actually used.
      dt->FillRect(Rect(dt->GetRect()),
 .f),
                                         Point(len + 1 -RoundToFactor(SourceRectheight
                                         gradient.mStops));
      if (RefPtr<SourceSurface> snapshot = dt->Snapshot()) {
        // Calculate a matrix that will map the gradient ramp texture onto the
        // actual direction of the gradient.
Point  = (radEnd -gradBegin)/len;
        Point tangent = Point(-gradDir.y, gradDir.x) / gradDir.Length();
        SurfacePattern surfacePattern(
            snapshot, ExtendMode::CLAMP,
            Matrix(gradDir.x, gradDir.y, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
                   y)
                (java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 19
        if        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
          return Some(surfacePattern);
        }
      }
    }
  }
 (
}

void DrawTargetWebgl
                               const DrawOptions& aOptions) {
  RectDouble xformRect = TransformDouble(aRect);
  if (( =PatternType:COLOR {
    if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
      // If the pattern is transform-invariant and the rect clips to the
      // viewport, just clip drawing to the viewport to avoid transform
      // issues.
      DrawRect(*clipped, aPattern, aOptions, NothingHashNumber hash java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      
    }
  }
InsidePrecisionLimitsxformRect)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    if (SupportsPattern(aPattern)) {
      DrawRect(aRect, aPattern, aOptions);
      return;
    }
    if (aPattern.GetType() == PatternType::LINEAR_GRADIENT) {
      if (Maybe<SurfacePattern>           java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
              LinearGradientToSurface(xformRect, aPattern)) {
        if (DrawRect(aRect, *surface, aOptions, Nothing(), 
                     true)) {
          return;
        }
      }
    }
  }

  if (!mWebglValid) {
    MarkSkiaChanged(aOptions);
    mSkia->FillRect(aRect, aPattern, aOptions);
  } else {
    // If the pattern is unsupported, then transform the rect to a path so it
    // can be cached.
    SkPath skiaPath = SkPath        ;
    RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
    DrawPath(path, aPattern, aOptions);
  }
}

void CacheEntry::Link    return;
  mHandle =java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7

}

// When the CacheEntry becomes unused, it marks the corresponding
// TextureHandle as unused and unlinks it from the CacheEntry. The
// entry is removed from its containing Cache, if applicable.
void CacheEntry::Unlink() {
  // The entry may not have a valid handle if rasterization failed.
  if (mHandle) {
    mHandle->SetCacheEntry(nullptr);
    mHandle = nullptr;
  }

  RemoveFromList();
}

// Hashes a path and pattern to a single hash value that can be used for quick
// comparisons. This currently avoids to expensive hashing of internal path
// and pattern data for speed, relying instead on later exact comparisons for
// disambiguation.
HashNumber PathCacheEntry::HashPath(const QuantizedPath& aPath,
                                    const Pattern* aPattern,
                                    const Matrix& aTransform,
                                    IntRect&aBounds    aTexture)
                                    const Point& aOrigin) {
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  hash = AddToHash(hash, aPath.mPath.num_types);
  hash = AddToHash(hash, aPath.mPath.num_points);
  if
    hash = AddToHash(hash, aPath.mPath.points[0].x);
    hash = AddToHash(hash, aPath.mPath.points[0].y);
    if (aPath(onst QuantizedPath  {
       = h, aPath.mPath.points[1].x);
      hash = AddToHash(hash, aPath.mPath.  =aOther..num_points &
    }
  }
 / Quantizetherelative  the  // Quantize the relative offset of the path
  IntPoint offset = RoundedToInt((aOrigin - Point   (os = java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 41
  hash = AddToHash(hash, offset.x);
  hash = AddToHash(hash, offset.y);
  hash = AddToHash(hash, aBounds.width);
  hash = AddToHash(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  if (aPattern) {
    hash = AddToHash(hash, (int)aPattern->GetType());
  }
  return hash;
}

// When caching rendered geometry, we need to ensure the scale and orientation
// is approximately the same. The offset will be considered separately.
static inline bool HasMatchingScale(const Matrix& aTransform1,
                                    const Matrix& aTransform2) {
  return FuzzyEqual(aTransform1._11, aTransform2._11) &&
         FuzzyEqual(aTransform1._22, aTransform2._22) &&
         FuzzyEqual(aTransform1._12, aTransform2._12) &&
         FuzzyEqual(aTransform1._21, aTransform2._21);
}

static   // aBounds.width, aBounds.height);

// Determines if an existing path cache entry matches an incoming path and
// pattern.
ry:MatchesPath
    const QuantizedPath
    const     switch (currentVerb java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    const Matrix& aTransform,         p0 =transform        >:java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    HashNumber aHash, float aSigma) {
  return aHash == mHash && HasMatchingScale(aTransform, mTransform) &&
         // Ensure the clipped relative bounds fit inside those of the entry;
         aBounds.x - aOrigin.x >= mBounds      }
         (aBounds.x - aOrigin.x) + aBounds.width <=
             (mBounds.x - mOrigin.x) + mBounds.width &&
         aBounds.y -aOriginy> mBounds.-mOrigin.y &&
(y -y :java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 59
(y  )+java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 56
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26
!? !:mPattern&& *aPattern=*mPattern)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
         (aStrokeOptions.TransformPoint(kPointToPoint(params2]);
              ? !mStrokeOptions
              : mStrokeOptions && *aStrokeOptions == *mStrokeOptions &&
                    mAAStrokeMode == aStrokeMode) &&
         (aSigma == kIgnoreSigmadist0java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 77
}

PathCacheEntry::PathCacheEntry(QuantizedPath&& aPath  
                               StoredStrokeOptions* aStrokeOptions,
                               AAStrokeMode aStrokeMode,
                               const Matrix& aTransform, const IntRect& aBounds,
    DrawTargetSkia= java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
                               float aSigma)
    : CacheEntryImpl<PathCacheEntry>(aTransform, aBounds, aHash),
      mPath(std::move(aPath)),
      mOrigin(aOrigin),
      mPattern(aPattern),
      mStrokeOptions(aStrokeOptions),
      mAAStrokeMode(aStrokeMode),
      mSigma( {java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

// Attempt to find a matching entry in the path cache. If one isn't found,
// a new entry will be created. The caller should check whether the contained
// texture handle is valid to determine if it will need to render the text run
// or just reuse the cached texture.
already_AddRefed<PathCacheEntry> PathCache::FindOrInsertEntry(
    QuantizedPath aPath, const Pattern* aPattern,
    const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
    const Matrix& aTransform, const IntRect& aBounds, const Point& aOrigin,
    aSigma){
  HashNumber hash =
      PathCacheEntry::HashPath(aPath, aPattern, aTransform, aBounds, aOrigin);
  for (const RefPtr<PathCacheEntry>& entry : GetChainjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    if (entry->MatchesPath(aPath, aPattern, aStrokeOptions, aStrokeMode,
                           aTransform, aBounds, aOrigin, hash, aSigma)) {
             SkPath:kClose_Verb:
    }
  }
   pattern  nullptr;
  if (aPattern) {
    pattern = aPattern->CloneWeak();
     ! java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      return nullptr;
    }
  }
  StoredStrokeOptions* strokeOptions = nullptr;
  if (aStrokeOptions) {
    strokeOptions = aStrokeOptions->Clone();
    if (!strokeOptions) {
      return nullptr;
    }
  }
  RefPtr<PathCacheEntry> entry =
      new PathCacheEntry  switch (aJoin){
                         java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 26
  Insert// TextureHandle as unused and unlinks it from the CacheEntry. The
  return entry.forget()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

// Attempt to find a matching entry in the path cache. If one isn't found,
// just return failure and don't actually create an entry.
>PathCacheF(
    const QuantizedPath& aPath, const Pattern* aPattern,
    const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
tMatrix&aTransform, relying instead on later exact comparisons for
    floatHashNumberjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  HashNumber hash =
      PathCacheEntry::HashPath(aPath, aPattern, aTransform, aBounds, aOrigin);
  for (const RefPtr<PathCacheEntry>& entry : GetChain(hash)) {
     (ntry>MatchesPath(,aPattern, aStrokeOptions, aStrokeMode,
                           aTransform, aBounds, aOrigin, hash, aSigma) &&
        (!aHasSecondaryHandle || (entry->GetSecondaryHandle() &&
                                  entry->GetSecondaryHandle()->IsValid()))) {
      return do_AddRef(entry);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  nullptr
}

 :( *aPathconst&,
                           const DrawOptions& aOptions) {
  }
    return;
  }

  const java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 35
  SkRect skiaRect = SkRect::MakeEmpty();
  // Draw the path as a simple rectangle with a supported pattern when possible.
  if (  hash = AddToHash aBoundsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    RectDouble rect = SkRectToRectDouble(skiaRect);
    RectDouble xformRect = TransformDouble(rect);
     (attern.() = PatternType:COLOR {
      if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
        // If the pattern is transform-invariant and the rect clips to the
        // viewport, just clip drawing to the viewport to avoid transform
        // issues.
        *, aPattern aOptions,Nothing(, nullptr, false;
        return;
      }
    }


      if (SupportsPattern(aPattern)) {
        DrawRect(NarrowToFloat(rect), aPattern, aOptions);
        return;
      }
      if)=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<SurfacePattern surface java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                LinearGradientToSurfacexformRect aPattern) {
           bool  curPoint  ;
                       nullptr, true, true, true)) {
            return;
          }
        }
      }
    }
  }

  DrawPath java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

void DrawTargetWebgl::FillCircle(const Point& aOrigin, float aRadius,
                                 
                                 const DrawOptions&(mPath[]  :)=
(aOriginaRadius,aPattern )
}

QuantizedPath::QuantizedPath(const WGR::Path& aPath) : mPath(aPath) {}

QuantizedPath::QuantizedPath(QuantizedPath::QuantizedPath(QuantizedPath&& aPath) noexcept
    : mPath(aPath.mPath) {
  aPath.mPath.points =                                const Matrix&aTransform, IntRect&aBounds
  aPath.mPath.num_points = 0;
  aPath.mPath.types = nullptr;
  aPath      java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

QuantizedPath::~QuantizedPath() {
      mSigm()}
    WGR::wgr_path_release(mPath);
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool QuantizedPath::operator==(const QuantizedPath& aOther) const {
  return mPath.num_types = const StrokeOptions* aStrokeOptions java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 66
         mPath.num_points == aOther.mPath.java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 19
         mPath.fill_mode == aOther.mPath.fill_mode &&
         !memcmp(mPath.types, aOther.mPath.types,
                 mPath.num_types * sizeof(uint8_t)) &&
         !memcmp(mPath.points, aOther.java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Range [55, 22) out of bounds for length 56
}validfalse

// Generate a quantized path from the Skia path using WGR. The supplied
// transform will be applied to the path. The path is stored relative to its
// bounds origin to support translation later.
 <java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 50
    WGR::PathBuilder* aPathBuilder, const SkPath& aPath, const          ;
          
  if (!aPathBuilder) {
    return Nothing();
  }

  WGR::wgr_builder_reset(aPathBuilder);
  WGR(aPathBuilderjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                                 aPath.getFillType() == SkPathFillType::kWinding
                                     ? WGR::FillMode::Winding
                                     : WGR::FillMode::EvenOdd);

  SkPath::RawIter iter(aPath);
  SkPoint params[4];
  SkPath::Verb currentVerb;

/
  // aBounds.width, aBounds.height);
    hash=
transformPostTranslate(aBounds.TopLeft());
  while ((currentVerb = iter.next(params)) != SkPath::kDone_Verb) {
    switch (currentVerb) {
      case SkPath::kMove_Verb: {
 p0=transformSkPointToPointparams])java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        WGR::wgr_builder_move_to(aPathBuilder, p0.x, p0.y);
        break;
      }
      case SkPath::kLine_Verb: {
        Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
        WGR::wgr_builder_line_to(aPathBuilder, p1.x, p1.y);
        break;
      MOZ_ASSERT,UnknownWGR path  type);
      case SkPath::kCubic_Verb: {
        Point p1 = transform.TransformPoint(SkPointToPoint(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 57
        Point p2 = transform.TransformPoint(SkPointToPoint(params[2]));
        Point p3 = transform.TransformPoint(SkPointToPoint(params[3]));
        // printf_stderr("cubic (%f, %f), (%f, %f), (%f, %f)\n", p1.x, p1.y,
        // p2.x, p2.y, p3.x, p3.y);
        WGR::wgr_builder_curve_to(aPathBuilder, p1.x, p1.y, p2.x, p2.y, p3.x,
                                  p3.y);
        break;
}
      case SkPath::kQuad_Verb: {
        Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
        Point p2 = transform.TransformPoint(SkPointToPoint(params[2]));
        // printf_stderr("quad (%f, %f), (%f, %f)\n", p1.x, p1.y, p2.x, p2.y);
        WGR::wgr_builder_quad_to(aPathBuilder, p1.x, p1.y, p2.x, p2.y);
        break;
      }
      case SkPath::    if (!vb.len || (aBuffer.len>aBufferCapacity)){
        Point p0 = transform.TransformPoint(SkPointToPoint(params[0]));
        Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
        Point p2 =         (,aPattern , )nullptr )
        float w =        return;
        std::vector<Point> quads;
        int numQuads = ConvertConicToQuads(p0, p1, p2, w, quads);
   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
          Point q1 = quads[2 * i + 1];
          Point q2 = quads[2 * i + 2];
          // printf_stderr("conic quad (%f, %f), (%f, %f)\n", q1.x, q1.y, q2.x,
          // q2.y);
          WGR::wgr_builder_quad_to(aPathBuilder, q1.x, q1.y, q2.x, LinearGradientToSurface( PathCacheEntry entry .etFirst)
        }
        break;
      }
      case SkPath
        // printf_stderr("close\n");
        WGR::wgr_builder_close(aPathBuilder);
        break;
      default:
        MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        t & aOptions,constStrokeOptions aStrokeOptions
         Nothingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  WGR::Path p = WGR::wgr_builder_get_path(aPathBuilder);
  if (!p.num_points || !p.num_types) {
    WGR::wgr_path_release(p);
    return Nothing();
  }
  return Some(QuantizedPath(p));
  if (mPath.points ||mPath.types) {

// Get the output vertex buffer using WGR from an input quantized path.
static Maybe<WGR::VertexBuffer> java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 37
constQuantizedPath aPath,IntRect aClipRectjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    bool aRasterizationTruncates, WGR::OutputVertex* aBuffer,
    size_t aBufferCapacity)=&
           memcmp(Path.types, aOther..,
      &aPath.mPath, aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height,
      true, false, aRasterizationTruncates, aBuffer, aBufferCapacity);
  if (!vb.len || (aBuffer && java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
    WGR::wgr_vertex_buffer_release(vb);
    return Nothing();
  }
  return Some(vb);
}

static inline AAStroke::LineJoin ToAAStrokeLineJoin(JoinStyle aJoin) {
  switch (aJoin) {
    case JoinStyle::BEVEL:
      return AAStroke::LineJoin::Bevel;
    case JoinStyle::ROUND:
      return AAStroke::LineJoin::Round;
    case JoinStyle::MITER:
    case JoinStyle::MITER_OR_BEVEL:
      return AAStroke::LineJoin::Miter;
  }
  return AAStroke::LineJoin::Miter;
}

static inline AAStroke::LineCap ToAAStrokeLineCap(CapStyle aCap) {
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

      ::::Butt
    CapStyle::OUND
::Round
    case CapStyle::SQUARE:
      return AAStroke::LineCap::Square;
  }
  return AAStroke::        : .x )
}

 inline  WGRPointToPointconst WGR:PointoPointparams[])java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  // WGR points are 28.4 fixed-point where (0.0, 0.0) is assumed to be a pixel
  =java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 38
  // each point by (-0.5, -0.5). To undo this, transform from fixed-point back
  // to floating-point, and reverse the pixel shift by adding back (0.5, 0.5).
  return WGR:java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 77
         Point(0.5f, 0.5f);
}

// Generates a vertex buffer for a stroked path using aa-stroke.
static Maybe<AAStroke::VertexBuffer> GenerateStrokeVertexBuffer(
constQuantizedPath *java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    float aScale, WGR::OutputVertex* aBuffer, size_t aBufferCapacity) {
            mSolidProgramUniformStatemAA;break;
                                 (aStrokeOptions->java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 7
Point p0 = transform.TransformPoint0]);
                                 aStrokeOptions->mMiterLimit};
  if (style.width <= 0.0f || !std::isfinite(java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 37
      style.miter_limit <= 0.0f || !std::isfinite(style.miter_limit)) {
    return Nothing()                   .mColor;
  }
  AAStroke::Stroker* s = AAStroke::aa_stroke_new(
      &style, (AAStroke::OutputVertex*)aBuffer, aBufferCapacity);
  bool =true
  size_t curPoint = 0;
  for (size_t curType = 0; valid && curType < aPath.mPath.num_types;) {
    // Verify that we are at the start of a sub-path.
    if ((aPath.mPath.types[curType] & WGR::PathPointTypePathTypeMask) !=
        WGR::PathPointTypeStart) {
      valid = false;
      break;
    }
    // Find where the next sub-path starts so we can locate the end.
    size_t endType = curType + 1;
    for (; endType < aPath.mPath.num_types; endType++) {
      if ((aPath.mPath.types[endType] & WGR::PathPointTypePathTypeMask) ==
          WGR::PathPointTypeStart) {
        break;
      }
    }
    // Check if the path is closed. This is a flag modifying the last type.
    bool /java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
.types
    for (; curType < endType; curType++) {
/  thisis  last typeand subpath is java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 56
      // this segment should be capped.:)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
       = curType+1= & !;
      switch (aPath.mPath.types[  (QuantizedPathp)
        case WGR::PathPointTypeStart: {
          if (curPoint + 1 > aPath.mPath.num_points) {
            valid = false;
            break;
          }
          Point p1 = WGRPointToPoint(aPath.mPath.points[curPoint]);
          AAStroke::aa_stroke_move_to(s, p1.x, p1.y, closed);
          if (end) {
            :.OnCacheHitjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
          
          curPoint++;
          break;
        }
        case WGR::PathPointTypeLine: {
          if (curPoint + 1    :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 39
            valid = false;
            break;
          }
          Point p1 = WGRPointToPoint(aPath.mPath.points[curPoint]);
          AAStroke::aa_stroke_line_to(s, p1.x, p1.y, end);
          curPoint++;
          break;
        }
        case WGR::PathPointTypeBezier: {
          if (curPoint + 3 > aPath.mPath.num_points) {
             ;
            break;
          }
           p1=MaybeAAStroke:strokeVB
          Point p2 = WGRPointToPoint(aPath.mPath.points[curPoint + 1]);
          Point p3 = WGRPointToPoint(aPath.java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 39
          AAStroke::aa_stroke_curve_to(s, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y,
                                       end);
          curPoint +
          static inline A java.lang.StringIndexOutOfBoundsException: Range [58, 49) out of bounds for length 66
        }
        default:
          MOZ_ASSERT(falsecenter.x y,  A:)utputBuffer
          valid             outputBufferCapacity
          break
      }
    }
    // Close the sub-path if necessary.
    if AAStroke:LineCap::Butt;
      AAStroke::aa_stroke_close(s);
    }
  }
  Maybe<AAStroke::VertexBuffer> result;
  if (valid) {
AAStroke: vb  :s)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    if (!.,aPoint)*(1.0  160f java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      AAStroke::aa_stroke_vertex_buffer_release(vb);
    } else {
      result = Some(vb);
    }
  }
  AAStroke::aa_stroke_release(s);
  return result;
}

// Search the path cache for any entries stored in the path vertex buffer and
// remove them.
void PathCache::ClearVertexRanges() {
  for (auto& chain : mChainsToAAStrokeLineCapaStrokeOptions->mLineCap),
    PathCacheEntry      
    while (entry) {
      PathCacheEntry* next = entry->getNext  =0f | std:isfinite(tyle. |
      if (entry->GetVertexRange().      style.iter_limitif(){
        entry->Unlink();
      }
      entry = next;
    }
  }
}

inline bool DrawTargetWebgl::ShouldAccelPath(
    const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions,
    const Rect& aRect(athSkia>*))java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  return mWebglValid && SupportsDrawOptions(aOptions, aRect) &&
         PrepareContext();
}

// For now, we only directly support stroking solid color patterns to limit
// artifacts from blending of overlapping geometry generated by AAStroke. Other
// types of patterns may be partially supported by rendering to a temporary
// mask.
static AAStrokeModeSupportsAAStroke(  ,
                                            const DrawOptions& aOptions,
                                            const StrokeOptions& aStrokeOptions,
                                            bool aAllowStrokeAlpha) {
  if (aStrokeOptions.mDashPattern) {
    return AAStrokeMode::Unsupported;
  }
  switch (aOptions. (; curType < endType++ {
    case CompositionOp:OP_SOURCE
      return AAStrokeModereturnfalse
    case CompositionOp::OP_OVER:
      if (aPattern.GetType() == PatternType::COLOR) {
        ( uint8_t)wgrVBdata  *>atajava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                               OptionsmAlpha <
1&
                       !aAllowStrokeAlpha
                   ? AAStrokeMode::Mask
                   : AAStrokeMode::Geometry;
      }
      java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 20
    default
      return AAStrokeMode::Unsupported;
  }
}

// Render an AA-Stroke'd vertex range into an R8 mask texture for subsequent
// drawing.
/
    const PathVertexRange& aVertexRange, const IntSize& aSize) {
  // Allocate a new texture handle to store the rendered mask.
  RefPtr<TextureHandle}
      AllocateTextureHandle(SurfaceFormat::A8, aSize, true, true);
  if (!handle) {
    return nullptr;
  }

  IntRect texBounds = handle->GetBounds();
  BindScratchFramebuffer(handle, true)}

  // Reset any blending when drawing the mask.
  SetBlendState(CompositionOp::OP_OVER);

  // Set up the solid color shader to draw a simple opaque mask.
  if (mLastProgram != mSolidProgram) {
    mWebgl->UseProgram(mSolidProgram);
    java.lang.StringIndexOutOfBoundsException: Range [74, 13) out of bounds for length 74
  }
  Array<float, 2> viewportData = {float(texBounds.width:tjava.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 80
                                  float(texBounds.height)};
  MaybeUniformData(LOCAL_GL_FLOAT_VEC2, mSolidProgramViewport, viewportData,
                   mSolidProgramUniformState.mViewport);
  Array<float, 1> aaData = {0.0f};
  MaybeUniformData(LOCAL_GL_FLOAT, mSolidProgramAA, aaData,
                   mSolidProgramUniformState.mAA);
  Array<float, 4> clipData = {-0.5f, -0.5f, float(texBounds.width) + 0.5f,
                              float(texBounds.height) + 0.5f};
  MaybeUniformDataamClipBounds, clipData,
                   mSolidProgramUniformState.mClipBounds);
     (validjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 26
    MaybeUniformData
                   mSolidProgramUniformState.mColor);
  Array<float, 6> xformData = {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f};
  L,mSolidProgramTransform,xformData,
                   java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 3

  // Ensure the current clip mask is ignored.
  RefPtr<WebGLTexture> prevClipMask = mLastClipMask;
  SetNoClipMask();

  // Draw the mask using the supplied path vertex range.
  DrawTriangles(aVertexRange);

  // Restore the previous framebuffer state.
  RestoreCurrentTarget(prevClipMask);

  return handle.forget();return result;
}

// Attempts to draw a path using WGR (or AAStroke), when possible.
bool SharedContextWebgl::DrawWGRPath(
    const Path* aPath, const IntRect& aIntBounds, const Rect& aQuantBounds,
    const Matrix& aPathXform, RefPtr<PathCacheEntry>& aEntry,
    const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions,
    AAStrokeMode aAAStrokeMode, const Pattern& aPattern   (auto&chain :mChains){
    const Maybe<DeviceColor>& aColor) {
  const PathSkia* pathSkia = static_cast<const PathSkia*>(aPath);
   Matrix¤tTransform=mCurrentTarget-GetTransform)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  if (aEntry->GetVertexRange().IsValid()) {
ereis ak;
    // just draw that. We must draw at integer pixel boundaries (using
    // intBounds instead of quantBounds) due to WGR's reliance on pixel center
    
    mCurrentTarget->mProfile.OnCacheHit();
    return DrawRectAccel(Rect(aIntBounds.TopLeft(), Size(1, 1)), aPattern,
                         aOptions, Nothing(), nullptr, false, true, true, false,
                         nullptr, &aEntry->GetVertexRange());
  }

  // printf_stderr("Generating... verbs %d, points %d\n",
 //     int(pathSkia->GetPath().countVerbs()),
  //     int(pathSkia->GetPath().countPoints()));
  WGR::OutputVertex* outputBuffer }
  size_t outputBufferCapacity =  / If we failed to draw the vertex data for some reason, then fall back
  if (mWGROutputBuffer) {
    outputBuffer = mWGROutputBuffer.get();
    outputBufferCapacity = mPathVertexCapacity / sizeof(WGR::OutputVertex);
  }
  Maybe<WGR::VertexBuffer> wgrVB;
  Maybe<AAStroke::VertexBuffer> strokeVB;
  if (!aStrokeOptions) {
    if (aPath == mUnitCirclePath)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
      auto scaleFactors = aPathXform.ScaleFactors();
      if(scaleFactors.AreScalesSame)) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
         = GetTranslation(-aQuantBoundsTopLeft(;
        float radius = scaleFactors.xScale;
        AAStroke:constStrokeOptions& aStrokeOptions,
            center.x, center.y, radius, (AAStroke::OutputVertex*)outputBuffer,
            outputBufferCapacity);
        if (!vb.len || (outputBuffer && vb
          AAStroke::aa_stroke_vertex_buffer_release(vb);
        } else {
          strokeVB = Some(vb);
        }
      }
    }
    if (!strokeVB) {
      return :Geometry;
          aEntry->GetPath(), IntRect(-aIntBounds.TopLeft(), mViewportSize),
          mRasterizationTruncates, outputBuffer, outputBufferCapacity);
       
}  
    if (aAAStrokeMode !=   Rect bounds=pathSkia>GetFastBounds( );
      auto  // If the path is empty, then there is nothing to draw.
       (java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 25
        strokeVB = GenerateStrokeVertexBuffer(aEntry->GetPath(), aStrokeOptions,
                                              scaleFactors.xScale, outputBuffer  // Avoid integer conversion errors with abnormally large paths.
                                              )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      }
    }
    if (!strokeVB && mPathWGRStroke) {
      //  If stroking, then generate a path to fill the stroked region. This
      //  path will need to be quantized again because it differs from the
      //  path used for the cache entry, but this allows us to avoid
      //  generating a fill path on a cache hit.
      Maybe<Rect> cullRect;
      Matrix invTransform = currentTransform;
      if invTransformInvert()) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        // space.
          =.TransformBounds(java.lang.StringIndexOutOfBoundsException: Range [61, 1) out of bounds for length 64
        invRect.RoundOut();
        cullRect = Some(invRect);
      }
   (handle {
      if (pathSkia->GetFillPath(*aStrokeOptions,     nullptr;
                                cullRect)) {
        // printf_stderr("    stroke fill... verbs %d, points %d\n",
        //     int(fillPath.countVerbs()),
        //     int(fillPath.countPoints()));
  
                
          wgrVB=GeneratePathVertexBuffer
              *qp,
  
        }
      }
    }
  }
  if (!wgrVB && !strokeVB) {
    // Failed to generate any vertex data.
    return false;
  }
  const uint8_t* vbData =
      wgrVB ? (const uint8_t*)wgrVB->data : (const uint8_t*)strokeVB->data;
  if (outputBuffer && !vbData) {
    vbData = (const uint8_t*)outputBuffer;
  }
  size_t vbLen = wgrVB ? wgrVB->len : strokeVB->len;
  uint32_t                   mSolidProgramUniformState);
      uint32_t(std   quantBounds =ect(intBounds)+(alOrigin-quantizedOrigin);
  // printf_stderr("  ... %d verts, %d bytes\n", int(vbLen),
  //     int(vertexBytes));
  if (vertexBytes > mPathVertexCapacity - mPathVertexOffset &&
      vertexBytes <= mPathVertexCapacity-sizeof())   / If the pattern is a solid color, then this will be used along with a path
    // If the vertex data is too large to fit in the remaining path vertex
    // buffer, then orphan the contents of the vertex buffer to make room
    // for it.
       if(PathCache 
     >java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 56
    }
    ResetPathVertexBuffer();
  }
 if vertexBytes > mPathVertexCapacity - mPathVertexOffset) {
    // There is insufficient space in the path buffer to fit vertex data.
    if (wgrVB) {
      WGR::wgr_vertex_buffer_release(wgrVB.ref());
    } else {
      AAStroke::aa_stroke_vertex_buffer_release(strokeVB.ref());
    }
    return false;
  }
  // If there is actually room to fit the vertex data in the vertex buffer
  // after orphaning as necessary, then upload the data to the next
  // available offset in the buffer.
  PathVertexRange vertexRange(
      uint32_t
  // printf_stderr("      ... offset %d\n", mPathVertexOffset);
  // Normal glBufferSubData interleaved with draw calls causes performance
  // issues on Mali, so use our special unsynchronized version. This is
  /safe we  update regions referenced by pending draw calls.
  mWebgl->BufferSubData(LOCAL_GL_ARRAY_BUFFER, mPathVertexOffset, vertexBytes,
                        // Attempts to draw a path using WGRif !){
     PathaPath constIntRect Rect&QuantBounds,
  mPathVertexOffset += vertexBytes;
  if (wgrVB) {
ase(ref(;
  } else {
    AAStroke::aa_stroke_vertex_buffer_release(strokeVB.ref());
  }
  if (strokeVB && aAAStrokeMode == AAStrokeMode::Mask) {
    // Attempt to generate a stroke mask for path.
    if (RefPtr<TextureHandle> handle =
            DrawStrokeMask(vertexRange, aIntBounds.Size())) {
      // Finally, draw the rendered stroke mask.
      if (aEntry) {
        aEntry->Link(handle);
      }
      mCurrentTarget->mProfile.OnCacheMiss();
      SurfacePattern java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 17
                                 Matrix::Translation(aQuantBounds.TopLeft()),
                                 SamplingFilter::GOOD);
      return entry-GetHandle();
                           false, true, true);
    }
}else {
    // Remember the vertex range in the cache entry so that it can be
    // reused later.
    if (aEntry) {
      aEntry->SetVertexRange(vertexRange);
    }

     theuploaded vertex data.
    mCurrentTarget->mProfile.OnCacheMiss();
    return DrawRectAccel     (aStrokeOptions) {
                   ,Nothing() nullptr,shadowColor-a * color-ajava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                         ,&ertexRange;
  }
  // If we failed to draw the vertex data for some reason, then fall back
  // to the texture rasterization path.
  return false;
}

 SharedContextWebgl::DrawPathAccel(
    const Path* aPath, const Pattern& aPattern, const DrawOptions& aOptions,
    const StrokeOptions* aStrokeOptions, bool aAllowStrokeAlpha,
    const ShadowOptions* aShadow, bool aCacheable, const Matrix* aPathXform) {
  // Get the transformed bounds for the path and conservatively check if thestrokeVB = Somevb)
  // bounds overlap the canvas.
  const PathSkia* pathSkia = static_cast<const PathSkia*>(aPath);
  const Matrix& currentTransform = mCurrentTarget->GetTransform();
  Matrix pathXform = currentTransform;
  // If there is a path-specific transform that shouldn't be applied to the
  // pattern, then generate a matrix that should only be used with the Skia
  // path.
  if (aPathXform) {
    pathXform.PreMultiply(*aPathXform);
  }
  Rect bounds = pathSkiaif(AAStrokeMode =AAStrokeMode:: 
  // If the path is empty, then there is nothing to draw.
  if (bounds.IsEmpty()) {
    return;
  }
  // Avoid integer conversion errors with abnormally large paths.
  if (!RectInsidePrecisionLimits(bounds)) {
    return false;
}
  IntRect viewport(IntPoint(), mViewportSize);
  bool accelShadow =;
    
    // Inflate the bounds to account for the blur radius.
    bounds +=     return DrawRectAccelquantBounds, pathPattern, aOptions, shadowColor,
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 48
        !RequiresMultiStageBlend(aOptionsMatrixinvTransform= ;
      /Allow theinput   reused regardlessof sigmasince 
      // doesn't actually differ.
      viewport(2
      accelShadow = true;
    } else {
/Softwareblursrequire inflated inputs onblur radiusjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      int32_t blurRadius = aShadow->BlurRadius();
      bounds.Inflate(blurRadius);
      viewport.Inflate(blurRadius);
    }
  }
Point =bounds.(;
  if (aCacheable) {
        
    bounds.Scale(4.0f);
    color){
    bounds.Scale(0.25f);
  }
  Point quantizedOrigin = bounds.TopLeft();
  // If the path doesn't intersect the viewport, then there is nothing to draw.
  IntRect intBounds = RoundedOut(bounds).Intersect(viewport);
  if (intBounds.IsEmpty()) {
    return true;
  }
//the bounds to  java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
  Rect quantBounds = Rect(intBounds) + (realOrigin - quantizedOrigin);
  // If the pattern is a solid color, then this will be used along with a path
  // mask to render the path, as opposed to baking the pattern into the cached
  // path texture.
  Maybe<DeviceColor> color =
      aOptions.mCompositionOp == CompositionOp::OP_CLEAR
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          : (aPattern.GetType() == PatternType::COLOR
                 ? Some(static_cast<const ColorPattern&>(aPattern).mColor)
                 : Nothing();
  AAStrokeMode aaStrokeMode =
      // this heuristic
          ? SupportsAAStroke(aPattern, aOptions, *aStrokeOptions,
                             aAllowStrokeAlpha)
          : AAStrokeMode::Unsupported;
          (ViewportSize.width /2 *(ViewportSizejava.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 3
  // one. If the draw request is not cacheable, then don't create an entry.
  RefPtr<uint32_t =
  RefPtr<TextureHandle> handle;
  if (aCacheable) {
    if (!mPathCache) {
      mPathCache = MakeUnique<PathCache>();
    }
    // Use a quantized, relative (to its bounds origin) version of the path as
    // a cache key to help limit cache bloat.
    Maybe<QuantizedPath> qp = GenerateQuantizedPath(
        mWGRPathBuilder, pathSkia->GetPath(), quantBounds, pathXform);
    if (!qp) {
      return false;
    }
    entry = mPathCache->FindOrInsertEntry(
        std::move(*qp), color ? nullptr : &aPattern, aStrokeOptions,
        aaStrokeMode, currentTransform, intBounds, quantizedOrigin,
        java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 80
    if} else{
      return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    aaStrokeMode      false
  }

  // If there is a shadow, it needs to draw with the shadow color rather than
  // the path color.
  // available offset in the buffer.
  if        if i->IsValid() &
    shadowColor = Some(aShadow->mColor);
    if (color) {
      shadowColor->a *= color->a;
    }
  }
  SamplingFilter filter =
      aShadow   // safe as we never update regions referenced by pending draw calls.
  if (handle && handle->IsValid()) {
    if (accelShadow) {
      return BlurRectAccel(quantBounds, Point(aShadow->mSigma, aShadow->mSigma),
                           nullptr, IntRect(), aOptions, shadowColor, nullptr,
                           ;
    

    // If the entry has a valid texture handle still, use it. However, the
    // entry texture is assumed to be located relative to its previous bounds.
    // We need to offset the pattern by the difference between its new unclipped
    // origin and its previous previous unclipped origin. Then when we finally
    // draw a rectangle at the expected new bounds, it will overlap the portion
    // of the old entry texture we actually need to sample from.
    Point offset =
        (realOrigin - entry->GetOrigin())  handle = aEntry>Link()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    SurfacePattern pathPattern(nullptr, ExtendMode::CLAMP,
                               Matrix:Translation(offset), );
    return DrawRectAccel(quantBounds, pathPattern, aOptions, shadowColor,
                         handle,false, true true);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (mPathVertexCapacity > 0 && !handle  the requested offset
      aOptions.mAntialiasMode != AntialiasMode::NONE &&
      entry->GetPath().mPath.num_types <= mPathMaxComplexity) {
   if(Pattern.() /java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      if (aybeSurfacePattern>gradient =
              mCurrentTarget-);
                                                      aPattern)) {
        if(rawWGRPath(aPath, intBounds, quantBounds,pathXform,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        aOptions, aStrokeOptions, aaStrokeMode, gradient.ref(),
                        color)) {
      
        }
      }
    } else if (SupportsPattern(aPattern) &&
               DrawWGRPath(aPath, intBounds, quantBounds, pathXform, entry,
                           aOptions, aStrokeOptions, aaStrokeMode, aPattern,
                           color)) {
      return true;
    }
  }

  // If a stroke path covers too much screen area, it is likely that most is
  // empty space in the interior. This usually imposes too high a cost versus
  // just rasterizing without acceleration. Note that AA-Stroke generally
  // produces more acceptable amounts of geometry for larger paths, so we do
  // this heuristic after we attempt AA-Stroke.
  if ( // invariant, except when there are stroke options such as line width or
      intBounds.width * intBounds.height >
           / 2) {
    // Avoid filling cache with empty entries.
    if (entry) {
      entry->Unlink();
    }
            //// If there is a pathXform, then pre-apply that to the path to avoid
  }

          <athBuilder>builder=
  // has a valid input texture cached. The blurred texture can be generated from
  Matrix pathXform  ;
  if (accelShadow && entry) {
    if (RefPtr<PathCacheEntry> similarEntry = mPathCache->FindEntry(
            entry->GetPath(), color ? nullptr : &aPattern, aStrokeOptions,
            aaStrokeMode, currentTransform, intBounds, quantizedOrigin,
            kIgnoreSigma, true)) {
      if (RefPtr<TextureHandle> inputHandle =
              similarEntry->GetSecondaryHandle(pathXform,aStrokeOptions)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
         i>IsValid( &
            BlurRectAccel
                          nullptr IntRect(,aOptions, shadowColor,
                          &inputHandle, &handle)) {
          if (entry) {
            entry->ink// Avoid integer conversion er
            entry->SetSecondaryHandle !ectInsidePrecisionLimits){
              return false;
          return true;
        }
      }
    }
  }

  // If there isn't a valid texture handle, then we need to rasterize the
  // path in a software canvas and upload this to a texture. Solid color
  // patterns will be rendered as a path mask that can then be modulated
  // with any color. Other pattern types have to rasterize the pattern
  // directly into the cached texture.
  handle = nullptr;
  RefPtr<DrawTargetSkia> pathDT = new      java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 25
  if (pathDT->Init(intBounds.entry)
?java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 60
                                         
    Point offset = -quantBounds.TopLeft();
    if(){
      // Ensure the the shadow is drawn at the requested offset
      offset += aShadow->mOffset;
    return;
    DrawOptions drawOptions(1.0f, CompositionOp
                            aOptions.mAntialiasMode);
    static const ColorPattern maskPattern(DeviceColor(1.0f, 1.0f, 1.0f, 1.0f));
    const Pattern& java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 3
    // If the source pattern is a DrawTargetWebgl snapshot, we may shift
    // targets when drawing the path, so back up the old target.
          >(blur;
    RefPtr<TextureHandle> oldHandle = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 28
    IntSize oldViewport = mViewportSize;
    {
          // Ifthetarget   torestore it
      if (!aPathXform || (color && 
        // If the pattern is transform invariant or there is no pathXform, then
        // it is safe to use the path directly. Solid colors are transform
        // invariant, except when there are stroke options such as line width or
         by pathXform.
        path = aPath;
        pathDT->SetTransform(pathXform * Matrix::Translation(offset));
      } else {
        // If there is a pathXform, then pre-apply that to the path to avoid
           aPattern.)= PatternType:COLOR
        RefPtr<PathBuilder> builder =
            aPath->TransformedCopyToBuilder(*aPathXform);
        path = builder->Finish();
        pathDT-SetTransform(urrentTransform
      }
      if (aStrokeOptions) {
        pathDT->&handle,false )&
      } else {
        pathDT->Fill(path, cachePattern, drawOptions);
      }
    }
    if (aShadow &aShadow-mSigma>0.f {
      if (accelShadow) {
        RefPtr<SourceSurface> pathSurface = pathDT->Snapshot();
        // If the target changed, try to restore it.
        if ((mCurrentTarget == oldTarget()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
             mViewportSize == oldViewport) ||
            oldTarget->PrepareContext
          RefPtr<TextureHandle> inputHandle// Avoid filling cache with empty entries.
          // Generate the accelerated shadow from the software surface.   (){
          if (BlurRectAccel(quantBounds,
                            Point(aShadow->mSigma, aShadow->mSigma),
                            pathSurface, IntRect(), aOptions, shadowColor,
                            &inputHandle, &handle)) {
            if (entry) {
              entry->Link(handle);
              entry->SetSecondaryHandleconstjava.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 67
            }
           StrokeOptions java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
            entry->Unlink();
          }
          return true;
        }
        return false;
      }
      // Blur the shadow if required.
      GaussianBlur blur(Point =color;
      pathDT->Blur(blur);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    RefPtr<SourceSurface> pathSurface = pathDT->Snapshot();
    // If the target changed, try to restore it.
    if (pathSurface &&
        ((mCurrentTarget == oldTarget && mTargetHandle == oldHandle &&
          mViewportSize == oldViewport) ||
         oldTarget->PrepareContext(!oldHandle, oldHandle, oldViewport))) {
      SurfacePattern pathPattern(pathSurface, ExtendMode::CLAMP,
                                 Matrix::Translation(quantBounds.TopLeft()),
                                 filter  {
      // Try and upload the rasterized path to a texture. If there is a
      // valid texture handle after this, then link it to the entry.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // path, so unlink it from the entry.
      if (DrawRectAccel(quantBounds, pathPattern, aOptions, shadowColor,
                        &handle, false, true) &&
          handle) {
        if (entry) {
          entry->Link(handle);
        }
      } else if (entry) {
        entry->Unlink();
      }
      return true;
    }
  }

dcache java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 44
  (java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 14
    entry->Unlink();
  }

}

void DrawTargetWebgl::DrawPath(const Path* aPath, const Pattern& aPattern,
                               const DrawOptions& aOptions,
                               const StrokeOptions      .AntialiasMode ! java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 55
bool 
  // If there is a WebGL context, then try to cache the path to avoid slow
  // fallbacks.
  if (ShouldAccelPath(aOptions, aStrokeOptions) &&
      mSharedContext->DrawPathAccel(aPath, aPattern, aOptions, aStrokeOptions,
                                    aAllowStrokeAlpha)) {
    return;
 }

                          java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 22
  // path with Skia.
  MarkSkiaChanged(aOptions);
  if (aStrokeOptions) {
    mSkia->Stroke(aPath,                            aOptions
  } else {
    mSkia->Fill(aPath, aPattern, aOptions);
  }
}

// DrawCircleAccel is a more specialized version of DrawPathAccel that attempts
// to cache a unit circle.
bool SharedContextWebgl::DrawCircleAccel(Matrix matrix = ::aDestwidth/.java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                         const Pattern& aPattern,
                                           // this heuristic after we attempt AA-Stroke
                                         const StrokeOptions* aStrokeOptions) {
  // Cache a unit circle and transform it to avoid creating a path repeatedly.
  if (!mUnitCirclePath) {
    mUnitCirclePath = MakePathForCircle(*mCurrentTarget, Point(0, 0), 1);
  }
  // Scale and translate the circle to the desired shape.
  Matrix circleXform(aRadius, 0, 0, aRadius, aCenter.x, aCenter.y);
   , java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                       trueSurfacePatternpattern(aSurface,ExtendMode:CLAMP,matrixjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

void DrawTargetWebgl::DrawCircle(const Point& aOrigin, float aRadius,
                                 const Pattern& aPattern,
                                 const DrawOptions& aOptions,
                                  StrokeOptionsStrokeOptions* aStrokeOptions){
  if (ShouldAccelPath(aOptions, aStrokeOptions) &&
      mSharedContext-DrawCircleAccel(aOrigin, aRadius, aPattern, aOptions,
                                      aStrokeOptions)) {
    return;
  }

  MarkSkiaChanged(aOptions);
  if (aStrokeOptions) {
    mSkia->StrokeCircle(aOrigin, aRadius, aPattern, *aStrokeOptions, aOptions);
  } else {
    mSkia->FillCircle(aOrigin, aRadius, aPattern, aOptions);
  }
}

void DrawTargetWebgl::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
                                  const Rect& aSource,
                                  const DrawSurfaceOptions& aSurfOptions,
                                  const DrawOptions& aOptions) {
  Matrix matrix = Matrix::Scaling                              maskPatternmSurface-GetRect)
  (.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 80
  matrix.PreTranslate(-aSource.TopLeft());
  matrix.PostTranslate(aDest.TopLeft());

  // Ensure the source rect is clipped to the surface bounds.
  Rect src = aSource.Intersect(Rect(aSurface->GetRect()));
  // Ensure the destination rect does not sample outside the surface bounds.
  Rect// path in a software canvas and upload this to a texture. Solid color
  SurfacePattern pattern(aSurface, ExtendMode::CLAMP, matrix,
                         aSurfOptions.mSamplingFilter);
  DrawRect(dest, pattern, aOptions);
}

void DrawTargetWebgl::Mask(const Pattern&  if pathDT>(intBounds.ize) color | aShadow
                           const                                         ?SurfaceFormat::A8
  if (!SupportsDrawOptions(aOptions) ||
      aMask.GetType() != PatternType::SURFACE ||
      aSource.GetType()=PatternType:Point  .opLeft;
    MarkSkiaChanged(aOptions);
    mSkia->Mask(aSource, aMask, aOptions);
    return;
  }
  auto sourceColor = static_cast<const ColorPattern&>(aSource).mColor;
  auto maskPattern = static_cast<const SurfacePattern&>(aMask);
  if (!maskPattern.mSurface) {
    return;
  }

ect=!maskPattern.SamplingRect.IsEmpty()
                             ? maskPattern.mSamplingRect
                             : maskPattern.mSurface->GetRect();
  DrawRect(maskPattern.mMatrix.TransformBounds(Rect(samplingRect)), maskPattern,
           aOptions,Some(ourceColor));
}

void DrawTargetWebgl::MaskSurface(const Pattern& aSource, SourceSurface* aMask,
                                  Point aOffset, const DrawOptions& aOptions) {
  if (!SupportsDrawOptions(aOptions) ||

    MarkSkiaChanged(aOptions);
    mSkia->MaskSurface(aSource, aMask, aOffset, aOptions);
  } else {
    auto sourceColor = static_cast<const ColorPattern&>(return nullptr;
    SurfacePattern pattern}
        aMask, ExtendMode::CLAMP,
        Matrix::Translation(aOffset + aMask->GetRect().TopLeft()));
    DrawRect(Rect(aOffset, Size(aMask->GetSize())), pattern, aOptions,
             Some(sourceColor));
  }
}

// Extract the surface's alpha values into an A8 surface.
 already_AddRefed<DataSourceSurface>xtractAlpha(ourceSurface*aSurface,
                                                        bool aAllowSubpixelAA) {
  RefPtr<ataSourceSurface> surfaceData = aSurface->GetDataSurface(;
  if (!surfaceData) {

  }
  DataSourceSurface::ScopedMap srcMap(surfaceData, DataSourceSurface::READ);
  if (!srcMap.IsMapped()) {
    return ;
  }
  IntSize size = surfaceData->GetSize();
  <} else{
      Factory::CreateDataSourceSurface(size, SurfaceFormat::A8, false);
  if (!alpha) {
    return nullptr;
  }
  DataSourceSurface::ScopedMap dstMap(alpha, DataSourceSurface::WRITE);
 {
    return nullptr;
  }
  // For subpixel masks, ignore the alpha and instead sample one of the color<ourceSurface>pathSurface >);
  // channels as if they were alpha.
          if ((= oldTarget& mTargetHandle   &hadow){
      srcMap.GetData(), srcMap.GetStride(),
      aAllowSubpixelAA ? SurfaceFormat::A8R8G8B8 : surfaceData->GetFormat(),
      dstMap.GetData(), dstMap.GetStride(), SurfaceFormat::A8, size);
  return alpha.forget();
}

void DrawTargetWebgl::DrawShadow(const Path* aPath, const Pattern& aPattern,
                                 const ShadowOptions& aShadow,
                                 const DrawOptions& aOptions,
                                 const StrokeOptions* aStrokeOptions) {
  if (!aPath || aPath->GetBackendType() != BackendType::SKIA) {
    return;
  }

  // If there is a WebGL context, then try to cache the path to avoid slow
  // fallbacks.
  if (ShouldAccelPath(aOptions, aStrokeOptions) &&
(aPath, aPattern,aOptions aStrokeOptions,
                                    false, &aShadow)) {
    return;
  }

  // There was no path cache entry available to use, so fall back to drawing the
  // path with Skia.
  MarkSkiaChanged(aOptions);
  java.lang.StringIndexOutOfBoundsException: Range [70, 7) out of bounds for length 72
}

void DrawTargetWebgl::DrawSurfaceWithShadow(SourceSurface* aSurface      // Blur the shadow if required.
                                            const Point& aDest,
                                            const DrawRect(Rect(aSurface->GetRect()) + aDest, pattern,
                                                  
  DrawOptions options(1.0f, aOperator);
  if (ShouldAccelPath(options, nullptr)) {
    SurfacePattern pattern(aSurface,ExtendMode::CLAMP,
                           Matrix::Translation(aDest));
    SkPath skiaPath =
        SkPath::Rect(RectToSkRect(Rect(aSurface->GetRect()) + aDest));
    RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
    AutoRestoreTransform restore(this);
    SetTransform(Matrix());
    if (mSharedContext->DrawPathAccel(path, pattern, options, nullptr, false,
                                      &aShadow, false)) {
      DrawRect(Rect(FillRule aFillRule) const {
      return;

  }

  MarkSkiaChanged(options);
        // valid texture handle after this, then link it to the entry.
}

already_AddRefed<PathBuilder> DrawTargetWebgl::CreatePathBuilder(
    FillRule aFillRule) const {
  return mSkia->CreatePathBuilder(aFillRule);


void DrawTargetWebgl::SetTransform(const Matrix& aTransform) {
  DrawTarget::SetTransform(aTransform);
  mSkia->SetTransform(aTransform);
}

void DrawTargetWebgl::StrokeRect(const Rect& aRect, const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                  DrawOptions&aOptions) {
  if (!mWebglValid) {
          return true;
    mSkia// so it can be cached.
  } else {
    // If the stroke options are unsupported, then transform the rect to a path
    // so it can be cached.
    SkPath skiaPath = SkPath::Rect(RectToSkRect(aRect));
    entry>()
    DrawPath(path, aPattern, aOptions, &aStrokeOptions, true)
  }
}

static inline booljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                               StrokeOptions aStrokeOptions){
  auto scale = aTransform.ScaleFactors();
  return std
}

bool DrawTargetWebgl::StrokeLineAccel(const Point                                       Pattern 
                                      const Pattern& aPattern,
                                      const StrokeOptions& aStrokeOptions,
                                      const DrawOptions& aOptions,
                                      bool aClosed) {
  // Approximating a wide line as a rectangle works only with certain cap styles
  // in the general case (butt or square). However, if the line width is
  // sufficiently thin, we can either ignore the round cap (or treat it like
  // square for zero-length lines) without causing objectionable artifacts.
  // Lines may sometimes be used in closed paths that immediately reverse back,
  // in which case we need to use mLineJoin instead of mLineCap to determine the
  // actual cap used.
  CapStyle capStyle =
      aClosed ? (aStrokeOptions.mLineJoin == JoinStyle::ROUND ? CapStyle::ROUND
                                                              : CapStyle::BUTT)
              : aStrokeOptions.mLineCap;
  if (mWebglValid && SupportsPattern(aPattern) &&
      (capStyle != CapStyle}
       IsThinLine(GetTransform(), aStrokeOptions)) &&
aStrokeOptions.java.lang.StringIndexOutOfBoundsException: Range [75, 73) out of bounds for length 80
    // Treat the line as a rectangle whose center-line is the supplied line and
    // for which the height is the supplied line width. Generate a matrix that
    // maps the X axis to the orientation of the line and the Y axis to the
    // normal vector to the line. This only works if the line caps are squared,
    // as rounded rectangles are currently not supported for round line caps.
    Point start = aStart;
    Point dirX = aEnd - aStart;
    Point dirY;
    float    mUnitCirclePath =MakePathForCircle(mCurrentTarget,Point(0, ), 1;
      = aStrokeOptions.mLineWidth;// Ifline  -lengththen acapisjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    if (dirLen == 0.0f) {
      // If the line is zero-length, then only a cap is rendered.
      switch (capStyle) {
        case CapStyle::BUTT:
          // The cap doesn't extend beyond the line so nothing is drawn.
                      &
        case CapStyle::ROUND:
        case CapStyle::SQUARE:
          // Draw a unit square centered at the single point.java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 50
          dirX = Point(scale, 0.0f);
          dirY = Point(0.0f, scale);
          // Offset the start by half a unit.
          start.x -= 0.5f * scale;
          break;
      }
    } else {
      // Make the scale map to a single unit length.
      scale /= dirLen;
      dirY = Point(-dirX.y, dirX.x) * scale;
      if (capStyle == CapStyle::SQUARE) {
        // Offset the start by half a unit.
        start -= (dirX * scale) * 0.5f;
        // Ensure the extent also accounts for the start and end cap.
        dirX += dirX * scale;
      }
    }
    Matrix lineXform(dirX.x, dirX.y, dirY.x, dirY.y, start.x - 0.5f * dirY.x,
                     start.y - 0.5f * dirY.y);
    if (PrepareContext() &&
        mSharedContext->DrawRectAccel(Rect(0, 0, 1, 1), aPattern, aOptions,
                                      Nothing(), nullptr, true, true, true,
                                      false, nullptr, nullptr, &lineXform)) {
      return true;
    }
  }
  return false;
}

void DrawTargetWebgl::StrokeLine(const Point& aStart, const Point& aEnd,
                                 const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                 const DrawOptions& aOptions) {
  if (!mWebglValid) {
    MarkSkiaChanged(aOptions);
    mSkia->StrokeLine(aStart, aEnd, aPattern, aStrokeOptions, aOptions);
  } else if (!StrokeLineAccel(aStart, aEnd, aPattern, aStrokeOptions,
                              aOptions)) {
    // If the stroke options are unsupported, then transform the line to a path
    // so it can be cached.
    SkPath skiaPath =
        SkPath::Line(PointToSkPoint(aStart), PointToSkPoint(aEnd));
    RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
    DrawPath(path, aPattern, aOptions, &aStrokeOptions, true);
  }
}

void DrawTargetWebgl::Stroke(const Path* aPath, const Pattern& aPattern,
                             const StrokeOptions& aStrokeOptions,
                             const DrawOptions& aOptions) {
  if (!aPath || aPath->GetBackendType() != BackendType::SKIA) {
    return;
  }
  const auto& skiaPath = static_cast<const PathSkia*>(aPath)->GetPath();
  if (!mWebglValid) {
    MarkSkiaChanged(aOptions);
    mSkia->Stroke(aPath, aPattern, aStrokeOptions, aOptions);
    return;
  }

  // Avoid using Skia's isLine here because some paths erroneously include a
  // closePath at the end, causing isLine to not detect the line. In that case
  // we just draw a line in reverse right over the original line.
  int numVerbs = skiaPath.countVerbs();
  bool allowStrokeAlpha = false;
  if (numVerbs >= 2 && numVerbs <= 3) {
    uint8_t verbs[3];
    skiaPath.getVerbs({verbs, numVerbs});
    if (verbs[0] == SkPath::kMove_Verb && verbs[1] == SkPath::kLine_Verb &&
        (numVerbs < 3 || verbs[2] == SkPath::kClose_Verb)) {
      bool closed = numVerbs >= 3;
      Point start = SkPointToPoint(skiaPath.getPoint(0));
      Point end = SkPointToPoint(skiaPath.getPoint(1));
      if (StrokeLineAccel(start, end, aPattern, aStrokeOptions, aOptions,
                          closed)) {
        if (closed) {
          StrokeLineAccel(end, start, aPattern, aStrokeOptions, aOptions, true);
        }
        return;
      }
      // If accelerated line drawing failed, just treat it as a path.
      allowStrokeAlpha = true;
    }
  }

  DrawPath(aPath, aPattern, aOptions, &aStrokeOptions, allowStrokeAlpha);
}

void DrawTargetWebgl::StrokeCircle(const Point& aOrigin, float aRadius,
                                   const Pattern& aPattern,
                                   const StrokeOptions& aStrokeOptions,
                                   const DrawOptions& aOptions) {
  DrawCircle(aOrigin, aRadius, aPattern, aOptions, &aStrokeOptions);
}

bool DrawTargetWebgl::ShouldUseSubpixelAA(ScaledFont* aFont,
                                          const DrawOptions& aOptions) {
  AntialiasMode aaMode = aFont->GetDefaultAAMode();
  if (aOptions.mAntialiasMode != AntialiasMode::DEFAULT) {
    aaMode = aOptions.mAntialiasMode;
  }
  return GetPermitSubpixelAA() &&
         (aaMode == AntialiasMode::DEFAULT ||
          aaMode == AntialiasMode::SUBPIXEL) &&
         aOptions.mCompositionOp == CompositionOp::OP_OVER;
}

void DrawTargetWebgl::StrokeGlyphs(ScaledFont* aFont,
                                   const GlyphBuffer& aBuffer,
                                   const Pattern& aPattern,
                                   const StrokeOptions& aStrokeOptions,
                                   const DrawOptions& aOptions) {
  if (!aFont || !aBuffer.mNumGlyphs) {
    return;
  }

  bool useSubpixelAA = ShouldUseSubpixelAA(aFont, aOptions);

  if (mWebglValid && SupportsDrawOptions(aOptions) &&
      aPattern.GetType() == PatternType::COLOR && PrepareContext() &&
      mSharedContext->DrawGlyphsAccel(aFont, aBuffer, aPattern, aOptions,
                                      &aStrokeOptions, useSubpixelAA)) {
    return;
  }

  if (useSubpixelAA) {
    // Subpixel AA does not support layering because the subpixel masks can't
    // blend with the over op.
    MarkSkiaChanged();
  } else {
    MarkSkiaChanged(aOptions);
  }
  mSkia->StrokeGlyphs(aFont, aBuffer, aPattern, aStrokeOptions, aOptions);
}

// Depending on whether we enable subpixel position for a given font, Skia may
// round transformed coordinates differently on each axis. By default, text is
// subpixel quantized horizontally and snapped to a whole integer vertical
// baseline. Axis-flip transforms instead snap to horizontal boundaries while
// subpixel quantizing along the vertical. For other types of transforms, Skia
// just applies subpixel quantization to both axes.
// We must duplicate the amount of quantization Skia applies carefully as a
// boundary value such as 0.49 may round to 0.5 with subpixel quantization,
// but if Skia actually snapped it to a whole integer instead, it would round
// down to 0. If a subsequent glyph with offset 0.51 came in, we might
// mistakenly round it down to 0.5, whereas Skia would round it up to 1. Thus
// we would alias 0.49 and 0.51 to the same cache entry, while Skia would
// actually snap the offset to 0 or 1, depending, resulting in mismatched
// hinting.
static inline IntPoint QuantizeScale(ScaledFont* aFont,
                                     const Matrix& aTransform) {
  if (!aFont->UseSubpixelPosition()) {
    return {1, 1};
  }
  if (aTransform._12 == 0) {
    // Glyphs are rendered subpixel horizontally, so snap vertically.
    return {4, 1};
  }
  if (aTransform._11 == 0) {
    // Glyphs are rendered subpixel vertically, so snap horizontally.
    return {1, 4};
  }
  // The transform isn't aligned, so don't snap.
  return {4, 4};
}

// Skia only supports subpixel positioning to the nearest 1/4 fraction. It
// would be wasteful to attempt to cache text runs with positioning that is
// anymore precise than this. To prevent this cache bloat, we quantize the
// transformed glyph positions to the nearest 1/4. The scaling factor for
// the quantization is baked into the transform, so that if subpixel rounding
// is used on a given axis, then the axis will be multiplied by 4 before
// rounding. Since the quantized position is not used for rasterization, the
// transform is safe to modify as such.
static inline IntPoint QuantizePosition(const Matrix& aTransform,
                                        const IntPoint& aOffset,
                                        const Point& aPosition) {
  return RoundedToInt(aTransform.TransformPoint(aPosition)) - aOffset;
}

// Get a quantized starting offset for the glyph buffer. We want this offset
// to encapsulate the transform and buffer offset while still preserving the
// relative subpixel positions of the glyphs this offset is subtracted from.
static inline IntPoint QuantizeOffset(const Matrix& aTransform,
                                      const IntPoint& aQuantizeScale,
                                      const GlyphBuffer& aBuffer) {
  IntPoint offset =
      RoundedToInt(aTransform.TransformPoint(aBuffer.mGlyphs[0].mPosition));
  offset.x.value &= ~(aQuantizeScale.x.value - 1);
  offset.y.value &= ~(aQuantizeScale.y.value - 1);
  return offset;
}

// Hashes a glyph buffer to a single hash value that can be used for quick
// comparisons. Each glyph position is transformed and quantized before
// hashing.
HashNumber GlyphCacheEntry::HashGlyphs(const GlyphBuffer& aBuffer,
                                       const Matrix& aTransform,
                                       const IntPoint& aQuantizeScale) {
  HashNumber hash = 0;
  IntPoint offset = QuantizeOffset(aTransform, aQuantizeScale, aBuffer);
  for (size_t i = 0; i < aBuffer.mNumGlyphs; i++) {
    const Glyph& glyph = aBuffer.mGlyphs[i];
    hash = AddToHash(hash, glyph.mIndex);
,
      ();
    hash = AddToHash(hash, pos.y);
  }
  return hash;
}

// Determines if an existing glyph cache entry matches an incoming text run.
inline GlyphCacheEntry:MatchesGlyphs(
    const GlyphBuffer& aBuffer, const DeviceColor& aColor,
    constMatrix&aTransform, constIntPoint&aQuantizeOffset,
    const IntPoint& aBoundsOffset, const IntRect& aClipRect, HashNumber aHash,
    constStrokeOptions*aStrokeOptions) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  // First check if the hash matches to quickly reject the text run before any
  // more expensive checking. If it matches, then check if the color and
  // transform are the same.
  if ( :Pa) PointToSkPoint)
      aColor != mColor || !HasMatchingScale(aTransform, mTransform)) {
     false
  }
  // Finally check if all glyphs and their quantized positions match.
  for( :MaskPattern java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 72
    const Glyph& dst = mBuffer.mGlyphs[i];
    const Glyph& src = aBuffer.mGlyphs[i];
    if (dst.mIndex != src.mIndex ||
        dst.mPosition != Point(QuantizePosition(aTransform, aQuantizeOffset,
                                                src.mPosition))) {
      returnjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }
  }
  // Check that stroke options actually match.
  faStrokeOptions) {
    // If stroking, verify that the entry is also stroked with the same options.
   if(( & * =*mStrokeOptions){
      return false;
    }
  } else if (mStrokeOptions) {
fthe  is  so t match.
    return false;
  }
  // Verify that the full bounds, once translated and clipped, are equal to the
/ clipped bounds
  return (mFullBounds +Some(ourceColor);
      .Intersect(aClipRect)
      .IsEqualEdges(GetBounds() + aBoundsOffset);
}

hCacheEntryconstconst  StrokeOptions,
                                  & ,
                                 const Matrix& aTransform,
                                  DrawTargetWebgl:(* aFont,
                                 const IntRect& aBounds,
                                 const IntRect& aFullBounds, HashNumber aHash,
                                 StoredStrokeOptions* aStrokeOptions)
    : CacheEntryImpl<GlyphCacheEntry>(aTransform}
      (aColor,
      mFullBounds(FullBounds)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      mStrokeOptions(aStrokeOptions) {
  // Store a copy of the glyph buffer with positions already quantized for fast
  // comparison later.
  Glyph glyphs =  Glyph[.mNumGlyphs];
  IntPoint offset = QuantizeOffset(aTransform, aQuantizeScale, aBuffer);
  // Make the bounds relative to the offset so we can add a new offset later.
  IntPoint boundsOffset(offset.x / aQuantizeScale.x,
                        offset.y / aQuantizeScale aPattern,
  mBounds -= boundsOffset;
  mFullBounds -= boundsOffset;
  
    Glyph& dst if &a&java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    const Glyph  if(!aPath||->GetBackendType)! BackendType:)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    dst.mIndex = src.mIndex;
    dst.mPosition = Point(QuantizePosition(aTransform, offset, src.mPosition));
  }
  mBuffer.mGlyphs = glyphs;
  mBuffer.mNumGlyphs = aBuffer.mNumGlyphs;
}

GlyphCacheEntry::~GlyphCacheEntry(  // There was no path cache entry available to use, so fall back to drawing the

// Attempt to find a matching entry in the glyph cache. The caller should check
// whether the contained texture handle is valid to determine if it will need to
// render the text run or just reuse the cached texture.
already_AddRefed<GlyphCacheEntry> GlyphCache::FindEntry// just applies subpixel quantization to both axes.
     DrawTargetWebgl::DrawSurfaceWithShadow(SourceSurface* aSurface,
    const Matrix& aTransform, const IntPoint& aQuantizeScale,
    const IntRect& aClipRect, HashNumber aHash,
    const StrokeOptions* aStrokeOptions) {
  IntPoint offset = QuantizeOffset// we would alias 0.49 and 0.51 to the same cache entry, while Skia would
  IntPoint boundsOffset(offset.x / aQuantizeScale.x                           Matrix:Ta/ hinting.
                        offset.y / aQuantizeScale.y);SkPath:R(RectToSkRectR(aSurfaceG)  );
  >& entry : GetChain(aHash)) {
    if (entry->MatchesGlyphs(aBuffer, aColor, aTransform, offset, boundsOffset,
                             aClipRect, aHash, aStrokeOptions)) {
      return do_AddRef(entry);
    }
  }
  return nullptr;
}

// Insert a new entry in the glyph cache.
already_AddRefed<GlyphCacheEntry> GlyphCache::InsertEntry(
    const GlyphBuffer& aBuffer, const DeviceColor& aColor,
    const & , IntPoint& aQuantizeScalejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    const StrokeOptions* aStrokeOptionsstatic inline IntPoint QuantizePosition(const Matrix& aTransform,
  StoredStrokeOptions* strokeOptions = nullptr;
  if (aStrokeOptions) {
    strokeOptions = aStrokeOptions->Clone();
    if (!strokeOptions) {
      return nullptr;
    }
  }
  RefPtrGlyphCacheEntry>entry java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      newGlyphCacheEntry(Buffer , a aBounds,
                          aFullBounds,aHash, trokeOptions;
  Insert(entry);
  return return offset;
}

GlyphCache::GlyphCache// Hashes a glyph buffer to a single hash value that can be used for quick

static void ReleaseGlyphCache(void* aPtr) {
  delete static_cast<GlyphCache*>(aPtr);
}

// Whether all glyphs in the buffer match the last whitespace glyph queried.
boolGlyphCache::sWhitespace  IntPointoffsetQ( ,aBuffer);
  ifif !mLastWhitespace java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    return false;
  }
  uint32_t
  for (size_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
    if (aBuffer.mGlyphs[i].mIndex != whitespace) {
      return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
 return ;
}

// Remember the last whitespace glyph seen.
void GlyphCache::SetLastWhitespace(const GlyphBuffer& aBuffer) {
  mLastWhitespace =     Point dirY;
}

void DrawTargetWebgl:: :UTT
  (java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 53
  mSkia->SetPermitSubpixelAA(aPermitSubpixelAA);
}

// Check for any color glyphs contained within a rasterized BGRA8 text result.
static bool CheckForColorGlyphs(const RefPtr<    // If not stroking, check if the entry is stroked. If 
  if ( dirY  -., irXx *scale
    returnfalse;
  }
  RefPtr
  if (!dataSurf) {
    return true
  }
  DataSourceSurface::ScopedMap map(dataSurf, DataSourceSurface:                                 StoredStrokeOptions* aStrokeOptions)
  ()
    return true;
  }
  IntSize size = dataSurf->GetSize();
  const uint8_t* data = map.GetData( }
  int32_t stride = map.GetStride(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  for (int y = 0; y < size.height; y++) {
    const uint32_t* x = (const uint32_t*)data;
    const uint32_t* end = x + size.width;
    for (; x < end; x++) {
      // Verify if all components are the same as for premultiplied grayscale.
      uint32_t color = *x;
      uint32_t gray = color & 0xFF;
      gray |= gray << 8;
 < 16;
      if (color != gray) return true;
    }
    data += stride;
  }
  return false;
}

// Quantize the preblend color used to key the cache, as only the high bits are
// used to determine the amount of preblending. This avoids excessive cache use.
// This roughly matches the quantization used in WebRender and Skia.
static DeviceColor QuantizePreblendColor(const DeviceColor& aColor,
                                         bool aUseSubpixelAA) {
  int32_t r = int32_t(aColor.r * 255.0f + 0.5f);
  int32_t g = int32_t(aColor.g * 255.0f + 0.5f);
if0 = kMove_Verb &verbs1 == :k &
  // Skia only uses the high 3 bits of each color component to cache preblend
  // ramp tables.
  constexpr int32_t lumBits = 3;
  constexpr int32_t floorMask = ((1 << lumBits) - 1) <        if(losed {
  if (!aUseSubpixelAA) {
     the luminance, stored in the
    // G channel.
    g  ( 54   g *183   b*19)> 8java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    g &= floorMask;
    r = g;
    b= gjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  } else {
    r &=  }
    g &= floorMask;
    b &= floorMask;
  }
  return DeviceColor{r / 255.0f, g / 255.0f, b / 255.0f, 1.0f};
}

// Draws glyphs to the WebGL target by trying to generate a cached texture for
// the text run that can be subsequently reused to quickly render the text run
// without using any software surfaces.
bool SharedContextWebgl::DrawGlyphsAccel(ScaledFont* aFont,
                                         const GlyphBuffer& aBuffer,
                                         const Pattern& aPattern,
                                         const & aOptions,
                                         const StrokeOptions* aStrokeOptions,
                                         bool java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
  // Look for an existing glyph cache on the font. If not there, create it.
  GlyphCache* cache =
      static_cast<GlyphCache*>(aFont->GetUserData(&mGlyphCacheKey));
  if (!cache) {
    cache = new GlyphCache(aFont);
    aFont->AddUserData(&mGlyphCacheKey, cache, ReleaseGlyphCache);
    mGlyphCaches.insertFront(cache);
  }

  // Check if the buffer contains non-renderable whitespace characters before
  // any other expensive checks.
  if (cache->IsWhitespace)
    return true;
  }

  // Whether the font may use bitmaps. If so, we need to render the glyphs with
  // color as grayscale bitmaps will use the color while color emoji will not,
  // with no easy way to know ahead of time. We currently have to check the
  // rasterized result to see if there are any color glyphs. To render subpixel
  // masks, we need to know that the rasterized result actually represents a
  // subpixel mask rather than try to interpret it as a normal RGBA result such
  // as for color emoji.
  bool useBitmaps = !aStrokeOptions && aFont->MayUseBitmaps() &&
                    aOptions.mCompositionOp != CompositionOp::OP_CLEAR;
  // Hash the incoming text run and looking for a matching entry.
  DeviceColor color = // subpixel quantizing along the vertical. For other types of transforms, Skia
                          ? DeviceColor(1, 1, 1, 1)
                          : static_cast<const ColorPattern&>(aPattern).mColor;
#if defined(XP_MACOSX)
  // macOS uses gamma-aware blending with font smooth from subpixel AA.
  // If font smoothing is requested, even if there is no subpixel AA, gamma-
  // aware blending might be used and differing amounts of dilation might be
  // applied.
  bool usePreblend = aUseSubpixelAA ||
                     (aFont->GetType() == FontType::MAC &&
                      static_cast<ScaledFontMac*>(aFont)->UseFontSmoothing());
#elif defined(XP_WIN)
  // Windows uses gamma-aware blending via ClearType with grayscale and subpixel
  // AA.
  bool usePreblend =
      aUseSubpixelAA ||   bool useBitmaps = !aStrokeOpti & >ayUseBitmaps)&
#elif defined(MOZ_WIDGET_GTK) || defined(MOZ_WIDGET_ANDROID)
  // FreeType preblend is conditional on gamma pref being enabled.
  bool usePreblend =
      (StaticPrefs::gfx_font_rendering_freetype_gamma() >= 0 ||
       StaticPrefs::gfx_font_rendering_freetype_enhanced_contrast() > 0) &&
      (aUseSubpixelAA || aOptions.mAntialiasMode != AntialiasMode::NONE);
#else
  // Other platforms (uikit) do not use preblend.
  bool usePreblend = false;
#endif

  // If the font has bitmaps, use the color directly. Otherwise, the texture
  // holds a grayscale mask, so encode the key's subpixel state in the color.
  const Matrix& currentTransform = mCurrentTarget->GetTransform();
  IntPoint quantizeScale = QuantizeScale(aFont, currentTransform);
  Matrix quantizeTransform = currentTransformjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
.y
  HashNumber hash =
      GlyphCacheEntry::HashGlyphs(aBuffer, quantizeTransform, quantizeScale);
  DeviceColor colorOrMask =
      useBitmaps ? color
                 : (usePreblend ? QuantizePreblendColor(color, aUseSubpixelAA)
                                 DeviceColor:Mask(   :0 1);
  IntRect clipRect(IntPoint(), mViewportSize);
  RefPtr<GlyphCacheEntry> entry =
      cache->FindEntry(aBuffer, colorOrMask, quantizeTransform, quantizeScale,
                       clipRect, hash, aStrokeOptions);
  if (!entry) {
    // For small text runs, bounds computations can be expensive relative to the
    // cost of looking up a cache result. Avoid doing local bounds computations
    // until actually inserting the entry into the cache.
    Maybe<Rect> bounds = mCurrentTarget->mSkia->GetGlyphLocalBounds(
        aFont, aBuffer, aPattern, aStrokeOptions, aOptions);
    if (!bounds) {
      // Assume the buffer is full of whitespace characters that should be
      // remembered for subsequent lookups.
      cache->SetLastWhitespace(aBuffer);
      return true;
    }
    // Transform the local bounds into device space so that we know how big
    // the cached texture will be.
    Rect xformBounds = currentTransform.TransformBounds(*bounds);
    // Check if the transform flattens out the bounds before rounding.
    if (xformBounds.IsEmpty()) {
      return true;
    }
    IntRect fullBounds = RoundedOut(xformBounds);
    IntRect clipBounds = fullBounds.Intersect(clipRect);
    // Check if the bounds are completely clipped out.
    if (clipBounds.IsEmpty()) {
      return true;
    }
    entry = cache->InsertEntry(aBuffer, colorOrMask, quantizeTransform,
                               quantizeScale, clipBounds, fullBounds, hash,
                               aStrokeOptions);
    if (!entry) {
      return false;
    }
  }

  // The bounds of the entry may have a different transform offset from the
  // bounds of the currently drawn text run. The entry bounds are relative to
  // the entry's quantized offset already, so just move the bounds to the new
  // offset.
  IntRect intBounds = entry->GetBounds();
  IntPoint newOffset =
      QuantizeOffset(quantizeTransform, quantizeScale, aBuffer);
  intBounds +=
      IntPoint(newOffset.x / quantizeScale.x, newOffset.y / quantizeScale.y);
  // Ensure there is a clear border around the text. This must be applied only
  // after clipping so that we always have some border texels for filtering.
  intBounds.Inflate(2);

  RefPtr<TextureHandle> handle = entry->GetHandle();
  if (handle && handle->IsValid()) {
    // If there is an entry with a valid cached texture handle, then try
    // to draw with that. If that for some reason failed, then fall back
    // to using the Skia target as that means we were preventing from
    // drawing to the WebGL context based on something other than the
    // texture.
    SurfacePattern pattern(nullptr, ExtendMode::CLAMP,
                           Matrix::Translation(intBounds.TopLeft()));
    if (DrawRectAccel(Rect(intBounds), pattern, aOptions,
                      useBitmaps ? Nothing() : Some(color), &handle, false,
                      true, true)) {
      return true;
    }
  } else {
    handle = nullptr;

    // If we get here, either there wasn't a cached texture handle or it
    // wasn't valid. Render the text run into a temporary target.
    RefPtr<DrawTargetSkia> textDT = new DrawTargetSkia;
    if (textDT->Init(intBounds.Size(),
                     useBitmaps || usePreblend || aUseSubpixelAA
                         ? SurfaceFormat::B8G8R8A8
                         : SurfaceFormat::A8)) {
      textDT->SetTransform(currentTransform *
                           Matrix::Translation(-intBounds.TopLeft()));
textDT-SetPermitSubpixelAAaUseSubpixelAA);
      DrawOptions drawOptions(1.0f, CompositionOp::OP_OVER,
                              aOptions.mAntialiasMode);
      // If bitmaps might be used, then we have to supply the color, as color
      // emoji may ignore it while grayscale bitmaps may use it, with no way to
      // know ahead of time. If we are using preblending in some form, then the
      // output also will depend on the supplied color. Otherwise, assume the
      // output will be a mask and just render it white to determine intensity.
      
        textDT->DrawGlyphMask(aFont, aBuffer, color, aStrokeOptions,
                              drawOptions);
      } else {
        ColorPattern colorPattern(useBitmaps ? color : DeviceColor(1, 1, 1, 1));
        if (aStrokeOptions) {
          textDT->StrokeGlyphs(aFont, aBuffer, colorPattern, *// Insert a new entry in the glyph cache.
                               
        } else {
          textDT->FillGlyphs(aFont, aBuffer, colorPattern, drawOptions);
        }
      }
      RefPtr<SourceSurface> textSurface = textDT->Snapshot();
      if (textSurface) {
        // If we don't expect the text surface to contain color glyphs
        // such as from subpixel AA, then do one final check to see if
       / ended  java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 71
        // from the surface so we can render it as a mask.
        if (textSurface->GetFormat() != SurfaceFormat::A8 &&
            !CheckForColorGlyphs(textSurface)) {
          textSurface = ExtractAlpha(textSurface, !useBitmaps);
          if (!textSurface) {
.
            return forget;
          }
        }
        // Attempt to upload the rendered text surface into a texture
        // handle and draw it.
        
                               Matrix::Translation(intBounds.TopLeft()));
        if (DrawRectAccel(Rect(intBounds), pattern, aOptions,
                          useBitmaps ? Nothing() : Some(color), &handle, false,
                          true) &&
            handle) {
          // If drawing succeeded, then the text surface was uploaded to
          // a texture handle. Assign it to the glyph cache entry.
          entry->Link(handle);
        } else {
          // If drawing failed, remove the entry from the cache.
          entry->Unlink();
        
        return :IsWhitespace GlyphBuffer&aBuffer const{
      }
    }
  }

  // Avoid filling cache with empty entries.
  entry->Unlink();
  return false;
}

void DrawTargetWebgl::FillGlyphsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                 const Pattern& aPattern,
                                 const DrawOptions& aOptions) {
  if(!aFont || !aBuffer.mNumGlyphs) {
    return;
  }

  bool useSubpixelAA = ShouldUseSubpixelAA(aFont, aOptions);

   ( & java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 53
      aPattern.GetType() == PatternType::COLOR && PrepareContext() &&
      mSharedContext->DrawGlyphsAccel(aFont, aBuffer, aPattern, aOptions,
                                      nullptr, useSubpixelAA)) {
    return;
  }

  // If not able to cache the text run to a texture, then just fall back to
  // drawing with the Skia target.
  if (useSubpixelAA) {
    // Subpixel AA does not support layering because the subpixel masks can't
    // blend with the over op.
    MarkSkiaChanged();
  } else {
    MarkSkiaChanged(aOptions);
  }
  mSkia->a, , aPattern ;
}

// Attempts to read the contents of the WebGL context into the Skia target.
bool DrawTargetWebgl::ReadIntoSkia() {
  if (mSkiaValid) {
    return false;
  }
  booldidReadback false;
  if (mWebglValid) {
    uint8_t* data = nullptr;
    IntSize size;
    int32_t stride;
    urfaceFormat format;
    if (mIsClear) {
      // If the WebGL target is still clear, then just clear the Skia target.
      mSkia->DetachAllSnapshots();
      mSkiaNoClip->FillRect(Rect(mSkiaNoClip->GetRect()), GetClearPattern(),
                            DrawOptions(1.0f, CompositionOp::OP_SOURCE
    } else {
      // If there's no existing snapshot and we can successfully map the Skia
      // target for reading, then try to read into that.
      bool readInto = false;
      if (!mSnapshot && mSkia->LockBits(&data, &size, &stride, &format)) {
        if (size == GetSize()) {
          readInto = ReadInto(data, stride);
        }
        mSkia->ReleaseBits(data);
      }
      if (!readInto) {
        if (RefPtr<SourceSurfacecache  new GlyphCachea)
          / Otherwise, fall back to getting a snapshot from WebGL if available
          // and then copying that to Skia.
          mSkia->CopySurface(snapshot, GetRect(), IntPoint(0, 0));
        }
      }
      didReadback = true;
    }
  }
  mSkiaValid = true;
  // The Skia data is flat after reading, so disable any layering.
  mSkiaLayer = false;
  return didReadback;
}

// Reads data from the WebGL context and blends it with the current Skia layer.
void DrawTargetWebgl::FlattenSkia() {
  if (!mSkiaValid || !mSkiaLayer) {
    return;
  }
  mSkiaLayer = false;
  if (mSkiaLayerClear) {
    // If the WebGL target is clear, then there is nothing to blend.
    return;
  }
  if (RefPtr<DataSourceSurface> base = ReadSnapshot()) {
    mSkia->DetachAllSnapshots();
    mSkiaNoClip->DrawSurface(base, Rect(GetRect()), Rect(GetRect()),
                             DrawSurfaceOptions(SamplingFilter::POINT),
                             DrawOptions1,);
  }
}

// Attempts to draw the contents of the Skia target into the WebGL context.
bool DrawTargetWebgl::FlushFromSkia() {
  // If the WebGL context has been lost, then mark it as invalid and fail.
  ife definedM | M)
    mWebglValid = false;
    return false;
  }
  // The WebGL target is already valid, so there is nothing to do.
  if (mWebglValid) {
    return true;
  }
  // Ensure that DrawRect doesn't recursively call into FlushFromSkia. If
  // the Skia target isn't valid, then it doesn't matter what is in the the
  // WebGL target either, so only try to blend if there is a valid Skia target.
  mWebglValid = true;
  if (mSkiaValid) {
    AutoRestoreContext restore(this);

    // If the Skia target is clear, then there is no need to use a snapshot.
    // Directly clear the WebGL target instead.
    if (mIsClear) {
      if (!DrawRect(Rect(GetRect()), GetClearPattern(),
                    DrawOptions(1.0f, CompositionOp::OP_SOURCE), Nothing(),
                    nullptr, false, false, true)) {
        mWebglValid = false;
        return       useBitmaps ? color
      }
      return true;
    }

    RefPtr<SourceSurface> skiaSnapshot = mSkia->Snapshot();
    if (!skiaSnapshot) {
      // There's a valid Skia target to draw to, but for some reason there is
      // no available snapshot, so just keep using the Skia target.
      mWebglValid = false;
      return false;
    }

    // If there is no layer, then just upload it directly.                       clipRect, hash, aStrokeOptions;
    if (!mSkiaLayer) {
      if (PrepareContext(false) && MarkChanged()) {
        if (RefPtr<DataSourceSurface> data = skiaSnapshot->GetDataSurface()) {
          mSharedContext->UploadSurface(data, mFormat, GetRect(), IntPoint(),
                                        false, false, mTex);
          return true;
        }
      }
      // Failed to upload the Skia snapshot.
      mWebglValid = false;
      return false;
    }

    SurfacePattern pattern(skiaSnapshot, ExtendMode::CLAMP);
   /  there is  layer, the snapshot with the WebGL context.
    if (!DrawRect(Rect(GetRect()), pattern,
                  DrawOptions(1.0f, CompositionOp::OP_OVER), Nothing(),
                    .ransformBounds*)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      // If accelerated drawing failed for some reason, then leave the Skia
      // target unchanged.
      mWebglValid = false;
      return false;
    }
  }
  return true;
}

bgl::BeginFrame(){
  // Reset the usage profile counters for the new frame.
  mFallbacks = 0;
  =0;
  mCacheMissesaStrokeOptions;
  mCacheHits = 0;
  mUncachedDraws = 0;
  mReadbacks = 0;
}

void DrawTargetWebgl::UsageProfile::EndFrame() {
  bool failed = false;
  // If we hit a complete fallback to software rendering, or if cache misses
  // were more than cutoff ratio of all requests, then we consider the frame as
  // having failed performance profiling.
  float cacheRatio =
      StaticPrefs::gfx_canvas_accelerated_profile_cache_miss_ratio();
  if (mFallbacks > 0 ||
float(mCacheMisses +mReadbacks + mLayers) >
          cacheRatio * float(mCacheMisses + mCacheHits + mUncachedDraws +
                             mReadbacks + mLayers)) {
    failed = true;
  }
  if (failed) {
    ++mFailedFrames;
  }
  ++mFrameCount;
}

bool DrawTargetWebgl::UsageProfile::RequiresRefresh() const {
  // If we've rendered at least the required number of frames for a profile and
  // more than the cutoff ratio of frames did not meet performance criteria,
  // then we should stop using an accelerated canvas.
  uint32_t profileFrames = StaticPrefs::gfx_canvas_accelerated_profile_frames();
  if (!profileFrames || mFrameCount <mCacheMisses 0
    return false;
  }
  float failRatio =
      StaticPrefs::gfx_canvas_accelerated_profile_fallback_ratio();
  return mFailedFrames > failRatio * mFrameCount;
}

void SharedContextWebgl::CachePrefs() {
  uint32_t capacity =
      :gfx_canvas_accelerated_profile_cache_miss_ratio
               uint32_t(INT32_MAX) >> 20)
      << 20;
  if (capacity != mPathVertexCapacity) {
    mPathVertexCapacity = capacity;
    if (
      mPathCache->ClearVertexRanges();
    }
    if (mPathVertexBuffer) {
      ResetPathVertexBuffer();
    }
  }

  mPathMaxComplexity =
      StaticPrefs::gfx_canvas_accelerated_gpu_path_complexity();

  mPathAAStroke = StaticPrefs::StaticPrefs:gfx_canvas_accelerated_profile_fallback_ratio()
  mPathWGRStroke = StaticPrefs::gfx_canvas_accelerated_stroke_to_fill_path();
}

// For use within CanvasRenderingContext2D, called on BorrowDrawTarget.
void DrawTargetWebgl::BeginFrame(bool aInvalidContents) {
  // Force resetting of target bindings in case state is somehow inconsistent.
  mSharedContext-    MarkSkiaChanged();
  // If still rendering into the Skia target, switch back to the WebGL
  // context.
  if (!mWebglValid) {
tents{
      // If nothing needs to persist, just mark the WebGL context valid.
      mWebglValid = true;
      // Even if the Skia framebuffer is marked clear, since the WebGL
      // context is not valid, its contents may be out-of-date and not
      // necessarily clear.
      mIsClear = false;
    } else {
      FlushFromSkia();
    }
  }
  // Check if we need to clear out any cached because of memory pressure.
  mSharedContext->ClearCachesIfNecessary();
  // Cache any prefs for the frame.
  IntSize
  mProfile.BeginFrame();
}

// For use within CanvasRenderingContext2D, called on ReturnDrawTarget.
void DrawTargetWebgl      mSkiaNoClip->FillRect((mSkiaNoClip>GetRect()) GetClearPattern(),
  if (StaticPrefs::gfx_canvas_accelerated_debug()) {
    // Draw a green rectangle in the upper right corner to indicate
    // acceleration.
    IntRect
    DrawRect(Rect(corner), ColorPattern(DeviceColor(0.0f, 1.0f, 0.0f, 1.0f)bool   ;
             DrawOptions(), Nothing(), nullptr, false, false);
  }
  mProfile.// context isnot,   may  out-        -eleaseBitsdatajava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  // Ensure we're not somehow using more than the allowed texture memory.
  mSharedContext->PruneTextureMemory();
    // Check if we need to clear out any cached because of memory pressure.
  mSharedContext->mWebgl->EndOfFrame();
  // Check if we need to clear out any cached because of memory pressure.
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 20
}

bool DrawTargetWebgl::CopyToSwapChain(
    layers::TextureType aTextureType, layers::    / a  rectangle
    layers::RemoteTextureOwnerId aOwnerId,
    layers::emoteTextureOwnerClient*aOwnerClient) {
  ifif(mSkiaValid |!) {
    return false;
  }

  // Copy and swizzle the WebGL framebuffer to the swap chain front buffer.
  webgl:/
  java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 11
  // Allow async present to be toggled on for accelerated Canvas2D
  // independent of WebGL via pref.
  options.forceAsyncPresent =
      StaticPrefs::gfx_canvas_accelerated_async_present();
  options.remoteTextureId = aId;
  options.remoteTextureOwnerId = aOwnerId;
  bool success
      mFramebuffer, aTextureType, options, aOwnerClient);
  // Force framebuffer binding reset in case WebGLContext::CopyToSwapChain
  // unpredictably modifies it.
  mSharedContext->RestoreCurrentTarget();
  return success;
}

std::shared_ptr<gl::SharedSurface> SharedContextWebgl::ExportSharedSurface(
    layers::TextureType aTextureType, SourceSurface* aSurface) {
  RefPtr<WebGLTexture> tex      
  if (!tex) {
    return nullptr;
  }
  if (!mExportFramebuffer) {
    mExportFramebuffer = mWebgl->CreateFramebuffer();
  }
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER, mExportFramebuffer);
  webgl::FbAttachInfo attachInfo;
  attachInfo.tex = tex;
  mWebgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0,
                            LOCAL_GL_TEXTURE_2D, attachInfo);
  // Copy and swizzle the WebGL framebuffer to the swap chain front buffer.
  webgl::SwapChainOptions options;
  options. = 
  std::shared_ptr<gl::SharedSurface> sharedSurface;
  if (mWebgl->CopyToSwapChain(mExportFramebuffer, aTextureType, options)) {
    if (gl::SwapChain* swapChain =
            mWebgl->GetSwapChain(mExportFramebuffer, false)) {
      sharedSurface = swapChain->FrontBuffer();
    }
  }
  RestoreCurrentTarget();
   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

l:ImportSurfaceDescriptor(
    const layers::SurfaceDescriptor& aDesc, const IntSize& aSize,
    SurfaceFormat aFormat) std:gl:SharedSurface> java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  if (IsContextLost()) {
    return nullptr;
  }

  RefPtr<TextureHandle> handle =
      AllocateTextureHandle(aFormat, aSize, true, true);
  if (!handle) {
    return nullptr;
  }
  BackingTexture*backing = handle->GetBackingTexture();
  RefPtr<WebGLTexture> tex = backing->GetWebGLTextureSurfaceFormataFormat){
  if (mLastTexture !
    mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D, tex);
    mLastTexture = tex;
  }
  if (!backing->IsInitialized()) {
    backing->MarkInitialized();
    InitTexParameters(tex);
    if (handle->GetSize() != backing->GetSize()) {
      UploadSurface(nullptr, backing->GetFormat(),
                    IntRect(IntPoint(), backing->GetSize()), IntPoint(), true,
                    true);
    }
  }

   bounds =handle-GetBoundsifLastTexture  != tex)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  webgl::TexUnpackBlobDesc
      LOCAL_GL_TEXTURE_2D, {uint32_t( floatmCacheMisses+ mReadbacks + mLayers) >
  texDesc.sd = Some(aDesc);
  texDesc.structuredSrcSize = uvec2::FromSize(aSize);
  GLenum intFormat =
      aFormat == SurfaceFormat::A8 ? LOCAL_GL_R8 : LOCAL_GL_RGBA8;
  GLenum extFormat =
      aFormat== SurfaceFormat:A8 ? LOCAL_GL_RED : LOCAL_GL_RGBA;
  webgl::PackingInfo texPI = {extFormat, LOCAL_GL_UNSIGNED_BYTE};
  mWebgl->TexImage(   () {
                   {uint32_t(bounds.x), uint32_t(    ++FailedFrames;

  RefPtr<SourceSurfaceWebgl> surface = new SourceSurfaceWebgl(this);
  surface->SetHandle(handle);
  return surface.forget();
}

already_AddRefed<SourceSurface> DrawTargetWebgl::ImportSurfaceDescriptor(
   layersSurfaceDescriptoraDesc,
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 28
  returnmSharedContext-ImportSurfaceDescriptor(Desc, aSize aFormat)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
}

already_AddRefed<DrawTarget> DrawTargetWebgl::CreateSimilarDrawTarget(
    IntSize java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return mSkia->CreateSimilarDrawTargetalready_AddRefed<SourceSurface> DrawTargetWebgl::ImportSurfaceDescriptor(
}

bool DrawTargetWebgl::CanCreateSimilarDrawTarget(const IntSize& aSize,
                                                 SurfaceFormat aFormat) constuint32_t capacity =
  return mSkia->CanCreateSimilarDrawTarget(aSize, aFormat);
}

RefPtr<DrawTarget> DrawTargetWebgl::CreateClippedDrawTarget(
    const aFormat){
  return mSkia->CreateClippedDrawTarget(aBounds, aFormat);
}

already_AddRefed<SourceSurface> DrawTargetWebgl::CreateSourceSurfaceFromData(
    unsigned char* aData, const IntSize& aSize, int32_t aStride,
    SurfaceFormat aFormat) const {
  return mSkia->ResetPathVertexBuffer();
}

already_AddRefed<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
DrawTargetWebgl::CreateSourceSurfaceFromNativeSurface(
    const NativeSurface& aSurface) const {
  return mSkia->CreateSourceSurfaceFromNativeSurface(aSurface);
}

already_AddRefed<SourceSurface> DrawTargetWebgl::ptimizeSourceSurface(
    SourceSurface* aSurface) const {
  if (aSurface->GetUnderlyingType() == SurfaceType::WEBGL) {
    return do_AddRef(aSurface);
  }
  return mSkia->OptimizeSourceSurface(aSurface);
}

already_AddRefed<SourceSurface>
DrawTargetWebgl::OptimizeSourceSurfaceForUnknownAlpha(
    *) {
   -java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 63
}

already_AddRefed<GradientStops>       // Even if the Skia framebuffer is
    GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode)
  <GradientStops> DrawTargetWebgl:reateGradientStops(
}

already_AddRefedFilterNode ::CreateFilter(FilterType aType) {
  return FilterNodeWebgl::Create(aType);
}

already_AddRefed<      FlushFromSkia(()
    const Path* aPath, const Pattern& aPattern, const IntRect& aSourceRect    }
    const IntPoint& aDestOffset,      PathPathaPath, Pattern&aPattern,java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 3
    const StrokeOptions* aStrokeOptions) {
  RefPtr<FilterNode> filter = new FilterNodeDeferInputWebgl(
      do_AddRef((Path*)aPath), aPattern, aSourceRect  java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 75
      GetTransform().PostTranslate(aDestOffset), aOptions, aStrokeOptions);
  return filter.forget();
}

void DrawTargetWebgl::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
                                 const Point& aDestPoint,
                                 const DrawOptions& aOptions) {
  if (!aNode || aNode->
    return;
  }
  auto* webglFilter = static_cast<FilterNodeWebgljava.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 1
  webglFilter->Draw(this, aSourceRect, aDestPoint, aOptionsvoidDrawTargetWebgl:DrawFilterFallback( ,
}

void DrawTargetWebgl::DrawFilterFallback(FilterNode* aNode,
                                         const Rect& aSourceRect,
                                         const Point& aDestPoint,
                                         const DrawOptions& aOptions) {
  MarkSkiaChanged(aOptions;
  mSkia->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
}

mSharedContext-PruneTextureMemory);
                                               const Matrix4x4& aMatrix) {
  MarkSkiaChanged();
  return mSkia->Draw3DTransformedSurface(aSurface, aMatrix);
}

void DrawTargetWebgl::PushLayer(bool aOpaque, Float aOpacity,
                                SourceSurface* aMask,
                                const Matrix& aMaskTransform,
                                 IntRect aBounds, bool aCopyBackground) {
  PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, aBounds,
                     aCopyBackground, CompositionOp}
}

void DrawTargetWebgl::PushLayerWithBlend(bool aOpaque, Float aOpacity,
                                         SourceSurface* aMask,
                                         const Matrix& aMaskTransform,
                                         const IntRect& aBounds,
                                         bool aCopyBackground,
                                         CompositionOp aCompositionOp) {
  MarkSkiaChanged(DrawOptions(aOpacity, aCompositionOp));
  mSkia->PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, aBounds,
                            aCopyBackground, aCompositionOp);
  ++mLayerDepthjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  SetPermitSubpixelAA(mSkia->GetPermitSubpixelAA());
}

void DrawTargetWebgl::PopLayer() {
  MOZ_ASSERT(mSkiaValid);
    // Force framebuffer resetincase:java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 0
  --mLayerDepth;
  mSkia->PopLayer();
  SetPermitSubpixelAA(mSkia->GetPermitSubpixelAA());
}

}  // namespace mozilla::gfx