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