cc: make partially-resident textures use 1 - y, not h - y.

cc/output/gl_renderer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 627 matching lines @@
   SkImageInfo dst_info =
       SkImageInfo::MakeN32Premul(dst_rect.width(), dst_rect.height());
   skia::RefPtr<SkSurface> surface = skia::AdoptRef(SkSurface::NewRenderTarget(
       use_gr_context->context(), SkSurface::kYes_Budgeted, dst_info, 0));
   if (!surface) {
     TRACE_EVENT_INSTANT0("cc", "ApplyImageFilter surface allocation failed",
                          TRACE_EVENT_SCOPE_THREAD);
     return skia::RefPtr<SkImage>();
   }
 
-  // The origin of the filter is top-left and the origin of the source is
-  // bottom-left, but the orientation is the same, so we must translate the
-  // filter so that it renders at the bottom of the texture to avoid
-  // misregistration.
-  float y_offset = source_texture_resource->size().height() - src_rect.height();
   SkMatrix local_matrix;
   local_matrix.setScale(scale.x(), scale.y());
   skia::RefPtr<SkImageFilter> filter_with_local_scale =
       skia::AdoptRef(filter->newWithLocalMatrix(local_matrix));
 
   SkPaint paint;
   paint.setImageFilter(filter_with_local_scale.get());
   surface->getCanvas()->translate(-dst_rect.x(), -dst_rect.y());
-  surface->getCanvas()->drawImage(srcImage.get(), src_rect.x(),
-                                  src_rect.y() - y_offset, &paint);
+  surface->getCanvas()->drawImage(srcImage.get(), src_rect.x(), src_rect.y(),
+                                  &paint);
 
   skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
   if (!image || !image->isTextureBacked()) {
     return skia::RefPtr<SkImage>();
   }
 
   CHECK(image->isTextureBacked());
   return image;
 }
 
@@ skipping 463 matching lines @@
     tex_scale_y = quad->rect.height() /
                   static_cast<float>(contents_texture->size().height());
   }
   DCHECK_LE(tex_scale_x, 1.0f);
   DCHECK_LE(tex_scale_y, 1.0f);
 
   DCHECK(locations.tex_transform != -1 || IsContextLost());
   // Flip the content vertically in the shader, as the RenderPass input
   // texture is already oriented the same way as the framebuffer, but the
   // projection transform does a flip.
-  gl_->Uniform4f(locations.tex_transform, 0.0f, tex_scale_y, tex_scale_x,
+  gl_->Uniform4f(locations.tex_transform, 0.0f, 1.0f, tex_scale_x,
                  -tex_scale_y);
 
   GLint last_texture_unit = 0;
   if (locations.mask_sampler != -1) {
     DCHECK_NE(locations.mask_tex_coord_scale, 1);
     DCHECK_NE(locations.mask_tex_coord_offset, 1);
     gl_->Uniform1i(locations.mask_sampler, 1);
 
     gfx::RectF mask_uv_rect = quad->MaskUVRect();
     if (mask_sampler != SAMPLER_TYPE_2D) {
       mask_uv_rect.Scale(quad->mask_texture_size.width(),
                          quad->mask_texture_size.height());
     }
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
     gl_->Uniform2f(locations.mask_tex_coord_offset, mask_uv_rect.x(),
-                   mask_uv_rect.bottom());
+                   mask_uv_rect.height() / tex_scale_y + mask_uv_rect.y());
     gl_->Uniform2f(locations.mask_tex_coord_scale,
                    mask_uv_rect.width() / tex_scale_x,
                    -mask_uv_rect.height() / tex_scale_y);
 
     last_texture_unit = 1;
   }
 
   if (locations.edge != -1)
     gl_->Uniform3fv(locations.edge, 8, edge);
 
@@ skipping 2436 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc