Remove "content" rect from GrTextureAdjuster.

Since we got rid of texture-backed bitmaps this is no longer required.

Change-Id: Id15c745994a3d6a1489e193b5d29916fa0931264
Reviewed-on: https://skia-review.googlesource.com/36340
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

1 files changed, 18 insertions, 97 deletions

diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp
index 92732238e6..f7d71fa18d 100644
--- a/src/gpu/GrTextureProducer.cpp
+++ b/src/gpu/GrTextureProducer.cpp
@@ -16,9 +16,7 @@
 
 sk_sp<GrTextureProxy> GrTextureProducer::CopyOnGpu(GrContext* context,
                                                    sk_sp<GrTextureProxy> inputProxy,
-                                                   const SkIRect* subset,
                                                    const CopyParams& copyParams) {
-    SkASSERT(!subset || !subset->isEmpty());
     SkASSERT(context);
 
     const SkRect dstRect = SkRect::MakeIWH(copyParams.fWidth, copyParams.fHeight);
@@ -33,23 +31,13 @@ sk_sp<GrTextureProxy> GrTextureProducer::CopyOnGpu(GrContext* context,
     GrPaint paint;
     paint.setGammaCorrect(true);
 
-    SkRect localRect;
-    if (subset) {
-        localRect = SkRect::Make(*subset);
-    } else {
-        localRect = SkRect::MakeWH(inputProxy->width(), inputProxy->height());
-    }
+    SkRect localRect = SkRect::MakeWH(inputProxy->width(), inputProxy->height());
 
     bool needsDomain = false;
     if (copyParams.fFilter != GrSamplerParams::kNone_FilterMode) {
         bool resizing = localRect.width()  != dstRect.width() ||
                         localRect.height() != dstRect.height();
-
-        if (GrResourceProvider::IsFunctionallyExact(inputProxy.get())) {
-            needsDomain = subset && resizing;
-        } else {
-            needsDomain = resizing;
-        }
+        needsDomain = resizing && !GrResourceProvider::IsFunctionallyExact(inputProxy.get());
     }
 
     if (needsDomain) {
@@ -88,62 +76,45 @@ GrTextureProducer::DomainMode GrTextureProducer::DetermineDomainMode(
                                 FilterConstraint filterConstraint,
                                 bool coordsLimitedToConstraintRect,
                                 GrTextureProxy* proxy,
-                                const SkIRect* contentRect,
                                 const GrSamplerParams::FilterMode* filterModeOrNullForBicubic,
                                 SkRect* domainRect) {
     const SkIRect proxyBounds = SkIRect::MakeWH(proxy->width(), proxy->height());
 
     SkASSERT(proxyBounds.contains(constraintRect));
-    // We only expect a content area rect if there is some non-content area.
-    SkASSERT(!contentRect ||
-             (!contentRect->contains(proxyBounds) &&
-              proxyBounds.contains(*contentRect) &&
-              contentRect->contains(constraintRect)));
 
     const bool proxyIsExact = GrResourceProvider::IsFunctionallyExact(proxy);
-
+    // We don't expect to have an image that is in an inexact proxy unless the caller was aware
+    // of the potential of sampling outside of the proxy's bounds and specified a constraint rect
+    // with a filter constraint.
+    SkASSERT(kYes_FilterConstraint == filterConstraint || proxyIsExact);
     // If the constraint rectangle contains the whole proxy then no need for a domain.
     if (constraintRect.contains(proxyBounds) && proxyIsExact) {
         return kNoDomain_DomainMode;
     }
 
-    if (!contentRect && !proxyIsExact) {
-        contentRect = &proxyBounds;
-    }
-
     bool restrictFilterToRect = (filterConstraint == GrTextureProducer::kYes_FilterConstraint);
 
     // If we can filter outside the constraint rect, and there is no non-content area of the
     // proxy, and we aren't going to generate sample coords outside the constraint rect then we
     // don't need a domain.
-    if (!restrictFilterToRect && !contentRect && coordsLimitedToConstraintRect) {
+    if (!restrictFilterToRect && coordsLimitedToConstraintRect) {
         return kNoDomain_DomainMode;
     }
 
     // Get the domain inset based on sampling mode (or bail if mipped)
-    SkScalar filterHalfWidth = 0.f;
     if (filterModeOrNullForBicubic) {
         switch (*filterModeOrNullForBicubic) {
             case GrSamplerParams::kNone_FilterMode:
                 if (coordsLimitedToConstraintRect) {
                     return kNoDomain_DomainMode;
-                } else {
-                    filterHalfWidth = 0.f;
                 }
                 break;
             case GrSamplerParams::kBilerp_FilterMode:
-                filterHalfWidth = .5f;
                 break;
             case GrSamplerParams::kMipMap_FilterMode:
-                if (restrictFilterToRect || contentRect) {
-                    // No domain can save us here.
-                    return kTightCopy_DomainMode;
-                }
-                return kNoDomain_DomainMode;
+                // No domain can save us with mip maps.
+                return  restrictFilterToRect ? kTightCopy_DomainMode : kNoDomain_DomainMode;
         }
-    } else {
-        // bicubic does nearest filtering internally.
-        filterHalfWidth = 1.5f;
     }
 
     // Both bilerp and bicubic use bilinear filtering and so need to be clamped to the center
@@ -155,67 +126,17 @@ GrTextureProducer::DomainMode GrTextureProducer::DetermineDomainMode(
     // the domain.
     if (restrictFilterToRect) {
         *domainRect = constraintRect.makeInset(kDomainInset, kDomainInset);
-    } else if (contentRect) {
-        // If we got here then: there is a contentRect, the coords are limited to the
-        // constraint rect, and we're allowed to filter across the constraint rect boundary. So
-        // we check whether the filter would reach across the edge of the content area.
-        // We will only set the sides that are required.
-
-        domainRect->setLargest();
-        if (coordsLimitedToConstraintRect) {
-            // We may be able to use the fact that the texture coords are limited to the constraint
-            // rect in order to avoid having to add a domain.
-            bool needContentAreaConstraint = false;
-            if (contentRect->fLeft > 0 &&
-                contentRect->fLeft + filterHalfWidth > constraintRect.fLeft) {
-                domainRect->fLeft = contentRect->fLeft + kDomainInset;
-                needContentAreaConstraint = true;
-            }
-            if (contentRect->fTop > 0 &&
-                contentRect->fTop + filterHalfWidth > constraintRect.fTop) {
-                domainRect->fTop = contentRect->fTop + kDomainInset;
-                needContentAreaConstraint = true;
-            }
-            if ((!proxyIsExact || contentRect->fRight < proxy->width()) &&
-                contentRect->fRight - filterHalfWidth < constraintRect.fRight) {
-                domainRect->fRight = contentRect->fRight - kDomainInset;
-                needContentAreaConstraint = true;
-            }
-            if ((!proxyIsExact || contentRect->fBottom < proxy->height()) &&
-                contentRect->fBottom - filterHalfWidth < constraintRect.fBottom) {
-                domainRect->fBottom = contentRect->fBottom - kDomainInset;
-                needContentAreaConstraint = true;
-            }
-            if (!needContentAreaConstraint) {
-                return kNoDomain_DomainMode;
-            }
-        } else {
-            // Our sample coords for the texture are allowed to be outside the constraintRect so we
-            // don't consider it when computing the domain.
-            if (contentRect->fLeft > 0) {
-                domainRect->fLeft = contentRect->fLeft + kDomainInset;
-            }
-            if (contentRect->fTop > 0) {
-                domainRect->fTop = contentRect->fTop + kDomainInset;
-            }
-            if (!proxyIsExact || contentRect->fRight < proxy->width()) {
-                domainRect->fRight = contentRect->fRight - kDomainInset;
-            }
-            if (!proxyIsExact || contentRect->fBottom < proxy->height()) {
-                domainRect->fBottom = contentRect->fBottom - kDomainInset;
-            }
+        if (domainRect->fLeft > domainRect->fRight) {
+            domainRect->fLeft = domainRect->fRight =
+                    SkScalarAve(domainRect->fLeft, domainRect->fRight);
         }
-    } else {
-        return kNoDomain_DomainMode;
-    }
-
-    if (domainRect->fLeft > domainRect->fRight) {
-        domainRect->fLeft = domainRect->fRight = SkScalarAve(domainRect->fLeft, domainRect->fRight);
-    }
-    if (domainRect->fTop > domainRect->fBottom) {
-        domainRect->fTop = domainRect->fBottom = SkScalarAve(domainRect->fTop, domainRect->fBottom);
+        if (domainRect->fTop > domainRect->fBottom) {
+            domainRect->fTop = domainRect->fBottom =
+                    SkScalarAve(domainRect->fTop, domainRect->fBottom);
+        }
+        return kDomain_DomainMode;
     }
-    return kDomain_DomainMode;
+    return kNoDomain_DomainMode;
 }
 
 std::unique_ptr<GrFragmentProcessor> GrTextureProducer::CreateFragmentProcessorForDomainAndFilter(