Update from https://crrev.com/316786

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 606 matching lines @@
   GLC(gl_, gl_->LineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
 static skia::RefPtr<SkImage> ApplyImageFilter(
     scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
-    const gfx::Point& origin,
+    const gfx::Rect& rect,
     const gfx::Vector2dF& scale,
     SkImageFilter* filter,
     ScopedResource* source_texture_resource) {
   if (!filter)
     return skia::RefPtr<SkImage>();
 
   if (!use_gr_context)
     return skia::RefPtr<SkImage>();
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider,
@@ skipping 48 matching lines @@
   // Create surface to draw into.
   skia::RefPtr<SkSurface> surface = skia::AdoptRef(
       SkSurface::NewRenderTargetDirect(backing_store->asRenderTarget()));
   skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
 
   // Draw the source bitmap through the filter to the canvas.
   SkPaint paint;
   paint.setImageFilter(filter);
   canvas->clear(SK_ColorTRANSPARENT);
 
-  canvas->translate(SkIntToScalar(-origin.x()), SkIntToScalar(-origin.y()));
+  // 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.
+  int y_translate = source.height() - rect.height() - rect.origin().y();
+  canvas->translate(-rect.origin().x(), y_translate);
   canvas->scale(scale.x(), scale.y());
   canvas->drawSprite(source, 0, 0, &paint);
 
   skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
   if (!image || !image->getTexture()) {
     return skia::RefPtr<SkImage>();
   }
 
   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
@@ skipping 144 matching lines @@
 }
 
 skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture) {
   DCHECK(ShouldApplyBackgroundFilters(frame, quad));
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, background_texture->size());
 
-  skia::RefPtr<SkImage> background_with_filters =
-      ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                       resource_provider_,
-                       quad->rect.origin(),
-                       quad->filters_scale,
-                       filter.get(),
-                       background_texture);
+  skia::RefPtr<SkImage> background_with_filters = ApplyImageFilter(
+      ScopedUseGrContext::Create(this, frame), resource_provider_, quad->rect,
+      quad->filters_scale, filter.get(), background_texture);
   return background_with_filters;
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad) {
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   if (!contents_texture || !contents_texture->id())
     return;
 
@@ skipping 85 matching lines @@
         SkColorFilter* colorfilter_rawptr = NULL;
         filter->asColorFilter(&colorfilter_rawptr);
         cf = skia::AdoptRef(colorfilter_rawptr);
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !filter->getInput(0)) {
         // We have a single color matrix as a filter; apply it locally
         // in the compositor.
         use_color_matrix = true;
       } else {
-        filter_image = ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                                        resource_provider_,
-                                        quad->rect.origin(),
-                                        quad->filters_scale,
-                                        filter.get(),
-                                        contents_texture);
+        filter_image = ApplyImageFilter(
+            ScopedUseGrContext::Create(this, frame), resource_provider_,
+            quad->rect, quad->filters_scale, filter.get(), contents_texture);
       }
     }
   }
 
   scoped_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   SamplerType mask_sampler = SamplerTypeNA;
   if (quad->mask_resource_id) {
     mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->mask_resource_id, GL_TEXTURE1, GL_LINEAR));
@@ skipping 1715 matching lines @@
   } else {
     SetStencilEnabled(false);
   }
 }
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
                                           const gfx::Rect& target_rect) {
   DCHECK(texture->id());
 
+  // Explicitly release lock, otherwise we can crash when try to lock
+  // same texture again.
   current_framebuffer_lock_ = nullptr;
 
   SetStencilEnabled(false);
   GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_));
   current_framebuffer_lock_ =
       make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(
           resource_provider_, texture->id()));
   unsigned texture_id = current_framebuffer_lock_->texture_id();
   GLC(gl_,
       gl_->FramebufferTexture2D(
@@ skipping 581 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc