Implement transform/clip support for 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/debug/trace_event.h"
@@ skipping 64 matching lines @@
                                        const gfx::RectF& quad_rect) {
   *quad_rect_transform = quad_transform;
   quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
                                  0.5 * quad_rect.height() + quad_rect.y());
   quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
 // static
 void DirectRenderer::InitializeMatrices(DrawingFrame* frame,
                                         gfx::Rect draw_rect,
+                                        gfx::Rect window_rect,
                                         bool flip_y) {
   if (flip_y) {
     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                      draw_rect.right(),
                                                      draw_rect.bottom(),
                                                      draw_rect.y());
   } else {
     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                      draw_rect.right(),
                                                      draw_rect.y(),
                                                      draw_rect.bottom());
   }
-  frame->window_matrix =
-      window_matrix(0, 0, draw_rect.width(), draw_rect.height());
+
+  frame->window_matrix = window_matrix(window_rect.x(),
+                                       window_rect.y(),
+                                       window_rect.width(),
+                                       window_rect.height());
   frame->flipped_y = flip_y;
 }
 
-// static
 gfx::Rect DirectRenderer::MoveScissorToWindowSpace(
     const DrawingFrame* frame, const gfx::RectF& scissor_rect) {
   gfx::Rect scissor_rect_in_canvas_space = gfx::ToEnclosingRect(scissor_rect);
-  // The scissor coordinates must be supplied in viewport space so we need to
+  // The scissor coordinates must be supplied in window space so we need to
   // offset by the relative position of the top left corner of the current
   // render pass.
   gfx::Rect framebuffer_output_rect = frame->current_render_pass->output_rect;
+  if (!frame->current_texture) {

[danakj, 2013/06/05 17:40:53]

This check is done twice in this function. Can you make a temp bool with a nice
name so we don't go repeating ourselves like that?

+    framebuffer_output_rect = gfx::Rect(output_surface_->SurfaceSize());
+    scissor_rect_in_canvas_space.Offset(client_->DeviceViewport().x(),

[enne (OOO), 2013/06/05 16:39:06]

My only remaining concern here is double-checking that I understand the
relationship between DeviceViewport (externally given or not) and SurfaceSize().
 When I talked to you previously, it sounded like there was no clear
container/subset relationship between these two, i.e. you could have a viewport
larger than the surface or a surface larger than the viewport.

If that's the case, it seems like this offset might be wrong and that maybe the
viewport needs to be the intersection of external viewport and surface size. 
(Or, if I'm wrong, maybe we need a dcheck that one is contained in the other?)

In either case, can you add some comments about what the relationship is between
viewport and surface size to the relevant header?

[danakj, 2013/06/05 17:40:53]

nit: or, scissor_rect_in_canvas_space +=
client_->DeviceViewport().OffsetFromOrigin();

[aelias_OOO_until_Jul13, 2013/06/06 08:57:50]

I added a DCHECK in DirectRenderer::UseRenderPass that surface size contains
device viewport; as it's the clip rect for WebView, it's guaranteed to be
contained.  The one that is not guaranteed to be contained is the viewport size
coming from the main thread (which is not used by the Renderers when
external_viewport_ is set).  I also wrote a comment in renderer.h.

+                                        client_->DeviceViewport().y());
+  }
   scissor_rect_in_canvas_space.set_x(
       scissor_rect_in_canvas_space.x() - framebuffer_output_rect.x());
   if (frame->flipped_y && !frame->current_texture) {
     scissor_rect_in_canvas_space.set_y(
         framebuffer_output_rect.height() -
         (scissor_rect_in_canvas_space.bottom() - framebuffer_output_rect.y()));
   } else {
     scissor_rect_in_canvas_space.set_y(
         scissor_rect_in_canvas_space.y() - framebuffer_output_rect.y());
   }
   return scissor_rect_in_canvas_space;
 }
 
 DirectRenderer::DirectRenderer(RendererClient* client,
+                               OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
     : Renderer(client),
+      output_surface_(output_surface),
       resource_provider_(resource_provider) {}
 
 DirectRenderer::~DirectRenderer() {}
 
 bool DirectRenderer::CanReadPixels() const { return true; }
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     gfx::Vector2d amount) {
   enlarge_pass_texture_amount_ = amount;
 }
@@ skipping 54 matching lines @@
                        render_passes_in_draw_order->size());
 
   const RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect =
       Capabilities().using_partial_swap && client_->AllowPartialSwap() ?
       root_render_pass->damage_rect : root_render_pass->output_rect;
-  frame.root_damage_rect.Intersect(gfx::Rect(ViewportSize()));
+  frame.root_damage_rect.Intersect(gfx::Rect(client_->DeviceViewport().size()));
+
+  // Only reshape when we know we are going to draw. Otherwise, the reshape
+  // can leave the window at the wrong size if we never draw and the proper
+  // viewport size is never set.
+  output_surface_->Reshape(client_->DeviceViewport().size(),
+                           client_->DeviceScaleFactor());
 
   BeginDrawingFrame(&frame);
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order->at(i);
     DrawRenderPass(&frame, pass);
 
     for (ScopedPtrVector<CopyOutputRequest>::iterator it =
              pass->copy_requests.begin();
          it != pass->copy_requests.end();
          ++it) {
@@ skipping 109 matching lines @@
   }
 }
 
 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
                                    const RenderPass* render_pass) {
   frame->current_render_pass = render_pass;
   frame->current_texture = NULL;
 
   if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
-    InitializeMatrices(frame, render_pass->output_rect, FlippedFramebuffer());
-    SetDrawViewportSize(render_pass->output_rect.size());
+    gfx::Rect viewport = client_->DeviceViewport();
+    if (FlippedFramebuffer())

[enne (OOO), 2013/06/05 16:39:06]

style nit: {}

+      viewport.set_y(output_surface_->SurfaceSize().height() -
+                     viewport.bottom());
+    InitializeMatrices(
+        frame,
+        render_pass->output_rect,
+        viewport,
+        FlippedFramebuffer());
+    SetDrawViewport(viewport);
     return true;
   }
 
   if (!resource_provider_)
     return false;
 
   CachedResource* texture = render_pass_textures_.get(render_pass->id);
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
@@ skipping 21 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