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
34namespace cc {
35
36namespace {
37
38static inline bool IsScalarNearlyInteger(SkScalar scalar) {
39  return SkScalarNearlyZero(scalar - SkScalarRound(scalar));
40}
41
42bool 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
52static SkShader::TileMode WrapModeToTileMode(GLint wrap_mode) {
53  switch (wrap_mode) {
54    case GL_REPEAT:
55      return SkShader::kRepeat_TileMode;
56    case GL_CLAMP_TO_EDGE:
57      return SkShader::kClamp_TileMode;
58  }
59  NOTREACHED();
60  return SkShader::kClamp_TileMode;
61}
62
63}  // anonymous namespace
64
65scoped_ptr<SoftwareRenderer> SoftwareRenderer::Create(
66    RendererClient* client,
67    const LayerTreeSettings* settings,
68    OutputSurface* output_surface,
69    ResourceProvider* resource_provider) {
70  return make_scoped_ptr(new SoftwareRenderer(
71      client, settings, output_surface, resource_provider));
72}
73
74SoftwareRenderer::SoftwareRenderer(RendererClient* client,
75                                   const LayerTreeSettings* settings,
76                                   OutputSurface* output_surface,
77                                   ResourceProvider* resource_provider)
78    : DirectRenderer(client, settings, output_surface, resource_provider),
79      visible_(true),
80      is_scissor_enabled_(false),
81      is_backbuffer_discarded_(false),
82      output_device_(output_surface->software_device()),
83      current_canvas_(NULL) {
84  if (resource_provider_) {
85    capabilities_.max_texture_size = resource_provider_->max_texture_size();
86    capabilities_.best_texture_format =
87        resource_provider_->best_texture_format();
88  }
89  // The updater can access bitmaps while the SoftwareRenderer is using them.
90  capabilities_.allow_partial_texture_updates = true;
91  capabilities_.using_partial_swap = true;
92
93  capabilities_.using_map_image = settings_->use_map_image;
94  capabilities_.using_shared_memory_resources = true;
95}
96
97SoftwareRenderer::~SoftwareRenderer() {}
98
99const RendererCapabilitiesImpl& SoftwareRenderer::Capabilities() const {
100  return capabilities_;
101}
102
103void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
104  TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
105  root_canvas_ = output_device_->BeginPaint(
106      gfx::ToEnclosingRect(frame->root_damage_rect));
107}
108
109void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
110  TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
111  current_framebuffer_lock_.reset();
112  current_canvas_ = NULL;
113  root_canvas_ = NULL;
114
115  current_frame_data_.reset(new SoftwareFrameData);
116  output_device_->EndPaint(current_frame_data_.get());
117}
118
119void SoftwareRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
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  SkBaseDevice* device = current_canvas_->getDevice();
146  SetClipRect(gfx::Rect(device->width(), device->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    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(gfx::Rect scissor_rect) {
174  is_scissor_enabled_ = true;
175  scissor_rect_ = scissor_rect;
176  SetClipRect(scissor_rect);
177}
178
179void SoftwareRenderer::SetClipRect(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(gfx::Rect window_space_viewport) {}
213
214bool SoftwareRenderer::IsSoftwareResource(
215    ResourceProvider::ResourceId resource_id) const {
216  switch (resource_provider_->GetResourceType(resource_id)) {
217    case ResourceProvider::GLTexture:
218      return false;
219    case ResourceProvider::Bitmap:
220      return true;
221    case ResourceProvider::InvalidType:
222      break;
223  }
224
225  LOG(FATAL) << "Invalid resource type.";
226  return false;
227}
228
229void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
230  TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
231  gfx::Transform quad_rect_matrix;
232  QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
233  gfx::Transform contents_device_transform =
234      frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
235  contents_device_transform.FlattenTo2d();
236  SkMatrix sk_device_matrix;
237  gfx::TransformToFlattenedSkMatrix(contents_device_transform,
238                                    &sk_device_matrix);
239  current_canvas_->setMatrix(sk_device_matrix);
240
241  current_paint_.reset();
242  if (!IsScaleAndIntegerTranslate(sk_device_matrix)) {
243    // TODO(danakj): Until we can enable AA only on exterior edges of the
244    // layer, disable AA if any interior edges are present. crbug.com/248175
245    bool all_four_edges_are_exterior = quad->IsTopEdge() &&
246                                       quad->IsLeftEdge() &&
247                                       quad->IsBottomEdge() &&
248                                       quad->IsRightEdge();
249    if (settings_->allow_antialiasing && all_four_edges_are_exterior)
250      current_paint_.setAntiAlias(true);
251    current_paint_.setFilterBitmap(true);
252  }
253
254  if (quad->ShouldDrawWithBlending()) {
255    current_paint_.setAlpha(quad->opacity() * 255);
256    current_paint_.setXfermodeMode(SkXfermode::kSrcOver_Mode);
257  } else {
258    current_paint_.setXfermodeMode(SkXfermode::kSrc_Mode);
259  }
260
261  switch (quad->material) {
262    case DrawQuad::CHECKERBOARD:
263      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
264      break;
265    case DrawQuad::DEBUG_BORDER:
266      DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
267      break;
268    case DrawQuad::PICTURE_CONTENT:
269      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
270      break;
271    case DrawQuad::RENDER_PASS:
272      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
273      break;
274    case DrawQuad::SOLID_COLOR:
275      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
276      break;
277    case DrawQuad::TEXTURE_CONTENT:
278      DrawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
279      break;
280    case DrawQuad::TILED_CONTENT:
281      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
282      break;
283    case DrawQuad::INVALID:
284    case DrawQuad::IO_SURFACE_CONTENT:
285    case DrawQuad::YUV_VIDEO_CONTENT:
286    case DrawQuad::STREAM_VIDEO_CONTENT:
287      DrawUnsupportedQuad(frame, quad);
288      NOTREACHED();
289      break;
290  }
291
292  current_canvas_->resetMatrix();
293}
294
295void SoftwareRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
296                                            const CheckerboardDrawQuad* quad) {
297  gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
298      QuadVertexRect(), quad->rect, quad->visible_rect);
299  current_paint_.setColor(quad->color);
300  current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
301  current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
302                            current_paint_);
303}
304
305void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
306                                           const DebugBorderDrawQuad* quad) {
307  // We need to apply the matrix manually to have pixel-sized stroke width.
308  SkPoint vertices[4];
309  gfx::RectFToSkRect(QuadVertexRect()).toQuad(vertices);
310  SkPoint transformed_vertices[4];
311  current_canvas_->getTotalMatrix().mapPoints(transformed_vertices,
312                                              vertices,
313                                              4);
314  current_canvas_->resetMatrix();
315
316  current_paint_.setColor(quad->color);
317  current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
318  current_paint_.setStyle(SkPaint::kStroke_Style);
319  current_paint_.setStrokeWidth(quad->width);
320  current_canvas_->drawPoints(SkCanvas::kPolygon_PointMode,
321                              4, transformed_vertices, current_paint_);
322}
323
324void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
325                                       const PictureDrawQuad* quad) {
326  SkMatrix content_matrix;
327  content_matrix.setRectToRect(
328      gfx::RectFToSkRect(quad->tex_coord_rect),
329      gfx::RectFToSkRect(QuadVertexRect()),
330      SkMatrix::kFill_ScaleToFit);
331  current_canvas_->concat(content_matrix);
332
333  // TODO(aelias): This isn't correct in all cases. We should detect these
334  // cases and fall back to a persistent bitmap backing
335  // (http://crbug.com/280374).
336  skia::RefPtr<SkDrawFilter> opacity_filter =
337      skia::AdoptRef(new skia::OpacityDrawFilter(
338          quad->opacity(), frame->disable_picture_quad_image_filtering));
339  DCHECK(!current_canvas_->getDrawFilter());
340  current_canvas_->setDrawFilter(opacity_filter.get());
341
342  TRACE_EVENT0("cc",
343               "SoftwareRenderer::DrawPictureQuad");
344  quad->picture_pile->RasterDirect(
345      current_canvas_, quad->content_rect, quad->contents_scale, NULL);
346
347  current_canvas_->setDrawFilter(NULL);
348}
349
350void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
351                                          const SolidColorDrawQuad* quad) {
352  gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
353      QuadVertexRect(), quad->rect, quad->visible_rect);
354  current_paint_.setColor(quad->color);
355  current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
356  current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
357                            current_paint_);
358}
359
360void SoftwareRenderer::DrawTextureQuad(const DrawingFrame* frame,
361                                       const TextureDrawQuad* quad) {
362  if (!IsSoftwareResource(quad->resource_id)) {
363    DrawUnsupportedQuad(frame, quad);
364    return;
365  }
366
367  // TODO(skaslev): Add support for non-premultiplied alpha.
368  ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
369                                                quad->resource_id);
370  const SkBitmap* bitmap = lock.sk_bitmap();
371  gfx::RectF uv_rect = gfx::ScaleRect(gfx::BoundingRect(quad->uv_top_left,
372                                                        quad->uv_bottom_right),
373                                      bitmap->width(),
374                                      bitmap->height());
375  gfx::RectF visible_uv_rect =
376      MathUtil::ScaleRectProportional(uv_rect, quad->rect, quad->visible_rect);
377  SkRect sk_uv_rect = gfx::RectFToSkRect(visible_uv_rect);
378  gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
379      QuadVertexRect(), quad->rect, quad->visible_rect);
380  SkRect quad_rect = gfx::RectFToSkRect(visible_quad_vertex_rect);
381
382  if (quad->flipped)
383    current_canvas_->scale(1, -1);
384
385  bool blend_background = quad->background_color != SK_ColorTRANSPARENT &&
386                          !bitmap->isOpaque();
387  bool needs_layer = blend_background && (current_paint_.getAlpha() != 0xFF);
388  if (needs_layer) {
389    current_canvas_->saveLayerAlpha(&quad_rect, current_paint_.getAlpha());
390    current_paint_.setAlpha(0xFF);
391  }
392  if (blend_background) {
393    SkPaint background_paint;
394    background_paint.setColor(quad->background_color);
395    current_canvas_->drawRect(quad_rect, background_paint);
396  }
397  SkShader::TileMode tile_mode = WrapModeToTileMode(lock.wrap_mode());
398  if (tile_mode != SkShader::kClamp_TileMode) {
399    SkMatrix matrix;
400    matrix.setRectToRect(sk_uv_rect, quad_rect, SkMatrix::kFill_ScaleToFit);
401    skia::RefPtr<SkShader> shader = skia::AdoptRef(
402        SkShader::CreateBitmapShader(*bitmap, tile_mode, tile_mode));
403    shader->setLocalMatrix(matrix);
404    SkPaint paint;
405    paint.setStyle(SkPaint::kFill_Style);
406    paint.setShader(shader.get());
407    current_canvas_->drawRect(quad_rect, paint);
408  } else {
409    current_canvas_->drawBitmapRectToRect(*bitmap,
410                                          &sk_uv_rect,
411                                          quad_rect,
412                                          &current_paint_);
413  }
414
415  if (needs_layer)
416    current_canvas_->restore();
417}
418
419void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
420                                    const TileDrawQuad* quad) {
421  DCHECK(!output_surface_->ForcedDrawToSoftwareDevice());
422  DCHECK(IsSoftwareResource(quad->resource_id));
423
424  ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
425                                                quad->resource_id);
426  DCHECK_EQ(GL_CLAMP_TO_EDGE, lock.wrap_mode());
427
428  gfx::RectF visible_tex_coord_rect = MathUtil::ScaleRectProportional(
429      quad->tex_coord_rect, quad->rect, quad->visible_rect);
430  gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
431      QuadVertexRect(), quad->rect, quad->visible_rect);
432
433  SkRect uv_rect = gfx::RectFToSkRect(visible_tex_coord_rect);
434  current_paint_.setFilterBitmap(true);
435  current_canvas_->drawBitmapRectToRect(
436      *lock.sk_bitmap(),
437      &uv_rect,
438      gfx::RectFToSkRect(visible_quad_vertex_rect),
439      &current_paint_);
440}
441
442void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
443                                          const RenderPassDrawQuad* quad) {
444  ScopedResource* content_texture =
445      render_pass_textures_.get(quad->render_pass_id);
446  if (!content_texture || !content_texture->id())
447    return;
448
449  DCHECK(IsSoftwareResource(content_texture->id()));
450  ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
451                                                content_texture->id());
452  SkShader::TileMode content_tile_mode = WrapModeToTileMode(lock.wrap_mode());
453
454  SkRect dest_rect = gfx::RectFToSkRect(QuadVertexRect());
455  SkRect dest_visible_rect = gfx::RectFToSkRect(MathUtil::ScaleRectProportional(
456      QuadVertexRect(), quad->rect, quad->visible_rect));
457  SkRect content_rect = SkRect::MakeWH(quad->rect.width(), quad->rect.height());
458
459  SkMatrix content_mat;
460  content_mat.setRectToRect(content_rect, dest_rect,
461                            SkMatrix::kFill_ScaleToFit);
462
463  const SkBitmap* content = lock.sk_bitmap();
464
465  SkBitmap filter_bitmap;
466  if (!quad->filters.IsEmpty()) {
467    skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
468        quad->filters, content_texture->size());
469    // TODO(ajuma): In addition origin translation, the canvas should also be
470    // scaled to accomodate device pixel ratio and pinch zoom. See
471    // crbug.com/281516 and crbug.com/281518.
472    // TODO(ajuma): Apply the filter in the same pass as the content where
473    // possible (e.g. when there's no origin offset). See crbug.com/308201.
474    if (filter) {
475      bool is_opaque = false;
476      skia::RefPtr<SkBaseDevice> device =
477          skia::AdoptRef(new SkBitmapDevice(SkBitmap::kARGB_8888_Config,
478                                            content_texture->size().width(),
479                                            content_texture->size().height(),
480                                            is_opaque));
481      SkCanvas canvas(device.get());
482      SkPaint paint;
483      paint.setImageFilter(filter.get());
484      canvas.clear(SK_ColorTRANSPARENT);
485      canvas.translate(SkIntToScalar(-quad->rect.origin().x()),
486                       SkIntToScalar(-quad->rect.origin().y()));
487      canvas.drawSprite(*content, 0, 0, &paint);
488      bool will_change_pixels = false;
489      filter_bitmap = device->accessBitmap(will_change_pixels);
490    }
491  }
492
493  skia::RefPtr<SkShader> shader;
494  if (filter_bitmap.isNull()) {
495    shader = skia::AdoptRef(SkShader::CreateBitmapShader(
496        *content, content_tile_mode, content_tile_mode));
497  } else {
498    shader = skia::AdoptRef(SkShader::CreateBitmapShader(
499        filter_bitmap, content_tile_mode, content_tile_mode));
500  }
501  shader->setLocalMatrix(content_mat);
502  current_paint_.setShader(shader.get());
503
504  if (quad->mask_resource_id) {
505    ResourceProvider::ScopedReadLockSoftware mask_lock(resource_provider_,
506                                                       quad->mask_resource_id);
507    SkShader::TileMode mask_tile_mode = WrapModeToTileMode(
508        mask_lock.wrap_mode());
509
510    const SkBitmap* mask = mask_lock.sk_bitmap();
511
512    SkRect mask_rect = SkRect::MakeXYWH(
513        quad->mask_uv_rect.x() * mask->width(),
514        quad->mask_uv_rect.y() * mask->height(),
515        quad->mask_uv_rect.width() * mask->width(),
516        quad->mask_uv_rect.height() * mask->height());
517
518    SkMatrix mask_mat;
519    mask_mat.setRectToRect(mask_rect, dest_rect, SkMatrix::kFill_ScaleToFit);
520
521    skia::RefPtr<SkShader> mask_shader = skia::AdoptRef(
522        SkShader::CreateBitmapShader(*mask, mask_tile_mode, mask_tile_mode));
523    mask_shader->setLocalMatrix(mask_mat);
524
525    SkPaint mask_paint;
526    mask_paint.setShader(mask_shader.get());
527
528    skia::RefPtr<SkLayerRasterizer> mask_rasterizer =
529        skia::AdoptRef(new SkLayerRasterizer);
530    mask_rasterizer->addLayer(mask_paint);
531
532    current_paint_.setRasterizer(mask_rasterizer.get());
533    current_canvas_->drawRect(dest_visible_rect, current_paint_);
534  } else {
535    // TODO(skaslev): Apply background filters and blend with content
536    current_canvas_->drawRect(dest_visible_rect, current_paint_);
537  }
538}
539
540void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
541                                           const DrawQuad* quad) {
542#ifdef NDEBUG
543  current_paint_.setColor(SK_ColorWHITE);
544#else
545  current_paint_.setColor(SK_ColorMAGENTA);
546#endif
547  current_paint_.setAlpha(quad->opacity() * 255);
548  current_canvas_->drawRect(gfx::RectFToSkRect(QuadVertexRect()),
549                            current_paint_);
550}
551
552void SoftwareRenderer::CopyCurrentRenderPassToBitmap(
553    DrawingFrame* frame,
554    scoped_ptr<CopyOutputRequest> request) {
555  gfx::Rect copy_rect = frame->current_render_pass->output_rect;
556  if (request->has_area())
557    copy_rect.Intersect(request->area());
558  gfx::Rect window_copy_rect = MoveFromDrawToWindowSpace(copy_rect);
559
560  scoped_ptr<SkBitmap> bitmap(new SkBitmap);
561  bitmap->setConfig(SkBitmap::kARGB_8888_Config,
562                    window_copy_rect.width(),
563                    window_copy_rect.height());
564  current_canvas_->readPixels(
565      bitmap.get(), window_copy_rect.x(), window_copy_rect.y());
566
567  request->SendBitmapResult(bitmap.Pass());
568}
569
570void SoftwareRenderer::DiscardBackbuffer() {
571  if (is_backbuffer_discarded_)
572    return;
573
574  output_surface_->DiscardBackbuffer();
575
576  is_backbuffer_discarded_ = true;
577
578  // Damage tracker needs a full reset every time framebuffer is discarded.
579  client_->SetFullRootLayerDamage();
580}
581
582void SoftwareRenderer::EnsureBackbuffer() {
583  if (!is_backbuffer_discarded_)
584    return;
585
586  output_surface_->EnsureBackbuffer();
587  is_backbuffer_discarded_ = false;
588}
589
590void SoftwareRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
591  TRACE_EVENT0("cc", "SoftwareRenderer::GetFramebufferPixels");
592  SkBitmap subset_bitmap;
593  rect += current_viewport_rect_.OffsetFromOrigin();
594  output_device_->CopyToBitmap(rect, &subset_bitmap);
595  subset_bitmap.copyPixelsTo(pixels,
596                             4 * rect.width() * rect.height(),
597                             4 * rect.width());
598}
599
600void SoftwareRenderer::SetVisible(bool visible) {
601  if (visible_ == visible)
602    return;
603  visible_ = visible;
604
605  if (visible_)
606    EnsureBackbuffer();
607  else
608    DiscardBackbuffer();
609}
610
611}  // namespace cc
612