Add flag for drawing layers to screen with Ganesh

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 13 matching lines @@
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 namespace {
 
-void ToSkMatrix(SkMatrix* flattened, const gfx::Transform& m) {
-  // Convert from 4x4 to 3x3 by dropping the third row and column.
-  flattened->set(0, SkDoubleToScalar(m.matrix().getDouble(0, 0)));
-  flattened->set(1, SkDoubleToScalar(m.matrix().getDouble(0, 1)));
-  flattened->set(2, SkDoubleToScalar(m.matrix().getDouble(0, 3)));
-  flattened->set(3, SkDoubleToScalar(m.matrix().getDouble(1, 0)));
-  flattened->set(4, SkDoubleToScalar(m.matrix().getDouble(1, 1)));
-  flattened->set(5, SkDoubleToScalar(m.matrix().getDouble(1, 3)));
-  flattened->set(6, SkDoubleToScalar(m.matrix().getDouble(3, 0)));
-  flattened->set(7, SkDoubleToScalar(m.matrix().getDouble(3, 1)));
-  flattened->set(8, SkDoubleToScalar(m.matrix().getDouble(3, 3)));
-}
-
 bool IsScaleAndTranslate(const SkMatrix& matrix) {
   return SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMSkewY]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMPersp0]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMPersp1]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMPersp2] - 1.0f);
 }
 
 }  // anonymous namespace
 
@@ skipping 164 matching lines @@
 }
 
 void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
   TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
   SkMatrix sk_device_matrix;
-  ToSkMatrix(&sk_device_matrix, contents_device_transform);
+  gfx::TransformToFlattenedSkMatrix(contents_device_transform,
+                                    &sk_device_matrix);
   current_canvas_->setMatrix(sk_device_matrix);
 
   current_paint_.reset();
   if (!IsScaleAndTranslate(sk_device_matrix)) {
     current_paint_.setAntiAlias(true);
     current_paint_.setFilterBitmap(true);
   }
 
   if (quad->ShouldDrawWithBlending()) {
     current_paint_.setAlpha(quad->opacity() * 255);
@@ skipping 60 matching lines @@
   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(
+    quad->picture_pile->RasterToBitmap(
         &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(
+    quad->picture_pile->RasterDirect(
         current_canvas_, quad->content_rect, quad->contents_scale, NULL);
   }
 }
 
 void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
                                           const SolidColorDrawQuad* quad) {
   current_paint_.setColor(quad->color);
   current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
   current_canvas_->drawRect(gfx::RectFToSkRect(QuadVertexRect()),
                             current_paint_);
@@ skipping 137 matching lines @@
                              4 * rect.width());
 }
 
 void SoftwareRenderer::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
 }
 
 }  // namespace cc