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