Fix UpdateTilePriorities viewport in Android WebView.

cc/output/direct_renderer.cc

 // Copyright 2012 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/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 242 matching lines @@
     // Only intersect inverse-projected damage if the transform is invertible.
     gfx::RectF damage_rect_in_render_pass_space =
         MathUtil::ProjectClippedRect(inverse_transform,
                                      frame->root_damage_rect);
     render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
   }
 
   return render_pass_scissor;
 }
 
+bool DirectRenderer::NeedDeviceClip(const DrawingFrame* frame) const {
+  if (frame->current_render_pass != frame->root_render_pass)
+    return false;
+
+  return !client_->DeviceClip().Contains(client_->DeviceViewport());
+}
+
+gfx::Rect DirectRenderer::DeviceClipRect(const DrawingFrame* frame) const {

[enne (OOO), 2013/09/03 16:58:47]

Could you help me understand a little bit better why you need this additional
device clip?  Why should this only apply to drawing but not
UpdateTilePrioritieS?

[aelias_OOO_until_Jul13, 2013/09/03 19:52:09]

Sometimes a part of another Android View overlaps slightly with the WebView and
causes a small invalidation.  When this happens, the Android View system
requests a draw with a small clip rect surrounding that invalidation.  So, if we
use the clip rect as the visible viewport to be used for tile management, it
will work most of the time but when this happens CC will think the viewport
suddenly is tiny and evict tiles.

As of this patch, we use instead the "global visible rect" of our WebView as the
viewport (which is guaranteed to be a superset of the clip).  Conversely we
cannot use only *that* rect for both viewport and clip or we'll illegally draw
over other views sometimes.  So making CC aware of two different rectangles
becomes necessary.

[enne (OOO), 2013/09/03 21:47:31]

Thanks for all the explanation.  This clip rect then is really behaving as
damage caused by the embedder that needs a redraw.  

Although, if there is a composited animation going on (or scrolling), only
redrawing part of the viewport sounds like it would show content from different
frames.  I guess this is the Android view system asking for this draw though,
and it's probably too late to merge the compositor's damage rect with that
"clip" rect?

[boliu, 2013/09/03 21:54:05]

Absolutely. Eventually webview would like to avoid updating scroll offset inside
draw: crbug.com/249972

For now we have an hack of detecting this situation and invalidating the whole
view again, so the next draw will be the whole visible rect.
Right. Contract with android view system is never draw outside of the clip, lest
we clobber some other view on top of us that's not damaged.

+  gfx::Rect device_clip_rect = client_->DeviceClip();
+  if (FlippedFramebuffer())
+    device_clip_rect.set_y(current_surface_size_.height() -
+                           device_clip_rect.bottom());
+  return device_clip_rect;
+}
+
 void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
                                             const DrawQuad& quad) {
   if (quad.isClipped()) {
-    gfx::RectF quad_scissor_rect = quad.clipRect();
-    SetScissorTestRect(MoveFromDrawToWindowSpace(quad_scissor_rect));
-  } else {
-    EnsureScissorTestDisabled();
+    SetScissorTestRectInDrawSpace(frame, quad.clipRect());
+    return;
   }
+  if (NeedDeviceClip(frame)) {
+    SetScissorTestRect(DeviceClipRect(frame));
+    return;
+  }
+
+  EnsureScissorTestDisabled();
 }
 
 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
     const DrawingFrame* frame,
     const DrawQuad& quad,
     const gfx::RectF& render_pass_scissor,
     bool* should_skip_quad) {
   gfx::RectF quad_scissor_rect = render_pass_scissor;
 
   if (quad.isClipped())
     quad_scissor_rect.Intersect(quad.clipRect());
 
   if (quad_scissor_rect.IsEmpty()) {
     *should_skip_quad = true;
     return;
   }
 
   *should_skip_quad = false;
-  SetScissorTestRect(MoveFromDrawToWindowSpace(quad_scissor_rect));
+  SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
+}
+
+void DirectRenderer::SetScissorTestRectInDrawSpace(const DrawingFrame* frame,
+                                                   gfx::RectF draw_space_rect) {
+  gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
+  if (NeedDeviceClip(frame))
+    window_space_rect.Intersect(DeviceClipRect(frame));
+  SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization =
       Capabilities().using_partial_swap && client_->AllowPartialSwap();
   gfx::RectF render_pass_scissor;
 
   if (using_scissor_as_optimization) {
     render_pass_scissor = ComputeScissorRectForRenderPass(frame);
-    SetScissorTestRect(MoveFromDrawToWindowSpace(render_pass_scissor));
+    SetScissorTestRectInDrawSpace(frame, render_pass_scissor);
   }
 
   if (frame->current_render_pass != frame->root_render_pass ||
       client_->ShouldClearRootRenderPass()) {
-    if (!using_scissor_as_optimization)
+    if (NeedDeviceClip(frame))
+      SetScissorTestRect(DeviceClipRect(frame));
+    else if (!using_scissor_as_optimization)
       EnsureScissorTestDisabled();
     ClearFramebuffer(frame);
   }
 
   const QuadList& quad_list = render_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = *(*it);
     bool should_skip_quad = false;
@@ skipping 62 matching lines @@
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::RenderPassTextureFormat(const RenderPass* render_pass) {
   return GL_RGBA;
 }
 
 }  // namespace cc