src/cc/output/software_renderer.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/output/software_renderer.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "cc/base/math_util.h"
   9 #include "cc/output/compositor_frame.h"
  10 #include "cc/output/compositor_frame_ack.h"
  11 #include "cc/output/compositor_frame_metadata.h"
  12 #include "cc/output/copy_output_request.h"
  13 #include "cc/output/output_surface.h"
  14 #include "cc/output/render_surface_filters.h"
  15 #include "cc/output/software_output_device.h"
  16 #include "cc/quads/checkerboard_draw_quad.h"
  17 #include "cc/quads/debug_border_draw_quad.h"
  18 #include "cc/quads/picture_draw_quad.h"
  19 #include "cc/quads/render_pass_draw_quad.h"
  20 #include "cc/quads/solid_color_draw_quad.h"
  21 #include "cc/quads/texture_draw_quad.h"
  22 #include "cc/quads/tile_draw_quad.h"
  23 #include "skia/ext/opacity_draw_filter.h"
  24 #include "third_party/skia/include/core/SkCanvas.h"
  25 #include "third_party/skia/include/core/SkColor.h"
  26 #include "third_party/skia/include/core/SkImageFilter.h"
  27 #include "third_party/skia/include/core/SkMatrix.h"
  28 #include "third_party/skia/include/core/SkShader.h"
  29 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
  30 #include "ui/gfx/rect_conversions.h"
  31 #include "ui/gfx/skia_util.h"
  32 #include "ui/gfx/transform.h"
  33
  34 namespace cc {
  35
  36 namespace {
  37
  38 static inline bool IsScalarNearlyInteger(SkScalar scalar) {
  39   return SkScalarNearlyZero(scalar - SkScalarRound(scalar));
  40 }
  41
  42 bool IsScaleAndIntegerTranslate(const SkMatrix& matrix) {
  43   return IsScalarNearlyInteger(matrix[SkMatrix::kMTransX]) &&
  44          IsScalarNearlyInteger(matrix[SkMatrix::kMTransY]) &&
  45          SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
  46          SkScalarNearlyZero(matrix[SkMatrix::kMSkewY]) &&
  47          SkScalarNearlyZero(matrix[SkMatrix::kMPersp0]) &&
  48          SkScalarNearlyZero(matrix[SkMatrix::kMPersp1]) &&
  49          SkScalarNearlyZero(matrix[SkMatrix::kMPersp2] - 1.0f);
  50 }
  51
  52 }  // anonymous namespace
  53
  54 scoped_ptr<SoftwareRenderer> SoftwareRenderer::Create(
  55     RendererClient* client,
  56     const LayerTreeSettings* settings,
  57     OutputSurface* output_surface,
  58     ResourceProvider* resource_provider) {
  59   return make_scoped_ptr(new SoftwareRenderer(
  60       client, settings, output_surface, resource_provider));
  61 }
  62
  63 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
  64                                    const LayerTreeSettings* settings,
  65                                    OutputSurface* output_surface,
  66                                    ResourceProvider* resource_provider)
  67     : DirectRenderer(client, settings, output_surface, resource_provider),
  68       visible_(true),
  69       is_scissor_enabled_(false),
  70       is_backbuffer_discarded_(false),
  71       output_device_(output_surface->software_device()),
  72       current_canvas_(NULL) {
  73   if (resource_provider_) {
  74     capabilities_.max_texture_size = resource_provider_->max_texture_size();
  75     capabilities_.best_texture_format =
  76         resource_provider_->best_texture_format();
  77   }
  78   capabilities_.using_set_visibility = true;
  79   // The updater can access bitmaps while the SoftwareRenderer is using them.
  80   capabilities_.allow_partial_texture_updates = true;
  81   capabilities_.using_partial_swap = true;
  82
  83   capabilities_.using_map_image = settings_->use_map_image;
  84   capabilities_.using_shared_memory_resources = true;
  85 }
  86
  87 SoftwareRenderer::~SoftwareRenderer() {}
  88
  89 const RendererCapabilities& SoftwareRenderer::Capabilities() const {
  90   return capabilities_;
  91 }
  92
  93 void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
  94   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
  95   root_canvas_ = output_device_->BeginPaint(
  96       gfx::ToEnclosingRect(frame->root_damage_rect));
  97 }
  98
  99 void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
 100   TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
 101   current_framebuffer_lock_.reset();
 102   current_canvas_ = NULL;
 103   root_canvas_ = NULL;
 104
 105   current_frame_data_.reset(new SoftwareFrameData);
 106   output_device_->EndPaint(current_frame_data_.get());
 107 }
 108
 109 void SoftwareRenderer::SwapBuffers() {
 110   CompositorFrame compositor_frame;
 111   compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
 112   compositor_frame.software_frame_data = current_frame_data_.Pass();
 113   output_surface_->SwapBuffers(&compositor_frame);
 114 }
 115
 116 void SoftwareRenderer::ReceiveSwapBuffersAck(const CompositorFrameAck& ack) {
 117   output_device_->ReclaimSoftwareFrame(ack.last_software_frame_id);
 118 }
 119
 120 bool SoftwareRenderer::FlippedFramebuffer() const {
 121   return false;
 122 }
 123
 124 void SoftwareRenderer::EnsureScissorTestEnabled() {
 125   is_scissor_enabled_ = true;
 126   SetClipRect(scissor_rect_);
 127 }
 128
 129 void SoftwareRenderer::EnsureScissorTestDisabled() {
 130   // There is no explicit notion of enabling/disabling scissoring in software
 131   // rendering, but the underlying effect we want is to clear any existing
 132   // clipRect on the current SkCanvas. This is done by setting clipRect to
 133   // the viewport's dimensions.
 134   is_scissor_enabled_ = false;
 135   SkBaseDevice* device = current_canvas_->getDevice();
 136   SetClipRect(gfx::Rect(device->width(), device->height()));
 137 }
 138
 139 void SoftwareRenderer::Finish() {}
 140
 141 void SoftwareRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
 142   DCHECK(!output_surface_->HasExternalStencilTest());
 143   current_framebuffer_lock_.reset();
 144   current_canvas_ = root_canvas_;
 145 }
 146
 147 bool SoftwareRenderer::BindFramebufferToTexture(
 148     DrawingFrame* frame,
 149     const ScopedResource* texture,
 150     gfx::Rect target_rect) {
 151   current_framebuffer_lock_.reset();
 152   current_framebuffer_lock_ = make_scoped_ptr(
 153       new ResourceProvider::ScopedWriteLockSoftware(
 154           resource_provider_, texture->id()));
 155   current_canvas_ = current_framebuffer_lock_->sk_canvas();
 156   InitializeViewport(frame,
 157                      target_rect,
 158                      gfx::Rect(target_rect.size()),
 159                      target_rect.size());
 160   return true;
 161 }
 162
 163 void SoftwareRenderer::SetScissorTestRect(gfx::Rect scissor_rect) {
 164   is_scissor_enabled_ = true;
 165   scissor_rect_ = scissor_rect;
 166   SetClipRect(scissor_rect);
 167 }
 168
 169 void SoftwareRenderer::SetClipRect(gfx::Rect rect) {
 170   // Skia applies the current matrix to clip rects so we reset it temporary.
 171   SkMatrix current_matrix = current_canvas_->getTotalMatrix();
 172   current_canvas_->resetMatrix();
 173   current_canvas_->clipRect(gfx::RectToSkRect(rect), SkRegion::kReplace_Op);
 174   current_canvas_->setMatrix(current_matrix);
 175 }
 176
 177 void SoftwareRenderer::ClearCanvas(SkColor color) {
 178   // SkCanvas::clear doesn't respect the current clipping region
 179   // so we SkCanvas::drawColor instead if scissoring is active.
 180   if (is_scissor_enabled_)
 181     current_canvas_->drawColor(color, SkXfermode::kSrc_Mode);
 182   else
 183     current_canvas_->clear(color);
 184 }
 185
 186 void SoftwareRenderer::DiscardPixels(bool has_external_stencil_test,
 187                                      bool draw_rect_covers_full_surface) {}
 188
 189 void SoftwareRenderer::ClearFramebuffer(DrawingFrame* frame,
 190                                         bool has_external_stencil_test) {
 191   if (frame->current_render_pass->has_transparent_background) {
 192     ClearCanvas(SkColorSetARGB(0, 0, 0, 0));
 193   } else {
 194 #ifndef NDEBUG
 195     // On DEBUG builds, opaque render passes are cleared to blue
 196     // to easily see regions that were not drawn on the screen.
 197     ClearCanvas(SkColorSetARGB(255, 0, 0, 255));
 198 #endif
 199   }
 200 }
 201
 202 void SoftwareRenderer::SetDrawViewport(gfx::Rect window_space_viewport) {}
 203
 204 bool SoftwareRenderer::IsSoftwareResource(
 205     ResourceProvider::ResourceId resource_id) const {
 206   switch (resource_provider_->GetResourceType(resource_id)) {
 207     case ResourceProvider::GLTexture:
 208       return false;
 209     case ResourceProvider::Bitmap:
 210       return true;
 211     case ResourceProvider::InvalidType:
 212       break;
 213   }
 214
 215   LOG(FATAL) << "Invalid resource type.";
 216   return false;
 217 }
 218
 219 void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
 220   TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
 221   gfx::Transform quad_rect_matrix;
 222   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
 223   gfx::Transform contents_device_transform =
 224       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
 225   contents_device_transform.FlattenTo2d();
 226   SkMatrix sk_device_matrix;
 227   gfx::TransformToFlattenedSkMatrix(contents_device_transform,
 228                                     &sk_device_matrix);
 229   current_canvas_->setMatrix(sk_device_matrix);
 230
 231   current_paint_.reset();
 232   if (!IsScaleAndIntegerTranslate(sk_device_matrix)) {
 233     // TODO(danakj): Until we can enable AA only on exterior edges of the
 234     // layer, disable AA if any interior edges are present. crbug.com/248175
 235     bool all_four_edges_are_exterior = quad->IsTopEdge() &&
 236                                        quad->IsLeftEdge() &&
 237                                        quad->IsBottomEdge() &&
 238                                        quad->IsRightEdge();
 239     if (settings_->allow_antialiasing && all_four_edges_are_exterior)
 240       current_paint_.setAntiAlias(true);
 241     current_paint_.setFilterBitmap(true);
 242   }
 243
 244   if (quad->ShouldDrawWithBlending()) {
 245     current_paint_.setAlpha(quad->opacity() * 255);
 246     current_paint_.setXfermodeMode(SkXfermode::kSrcOver_Mode);
 247   } else {
 248     current_paint_.setXfermodeMode(SkXfermode::kSrc_Mode);
 249   }
 250
 251   switch (quad->material) {
 252     case DrawQuad::CHECKERBOARD:
 253       DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
 254       break;
 255     case DrawQuad::DEBUG_BORDER:
 256       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
 257       break;
 258     case DrawQuad::PICTURE_CONTENT:
 259       DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
 260       break;
 261     case DrawQuad::RENDER_PASS:
 262       DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
 263       break;
 264     case DrawQuad::SOLID_COLOR:
 265       DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
 266       break;
 267     case DrawQuad::TEXTURE_CONTENT:
 268       DrawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
 269       break;
 270     case DrawQuad::TILED_CONTENT:
 271       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
 272       break;
 273     case DrawQuad::INVALID:
 274     case DrawQuad::IO_SURFACE_CONTENT:
 275     case DrawQuad::YUV_VIDEO_CONTENT:
 276     case DrawQuad::STREAM_VIDEO_CONTENT:
 277       DrawUnsupportedQuad(frame, quad);
 278       NOTREACHED();
 279       break;
 280   }
 281
 282   current_canvas_->resetMatrix();
 283 }
 284
 285 void SoftwareRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
 286                                             const CheckerboardDrawQuad* quad) {
 287   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
 288       QuadVertexRect(), quad->rect, quad->visible_rect);
 289   current_paint_.setColor(quad->color);
 290   current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
 291   current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
 292                             current_paint_);
 293 }
 294
 295 void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
 296                                            const DebugBorderDrawQuad* quad) {
 297   // We need to apply the matrix manually to have pixel-sized stroke width.
 298   SkPoint vertices[4];
 299   gfx::RectFToSkRect(QuadVertexRect()).toQuad(vertices);
 300   SkPoint transformed_vertices[4];
 301   current_canvas_->getTotalMatrix().mapPoints(transformed_vertices,
 302                                               vertices,
 303                                               4);
 304   current_canvas_->resetMatrix();
 305
 306   current_paint_.setColor(quad->color);
 307   current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
 308   current_paint_.setStyle(SkPaint::kStroke_Style);
 309   current_paint_.setStrokeWidth(quad->width);
 310   current_canvas_->drawPoints(SkCanvas::kPolygon_PointMode,
 311                               4, transformed_vertices, current_paint_);
 312 }
 313
 314 void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
 315                                        const PictureDrawQuad* quad) {
 316   SkMatrix content_matrix;
 317   content_matrix.setRectToRect(
 318       gfx::RectFToSkRect(quad->tex_coord_rect),
 319       gfx::RectFToSkRect(QuadVertexRect()),
 320       SkMatrix::kFill_ScaleToFit);
 321   current_canvas_->concat(content_matrix);
 322
 323   // TODO(aelias): This isn't correct in all cases. We should detect these
 324   // cases and fall back to a persistent bitmap backing
 325   // (http://crbug.com/280374).
 326   skia::RefPtr<SkDrawFilter> opacity_filter =
 327       skia::AdoptRef(new skia::OpacityDrawFilter(
 328           quad->opacity(), frame->disable_picture_quad_image_filtering));
 329   DCHECK(!current_canvas_->getDrawFilter());
 330   current_canvas_->setDrawFilter(opacity_filter.get());
 331
 332   TRACE_EVENT0("cc",
 333                "SoftwareRenderer::DrawPictureQuad");
 334   quad->picture_pile->RasterDirect(
 335       current_canvas_, quad->content_rect, quad->contents_scale, NULL);
 336
 337   current_canvas_->setDrawFilter(NULL);
 338 }
 339
 340 void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
 341                                           const SolidColorDrawQuad* quad) {
 342   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
 343       QuadVertexRect(), quad->rect, quad->visible_rect);
 344   current_paint_.setColor(quad->color);
 345   current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
 346   current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
 347                             current_paint_);
 348 }
 349
 350 void SoftwareRenderer::DrawTextureQuad(const DrawingFrame* frame,
 351                                        const TextureDrawQuad* quad) {
 352   if (!IsSoftwareResource(quad->resource_id)) {
 353     DrawUnsupportedQuad(frame, quad);
 354     return;
 355   }
 356
 357   // TODO(skaslev): Add support for non-premultiplied alpha.
 358   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
 359                                                 quad->resource_id);
 360   const SkBitmap* bitmap = lock.sk_bitmap();
 361   gfx::RectF uv_rect = gfx::ScaleRect(gfx::BoundingRect(quad->uv_top_left,
 362                                                         quad->uv_bottom_right),
 363                                       bitmap->width(),
 364                                       bitmap->height());
 365   gfx::RectF visible_uv_rect =
 366       MathUtil::ScaleRectProportional(uv_rect, quad->rect, quad->visible_rect);
 367   SkRect sk_uv_rect = gfx::RectFToSkRect(visible_uv_rect);
 368   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
 369       QuadVertexRect(), quad->rect, quad->visible_rect);
 370   SkRect quad_rect = gfx::RectFToSkRect(visible_quad_vertex_rect);
 371
 372   if (quad->flipped)
 373     current_canvas_->scale(1, -1);
 374
 375   bool blend_background = quad->background_color != SK_ColorTRANSPARENT &&
 376                           !bitmap->isOpaque();
 377   bool needs_layer = blend_background && (current_paint_.getAlpha() != 0xFF);
 378   if (needs_layer) {
 379     current_canvas_->saveLayerAlpha(&quad_rect, current_paint_.getAlpha());
 380     current_paint_.setAlpha(0xFF);
 381   }
 382   if (blend_background) {
 383     SkPaint background_paint;
 384     background_paint.setColor(quad->background_color);
 385     current_canvas_->drawRect(quad_rect, background_paint);
 386   }
 387
 388   current_canvas_->drawBitmapRectToRect(*bitmap,
 389                                         &sk_uv_rect,
 390                                         quad_rect,
 391                                         &current_paint_);
 392
 393   if (needs_layer)
 394     current_canvas_->restore();
 395 }
 396
 397 void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
 398                                     const TileDrawQuad* quad) {
 399   DCHECK(!output_surface_->ForcedDrawToSoftwareDevice());
 400   DCHECK(IsSoftwareResource(quad->resource_id));
 401   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
 402                                                 quad->resource_id);
 403   gfx::RectF visible_tex_coord_rect = MathUtil::ScaleRectProportional(
 404       quad->tex_coord_rect, quad->rect, quad->visible_rect);
 405   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
 406       QuadVertexRect(), quad->rect, quad->visible_rect);
 407
 408   SkRect uv_rect = gfx::RectFToSkRect(visible_tex_coord_rect);
 409   current_paint_.setFilterBitmap(true);
 410   current_canvas_->drawBitmapRectToRect(
 411       *lock.sk_bitmap(),
 412       &uv_rect,
 413       gfx::RectFToSkRect(visible_quad_vertex_rect),
 414       &current_paint_);
 415 }
 416
 417 void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
 418                                           const RenderPassDrawQuad* quad) {
 419   ScopedResource* content_texture =
 420       render_pass_textures_.get(quad->render_pass_id);
 421   if (!content_texture || !content_texture->id())
 422     return;
 423
 424   DCHECK(IsSoftwareResource(content_texture->id()));
 425   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
 426                                                 content_texture->id());
 427
 428   SkRect dest_rect = gfx::RectFToSkRect(QuadVertexRect());
 429   SkRect dest_visible_rect = gfx::RectFToSkRect(MathUtil::ScaleRectProportional(
 430       QuadVertexRect(), quad->rect, quad->visible_rect));
 431   SkRect content_rect = SkRect::MakeWH(quad->rect.width(), quad->rect.height());
 432
 433   SkMatrix content_mat;
 434   content_mat.setRectToRect(content_rect, dest_rect,
 435                             SkMatrix::kFill_ScaleToFit);
 436
 437   const SkBitmap* content = lock.sk_bitmap();
 438
 439   SkBitmap filter_bitmap;
 440   if (!quad->filters.IsEmpty()) {
 441     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
 442         quad->filters, content_texture->size());
 443     // TODO(ajuma): In addition origin translation, the canvas should also be
 444     // scaled to accomodate device pixel ratio and pinch zoom. See
 445     // crbug.com/281516 and crbug.com/281518.
 446     // TODO(ajuma): Apply the filter in the same pass as the content where
 447     // possible (e.g. when there's no origin offset). See crbug.com/308201.
 448     if (filter) {
 449       bool is_opaque = false;
 450       skia::RefPtr<SkBaseDevice> device =
 451           skia::AdoptRef(new SkBitmapDevice(SkBitmap::kARGB_8888_Config,
 452                                             content_texture->size().width(),
 453                                             content_texture->size().height(),
 454                                             is_opaque));
 455       SkCanvas canvas(device.get());
 456       SkPaint paint;
 457       paint.setImageFilter(filter.get());
 458       canvas.clear(SK_ColorTRANSPARENT);
 459       canvas.translate(SkIntToScalar(-quad->rect.origin().x()),
 460                        SkIntToScalar(-quad->rect.origin().y()));
 461       canvas.drawSprite(*content, 0, 0, &paint);
 462       bool will_change_pixels = false;
 463       filter_bitmap = device->accessBitmap(will_change_pixels);
 464     }
 465   }
 466
 467   skia::RefPtr<SkShader> shader;
 468   if (filter_bitmap.isNull()) {
 469     shader = skia::AdoptRef(SkShader::CreateBitmapShader(
 470         *content, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
 471   } else {
 472     shader = skia::AdoptRef(SkShader::CreateBitmapShader(
 473         filter_bitmap, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
 474   }
 475   shader->setLocalMatrix(content_mat);
 476   current_paint_.setShader(shader.get());
 477
 478   if (quad->mask_resource_id) {
 479     ResourceProvider::ScopedReadLockSoftware mask_lock(resource_provider_,
 480                                                        quad->mask_resource_id);
 481
 482     const SkBitmap* mask = mask_lock.sk_bitmap();
 483
 484     SkRect mask_rect = SkRect::MakeXYWH(
 485         quad->mask_uv_rect.x() * mask->width(),
 486         quad->mask_uv_rect.y() * mask->height(),
 487         quad->mask_uv_rect.width() * mask->width(),
 488         quad->mask_uv_rect.height() * mask->height());
 489
 490     SkMatrix mask_mat;
 491     mask_mat.setRectToRect(mask_rect, dest_rect, SkMatrix::kFill_ScaleToFit);
 492
 493     skia::RefPtr<SkShader> mask_shader = skia::AdoptRef(
 494         SkShader::CreateBitmapShader(*mask,
 495                                      SkShader::kClamp_TileMode,
 496                                      SkShader::kClamp_TileMode));
 497     mask_shader->setLocalMatrix(mask_mat);
 498
 499     SkPaint mask_paint;
 500     mask_paint.setShader(mask_shader.get());
 501
 502     skia::RefPtr<SkLayerRasterizer> mask_rasterizer =
 503         skia::AdoptRef(new SkLayerRasterizer);
 504     mask_rasterizer->addLayer(mask_paint);
 505
 506     current_paint_.setRasterizer(mask_rasterizer.get());
 507     current_canvas_->drawRect(dest_visible_rect, current_paint_);
 508   } else {
 509     // TODO(skaslev): Apply background filters and blend with content
 510     current_canvas_->drawRect(dest_visible_rect, current_paint_);
 511   }
 512 }
 513
 514 void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
 515                                            const DrawQuad* quad) {
 516 #ifdef NDEBUG
 517   current_paint_.setColor(SK_ColorWHITE);
 518 #else
 519   current_paint_.setColor(SK_ColorMAGENTA);
 520 #endif
 521   current_paint_.setAlpha(quad->opacity() * 255);
 522   current_canvas_->drawRect(gfx::RectFToSkRect(QuadVertexRect()),
 523                             current_paint_);
 524 }
 525
 526 void SoftwareRenderer::CopyCurrentRenderPassToBitmap(
 527     DrawingFrame* frame,
 528     scoped_ptr<CopyOutputRequest> request) {
 529   gfx::Rect copy_rect = frame->current_render_pass->output_rect;
 530   if (request->has_area())
 531     copy_rect.Intersect(request->area());
 532   gfx::Rect window_copy_rect = MoveFromDrawToWindowSpace(copy_rect);
 533
 534   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
 535   bitmap->setConfig(SkBitmap::kARGB_8888_Config,
 536                     window_copy_rect.width(),
 537                     window_copy_rect.height());
 538   current_canvas_->readPixels(
 539       bitmap.get(), window_copy_rect.x(), window_copy_rect.y());
 540
 541   request->SendBitmapResult(bitmap.Pass());
 542 }
 543
 544 void SoftwareRenderer::DiscardBackbuffer() {
 545   if (is_backbuffer_discarded_)
 546     return;
 547
 548   output_surface_->DiscardBackbuffer();
 549
 550   is_backbuffer_discarded_ = true;
 551
 552   // Damage tracker needs a full reset every time framebuffer is discarded.
 553   client_->SetFullRootLayerDamage();
 554 }
 555
 556 void SoftwareRenderer::EnsureBackbuffer() {
 557   if (!is_backbuffer_discarded_)
 558     return;
 559
 560   output_surface_->EnsureBackbuffer();
 561   is_backbuffer_discarded_ = false;
 562 }
 563
 564 void SoftwareRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
 565   TRACE_EVENT0("cc", "SoftwareRenderer::GetFramebufferPixels");
 566   SkBitmap subset_bitmap;
 567   rect += current_viewport_rect_.OffsetFromOrigin();
 568   output_device_->CopyToBitmap(rect, &subset_bitmap);
 569   subset_bitmap.copyPixelsTo(pixels,
 570                              4 * rect.width() * rect.height(),
 571                              4 * rect.width());
 572 }
 573
 574 void SoftwareRenderer::SetVisible(bool visible) {
 575   if (visible_ == visible)
 576     return;
 577   visible_ = visible;
 578
 579   if (visible_)
 580     EnsureBackbuffer();
 581   else
 582     DiscardBackbuffer();
 583 }
 584
 585 }  // namespace cc