Implement transform/clip support for Android WebView.

cc/output/software_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/software_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 35 matching lines @@
     RendererClient* client,
     OutputSurface* output_surface,
     ResourceProvider* resource_provider) {
   return make_scoped_ptr(
       new SoftwareRenderer(client, output_surface, resource_provider));
 }
 
 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
                                    OutputSurface* output_surface,
                                    ResourceProvider* resource_provider)
-  : DirectRenderer(client, resource_provider),
+  : DirectRenderer(client, output_surface, resource_provider),
     visible_(true),
     is_scissor_enabled_(false),
     is_viewport_changed_(true),
-    output_surface_(output_surface),
     output_device_(output_surface->software_device()),
     current_canvas_(NULL) {
   if (resource_provider_) {
     capabilities_.max_texture_size = resource_provider_->max_texture_size();
     capabilities_.best_texture_format =
         resource_provider_->best_texture_format();
   }
   capabilities_.using_set_visibility = true;
   // The updater can access bitmaps while the SoftwareRenderer is using them.
   capabilities_.allow_partial_texture_updates = true;
@@ skipping 10 matching lines @@
 }
 
 void SoftwareRenderer::ViewportChanged() {
   is_viewport_changed_ = true;
 }
 
 void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
   if (is_viewport_changed_) {
     is_viewport_changed_ = false;
-    output_device_->Resize(ViewportSize());
+    output_device_->Resize(client_->DeviceViewport().size());
   }
   root_canvas_ = output_device_->BeginPaint(
       gfx::ToEnclosingRect(frame->root_damage_rect));
 }
 
 void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
   current_framebuffer_lock_.reset();
   current_canvas_ = NULL;
   root_canvas_ = NULL;
@@ skipping 43 matching lines @@
 
 bool SoftwareRenderer::BindFramebufferToTexture(
     DrawingFrame* frame,
     const ScopedResource* texture,
     gfx::Rect framebuffer_rect) {
   current_framebuffer_lock_.reset();
   current_framebuffer_lock_ = make_scoped_ptr(
       new ResourceProvider::ScopedWriteLockSoftware(
           resource_provider_, texture->id()));
   current_canvas_ = current_framebuffer_lock_->sk_canvas();
-  InitializeMatrices(frame, framebuffer_rect, false);
-  SetDrawViewportSize(framebuffer_rect.size());
+  InitializeMatrices(
+      frame, framebuffer_rect, gfx::Rect(framebuffer_rect.size()), false);

[enne (OOO), 2013/06/04 17:26:03]

I'm a little curious about this change.  When does this framebuffer rect not
have a position of zero? Should this function be taking in a gfx::Size instead
of a rect?

[aelias_OOO_until_Jul13, 2013/06/04 17:54:20]

I'll investigate and consider changing the argument to gfx::Size.

[aelias_OOO_until_Jul13, 2013/06/04 22:18:27]

It needs to be a rect since framebuffer_rect is set from the clip rect,
therefore the draw is translated and we need to cancel that out in the
projection matrix.  The problem is that the variable name is misleading -- I
changed it to "target_rect" in all the Renderers.

+  SetDrawViewport(gfx::Rect(framebuffer_rect.size()));
 
   return true;
 }
 
 void SoftwareRenderer::SetScissorTestRect(gfx::Rect scissor_rect) {
   is_scissor_enabled_ = true;
   scissor_rect_ = scissor_rect;
   SetClipRect(scissor_rect);
 }
 
@@ skipping 19 matching lines @@
     ClearCanvas(SkColorSetARGB(0, 0, 0, 0));
   } else {
 #ifndef NDEBUG
     // On DEBUG builds, opaque render passes are cleared to blue
     // to easily see regions that were not drawn on the screen.
     ClearCanvas(SkColorSetARGB(255, 0, 0, 255));
 #endif
   }
 }
 
-void SoftwareRenderer::SetDrawViewportSize(gfx::Size viewport_size) {}
+void SoftwareRenderer::SetDrawViewport(gfx::Rect viewport) {}

[enne (OOO), 2013/06/04 17:26:03]

How does the software renderer get away with ignoring the viewport?

[aelias_OOO_until_Jul13, 2013/06/04 17:54:20]

The software renderer applies the window_matrix directly.  It gets the viewport
transformation that way instead.

 
 bool SoftwareRenderer::IsSoftwareResource(
     ResourceProvider::ResourceId resource_id) const {
   switch (resource_provider_->GetResourceType(resource_id)) {
     case ResourceProvider::GLTexture:
       return false;
     case ResourceProvider::Bitmap:
       return true;
   }
 
@@ skipping 250 matching lines @@
                              4 * rect.width());
 }
 
 void SoftwareRenderer::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
 }
 
 }  // namespace cc