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