Skip clearing the canvas before painting the contents of opaque layers

cc/resources/content_layer_updater.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/content_layer_updater.h"
 
 #include "base/debug/trace_event.h"
 #include "base/time/time.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/layer_painter.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkScalar.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
 
 namespace cc {
 
 ContentLayerUpdater::ContentLayerUpdater(
     scoped_ptr<LayerPainter> painter,
     RenderingStatsInstrumentation* stats_instrumentation,
     int layer_id)
     : rendering_stats_instrumentation_(stats_instrumentation),
       layer_id_(layer_id),
-      painter_(painter.Pass()) {}
+      painter_(painter.Pass()),
+      layer_is_opaque_(false) {}
 
 ContentLayerUpdater::~ContentLayerUpdater() {}
 
 void ContentLayerUpdater::set_rendering_stats_instrumentation(
     RenderingStatsInstrumentation* rsi) {
   rendering_stats_instrumentation_ = rsi;
 }
 
 void ContentLayerUpdater::PaintContents(SkCanvas* canvas,
                                         gfx::Rect content_rect,
                                         float contents_width_scale,
                                         float contents_height_scale,
                                         gfx::Rect* resulting_opaque_rect) {
   TRACE_EVENT0("cc", "ContentLayerUpdater::PaintContents");
   canvas->save();
   canvas->translate(SkFloatToScalar(-content_rect.x()),
                     SkFloatToScalar(-content_rect.y()));
 
   gfx::Rect layer_rect = content_rect;
 
   if (contents_width_scale != 1.f || contents_height_scale != 1.f) {
     canvas->scale(SkFloatToScalar(contents_width_scale),
                   SkFloatToScalar(contents_height_scale));
 
     layer_rect = gfx::ScaleToEnclosingRect(
         content_rect, 1.f / contents_width_scale, 1.f / contents_height_scale);
   }
 
-  SkPaint paint;
-  paint.setAntiAlias(false);
-  paint.setXfermodeMode(SkXfermode::kClear_Mode);
   SkRect layer_sk_rect = SkRect::MakeXYWH(
       layer_rect.x(), layer_rect.y(), layer_rect.width(), layer_rect.height());
-  canvas->drawRect(layer_sk_rect, paint);
+
+  // If the layer has opaque contents then there is no need to
+  // clear the canvas before painting.
+  if (!layer_is_opaque_) {
+    SkDevice* device = canvas->getDevice();
+    if (content_rect.width() == device->width() &&
+        content_rect.height() == device->height()) {
+      canvas->clear(SK_ColorTRANSPARENT);
+    } else {
+      SkPaint paint;
+      paint.setAntiAlias(false);
+      paint.setXfermodeMode(SkXfermode::kClear_Mode);
+      canvas->drawRect(layer_sk_rect, paint);

[enne (OOO), 2013/08/27 17:13:04]

Could you just have the first branch of this if/else and remove the second? I
think it makes the code more confusing because it looks as though there's some
contract that pixels outside the content rect should be preserved.

The two ContentLayerUpdater-derived classes both size their canvases to
content_rect.size(), so you could just add a comment to PaintContents that
passing a larger canvas to PaintContents may write to pixels outside the content
rect if you think this is dangerous.

Alternatively, you could just pass a gfx::Vector2d offset instead of a gfx::Rect
to this function for the translation and then create the content_rect internally
based on that offset and canvas size.

+    }
+  }
+
   canvas->clipRect(layer_sk_rect);
 
   gfx::RectF opaque_layer_rect;
   painter_->Paint(canvas, layer_rect, &opaque_layer_rect);
   canvas->restore();
 
   gfx::Rect opaque_content_rect = gfx::ToEnclosedRect(gfx::ScaleRect(
       opaque_layer_rect, contents_width_scale, contents_height_scale));
   *resulting_opaque_rect = opaque_content_rect;
 
   content_rect_ = content_rect;
 }
 
+void ContentLayerUpdater::SetOpaque(bool opaque) {
+  layer_is_opaque_ = opaque;
+}
+
 }  // namespace cc