cc: Add tile-free software compositing mode.

cc/output/software_renderer.cc

Index: cc/output/software_renderer.cc
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index fd4b5a645f1caedf56baa07fa6b263a324de86dd..10266c21a4c58c5c284f254a9cba6561e7b75212 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -12,6 +12,7 @@
 #include "cc/output/output_surface.h"
 #include "cc/output/software_output_device.h"
 #include "cc/quads/debug_border_draw_quad.h"
+#include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
@@ -71,8 +72,11 @@ SoftwareRenderer::SoftwareRenderer(RendererClient* client,
     output_surface_(output_surface),
     output_device_(output_surface->software_device()),
     current_canvas_(NULL) {
-  capabilities_.max_texture_size = resource_provider_->max_texture_size();
-  capabilities_.best_texture_format = resource_provider_->best_texture_format();
+  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;
@@ -244,6 +248,9 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::PICTURE_CONTENT:
+      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      break;
     case DrawQuad::SOLID_COLOR:
       DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
       break;
@@ -264,6 +271,17 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
   current_canvas_->resetMatrix();
 }
 
+// static
+SkMatrix SoftwareRenderer::ContentDrawQuadMatrix(
+    const ContentDrawQuadBase* quad) {
+  SkMatrix content_draw_quad_matrix;
+  content_draw_quad_matrix.setRectToRect(
+      gfx::RectFToSkRect(quad->tex_coord_rect),

[enne (OOO), 2013/04/28 22:42:27]

I would actually like to get rid of this tex coord rect off of PictureDrawQuad. 
I don't think it has any business being there.  Given a content rect, a geometry
rect, and pile, the renderer can make the decision to add border texels if it
needs to.

+      gfx::RectFToSkRect(QuadVertexRect()),
+      SkMatrix::kFill_ScaleToFit);
+  return content_draw_quad_matrix;
+}
+
 void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                                            const DebugBorderDrawQuad* quad) {
   // We need to apply the matrix manually to have pixel-sized stroke width.
@@ -283,6 +301,33 @@ void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                               4, transformed_vertices, current_paint_);
 }
 
+void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
+                                       const PictureDrawQuad* quad) {
+  current_canvas_->concat(ContentDrawQuadMatrix(quad));
+
+  if (quad->ShouldDrawWithBlending()) {
+    TRACE_EVENT0("cc", "SoftwareRenderer::DrawPictureQuad with blending");
+    SkBitmap temp_bitmap;
+    temp_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                          quad->texture_size.width(),
+                          quad->texture_size.height());
+    temp_bitmap.allocPixels();
+    SkDevice temp_device(temp_bitmap);
+    SkCanvas temp_canvas(&temp_device);
+
+    quad->picture_pile->Raster(
+        &temp_canvas, quad->content_rect, quad->contents_scale, NULL);
+
+    current_paint_.setFilterBitmap(true);
+    current_canvas_->drawBitmap(temp_bitmap, 0, 0, &current_paint_);
+  } else {
+    TRACE_EVENT0("cc",
+                 "SoftwareRenderer::DrawPictureQuad direct from PicturePile");
+    quad->picture_pile->Raster(
+        current_canvas_, quad->content_rect, quad->contents_scale, NULL);
+  }
+}
+
 void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
                                           const SolidColorDrawQuad* quad) {
   current_paint_.setColor(quad->color);
@@ -320,11 +365,9 @@ void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 quad->resource_id);
 
-  SkRect uv_rect = gfx::RectFToSkRect(quad->tex_coord_rect);
   current_paint_.setFilterBitmap(true);
-  current_canvas_->drawBitmapRectToRect(*lock.sk_bitmap(), &uv_rect,
-                                        gfx::RectFToSkRect(QuadVertexRect()),
-                                        &current_paint_);
+  current_canvas_->drawBitmapMatrix(
+      *lock.sk_bitmap(), ContentDrawQuadMatrix(quad), &current_paint_);
 }
 
 void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,