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