Remove third_party/golang.org/x/mobile as it is no longer used with Go 1.5.

third_party/go/src/golang.org/x/mobile/sprite/portable/affine.go

Index: third_party/go/src/golang.org/x/mobile/sprite/portable/affine.go
diff --git a/third_party/go/src/golang.org/x/mobile/sprite/portable/affine.go b/third_party/go/src/golang.org/x/mobile/sprite/portable/affine.go
deleted file mode 100644
index 28016d87a12a4a6d178eab1abd899986ee5a66a6..0000000000000000000000000000000000000000
--- a/third_party/go/src/golang.org/x/mobile/sprite/portable/affine.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package portable
-
-import (
-	"image"
-	"image/draw"
-
-	"golang.org/x/mobile/f32"
-)
-
-// affine draws each pixel of dst using bilinear interpolation of the
-// affine-transformed position in src. This is equivalent to:
-//
-//	for each (x,y) in dst:
-//		dst(x,y) = bilinear interpolation of src(a*(x,y))
-//
-// While this is the simpler implementation, it can be counter-
-// intuitive as an affine transformation is usually described in terms
-// of the source, not the destination. For example, a scale transform
-//
-//	Affine{{2, 0, 0}, {0, 2, 0}}
-//
-// will produce a dst that is half the size of src. To perform a
-// traditional affine transform, use the inverse of the affine matrix.
-func affine(dst *image.RGBA, src image.Image, srcb image.Rectangle, mask image.Image, a *f32.Affine, op draw.Op) {
-	b := dst.Bounds()
-	var maskb image.Rectangle
-	if mask != nil {
-		maskb = mask.Bounds().Add(srcb.Min)
-	}
-
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		for x := b.Min.X; x < b.Max.X; x++ {
-			// Interpolate from the bounds of the src sub-image
-			// to the bounds of the dst sub-image.
-			ix, iy := pt(a, x-b.Min.X, y-b.Min.Y)
-			sx := ix + float32(srcb.Min.X)
-			sy := iy + float32(srcb.Min.Y)
-			if !inBounds(srcb, sx, sy) {
-				continue
-			}
-
-			// m is the maximum color value returned by image.Color.RGBA.
-			const m = 1<<16 - 1
-
-			ma := uint32(m)
-			if mask != nil {
-				mx := ix + float32(maskb.Min.X)
-				my := iy + float32(maskb.Min.Y)
-				if !inBounds(maskb, mx, my) {
-					continue
-				}
-				_, _, _, ma = bilinear(mask, mx, my).RGBA()
-			}
-
-			sr, sg, sb, sa := bilinear(src, sx, sy).RGBA()
-			off := (y-dst.Rect.Min.Y)*dst.Stride + (x-dst.Rect.Min.X)*4
-
-			if op == draw.Over {
-				dr := uint32(dst.Pix[off+0])
-				dg := uint32(dst.Pix[off+1])
-				db := uint32(dst.Pix[off+2])
-				da := uint32(dst.Pix[off+3])
-
-				// dr, dg, db, and da are all 8-bit color at the moment, ranging
-				// in [0,255]. We work in 16-bit color, and so would normally do:
-				//	dr |= dr << 8
-				// and similarly for the other values, but instead we multiply by 0x101
-				// to shift these to 16-bit colors, ranging in [0,65535].
-				// This yields the same result, but is fewer arithmetic operations.
-				//
-				// This logic comes from drawCopyOver in the image/draw package.
-				a := m - (sa * ma / m)
-				a *= 0x101
-
-				dst.Pix[off+0] = uint8((dr*a + sr*ma) / m >> 8)
-				dst.Pix[off+1] = uint8((dg*a + sg*ma) / m >> 8)
-				dst.Pix[off+2] = uint8((db*a + sb*ma) / m >> 8)
-				dst.Pix[off+3] = uint8((da*a + sa*ma) / m >> 8)
-			} else {
-				dst.Pix[off+0] = uint8(sr * ma / m >> 8)
-				dst.Pix[off+1] = uint8(sg * ma / m >> 8)
-				dst.Pix[off+2] = uint8(sb * ma / m >> 8)
-				dst.Pix[off+3] = uint8(sa * ma / m >> 8)
-			}
-		}
-	}
-}
-
-func inBounds(b image.Rectangle, x, y float32) bool {
-	if x < float32(b.Min.X) || x >= float32(b.Max.X) {
-		return false
-	}
-	if y < float32(b.Min.Y) || y >= float32(b.Max.Y) {
-		return false
-	}
-	return true
-}
-
-func pt(a *f32.Affine, x0, y0 int) (x1, y1 float32) {
-	fx := float32(x0) + 0.5
-	fy := float32(y0) + 0.5
-	x1 = fx*a[0][0] + fy*a[0][1] + a[0][2]
-	y1 = fx*a[1][0] + fy*a[1][1] + a[1][2]
-	return x1, y1
-}