cc/layers/picture_layer.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/layers/picture_layer.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "cc/layers/content_layer_client.h"
   9 #include "cc/layers/picture_layer_impl.h"
  10 #include "cc/resources/display_list_recording_source.h"
  11 #include "cc/resources/picture_pile.h"
  12 #include "cc/trees/layer_tree_impl.h"
  13 #include "third_party/skia/include/core/SkPictureRecorder.h"
  14 #include "ui/gfx/geometry/rect_conversions.h"
  15
  16 namespace cc {
  17
  18 scoped_refptr<PictureLayer> PictureLayer::Create(ContentLayerClient* client) {
  19   return make_scoped_refptr(new PictureLayer(client));
  20 }
  21
  22 PictureLayer::PictureLayer(ContentLayerClient* client)
  23     : client_(client),
  24       instrumentation_object_tracker_(id()),
  25       update_source_frame_number_(-1),
  26       is_mask_(false),
  27       nearest_neighbor_(false) {
  28 }
  29
  30 PictureLayer::PictureLayer(ContentLayerClient* client,
  31                            scoped_ptr<RecordingSource> source)
  32     : PictureLayer(client) {
  33   recording_source_ = source.Pass();
  34 }
  35
  36 PictureLayer::~PictureLayer() {
  37 }
  38
  39 scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
  40   return PictureLayerImpl::Create(tree_impl, id(), is_mask_,
  41                                   new LayerImpl::SyncedScrollOffset);
  42 }
  43
  44 void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
  45   Layer::PushPropertiesTo(base_layer);
  46   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
  47   // TODO(danakj): Make is_mask_ a constructor parameter for PictureLayer.
  48   DCHECK_EQ(layer_impl->is_mask(), is_mask_);
  49
  50   int source_frame_number = layer_tree_host()->source_frame_number();
  51   gfx::Size impl_bounds = layer_impl->bounds();
  52   gfx::Size recording_source_bounds = recording_source_->GetSize();
  53
  54   // If update called, then recording source size must match bounds pushed to
  55   // impl layer.
  56   DCHECK_IMPLIES(update_source_frame_number_ == source_frame_number,
  57                  impl_bounds == recording_source_bounds)
  58       << " bounds " << impl_bounds.ToString() << " recording source "
  59       << recording_source_bounds.ToString();
  60
  61   if (update_source_frame_number_ != source_frame_number &&
  62       recording_source_bounds != impl_bounds) {
  63     // Update may not get called for the layer (if it's not in the viewport
  64     // for example, even though it has resized making the recording source no
  65     // longer valid. In this case just destroy the recording source.
  66     recording_source_->SetEmptyBounds();
  67   }
  68
  69   layer_impl->SetNearestNeighbor(nearest_neighbor_);
  70
  71   // Preserve lcd text settings from the current raster source.
  72   bool can_use_lcd_text = layer_impl->RasterSourceUsesLCDText();
  73   scoped_refptr<RasterSource> raster_source =
  74       recording_source_->CreateRasterSource(can_use_lcd_text);
  75   layer_impl->UpdateRasterSource(raster_source, &recording_invalidation_,
  76                                  nullptr);
  77   DCHECK(recording_invalidation_.IsEmpty());
  78 }
  79
  80 void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) {
  81   Layer::SetLayerTreeHost(host);
  82   if (host) {
  83     if (!recording_source_) {
  84       if (host->settings().use_display_lists) {
  85         recording_source_.reset(new DisplayListRecordingSource);
  86       } else {
  87         recording_source_.reset(
  88             new PicturePile(host->settings().minimum_contents_scale,
  89                             host->settings().default_tile_grid_size));
  90       }
  91     }
  92     recording_source_->DidMoveToNewCompositor();
  93     recording_source_->SetSlowdownRasterScaleFactor(
  94         host->debug_state().slow_down_raster_scale_factor);
  95   }
  96 }
  97
  98 void PictureLayer::SetNeedsDisplayRect(const gfx::Rect& layer_rect) {
  99   if (!layer_rect.IsEmpty()) {
 100     // Clamp invalidation to the layer bounds.
 101     pending_invalidation_.Union(
 102         gfx::IntersectRects(layer_rect, gfx::Rect(bounds())));
 103   }
 104   Layer::SetNeedsDisplayRect(layer_rect);
 105 }
 106
 107 bool PictureLayer::Update(ResourceUpdateQueue* queue,
 108                           const OcclusionTracker<Layer>* occlusion) {
 109   update_source_frame_number_ = layer_tree_host()->source_frame_number();
 110   bool updated = Layer::Update(queue, occlusion);
 111
 112   gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
 113       visible_content_rect(), 1.f / contents_scale_x());
 114   gfx::Size layer_size = paint_properties().bounds;
 115
 116   if (last_updated_visible_content_rect_ == visible_content_rect() &&
 117       recording_source_->GetSize() == layer_size &&
 118       pending_invalidation_.IsEmpty()) {
 119     // Only early out if the visible content rect of this layer hasn't changed.
 120     return updated;
 121   }
 122
 123   recording_source_->SetBackgroundColor(SafeOpaqueBackgroundColor());
 124   recording_source_->SetRequiresClear(!contents_opaque() &&
 125                                       !client_->FillsBoundsCompletely());
 126
 127   TRACE_EVENT1("cc", "PictureLayer::Update",
 128                "source_frame_number",
 129                layer_tree_host()->source_frame_number());
 130   devtools_instrumentation::ScopedLayerTreeTask update_layer(
 131       devtools_instrumentation::kUpdateLayer, id(), layer_tree_host()->id());
 132
 133   // Calling paint in WebKit can sometimes cause invalidations, so save
 134   // off the invalidation prior to calling update.
 135   pending_invalidation_.Swap(&recording_invalidation_);
 136   pending_invalidation_.Clear();
 137
 138   if (layer_tree_host()->settings().record_full_layer) {
 139     // Workaround for http://crbug.com/235910 - to retain backwards compat
 140     // the full page content must always be provided in the picture layer.
 141     visible_layer_rect = gfx::Rect(layer_size);
 142   }
 143
 144   // UpdateAndExpandInvalidation will give us an invalidation that covers
 145   // anything not explicitly recorded in this frame. We give this region
 146   // to the impl side so that it drops tiles that may not have a recording
 147   // for them.
 148   DCHECK(client_);
 149   updated |= recording_source_->UpdateAndExpandInvalidation(
 150       client_, &recording_invalidation_, layer_size, visible_layer_rect,
 151       update_source_frame_number_, RecordingSource::RECORD_NORMALLY);
 152   last_updated_visible_content_rect_ = visible_content_rect();
 153
 154   if (updated) {
 155     SetNeedsPushProperties();
 156   } else {
 157     // If this invalidation did not affect the recording source, then it can be
 158     // cleared as an optimization.
 159     recording_invalidation_.Clear();
 160   }
 161
 162   return updated;
 163 }
 164
 165 void PictureLayer::SetIsMask(bool is_mask) {
 166   is_mask_ = is_mask;
 167 }
 168
 169 skia::RefPtr<SkPicture> PictureLayer::GetPicture() const {
 170   // We could either flatten the RecordingSource into a single SkPicture,
 171   // or paint a fresh one depending on what we intend to do with the
 172   // picture. For now we just paint a fresh one to get consistent results.
 173   if (!DrawsContent())
 174     return skia::RefPtr<SkPicture>();
 175
 176   int width = bounds().width();
 177   int height = bounds().height();
 178
 179   SkPictureRecorder recorder;
 180   SkCanvas* canvas = recorder.beginRecording(width, height, nullptr, 0);
 181   client_->PaintContents(canvas, gfx::Rect(width, height),
 182                          ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
 183   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 184   return picture;
 185 }
 186
 187 bool PictureLayer::IsSuitableForGpuRasterization() const {
 188   return recording_source_->IsSuitableForGpuRasterization();
 189 }
 190
 191 void PictureLayer::ClearClient() {
 192   client_ = nullptr;
 193   UpdateDrawsContent(HasDrawableContent());
 194 }
 195
 196 void PictureLayer::SetNearestNeighbor(bool nearest_neighbor) {
 197   if (nearest_neighbor_ == nearest_neighbor)
 198     return;
 199
 200   nearest_neighbor_ = nearest_neighbor;
 201   SetNeedsCommit();
 202 }
 203
 204 bool PictureLayer::HasDrawableContent() const {
 205   return client_ && Layer::HasDrawableContent();
 206 }
 207
 208 void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) {
 209   benchmark->RunOnLayer(this);
 210 }
 211
 212 }  // namespace cc