cc: Support mask layers in impl-side painting

cc/picture_layer_impl.cc

 // Copyright 2012 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/picture_layer_impl.h"
 
 #include "base/time.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "ui/gfx/quad_f.h"
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id),
       tilings_(this),
       pile_(PicturePileImpl::Create()),
-      last_update_time_(0) {
+      last_update_time_(0),
+      is_mask_(false) {
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
 }
 
 const char* PictureLayerImpl::layerTypeAsString() const {
   return "PictureLayer";
 }
 
 void PictureLayerImpl::appendQuads(QuadSink& quadSink,
@@ skipping 89 matching lines @@
 
 void PictureLayerImpl::dumpLayerProperties(std::string*, int indent) const {
   // TODO(enne): implement me
 }
 
 void PictureLayerImpl::didUpdateTransforms() {
   if (drawsContent()) {
     // TODO(enne): Add tilings during pinch zoom
     // TODO(enne): Consider culling old tilings after pinch finishes.
     if (!tilings_.num_tilings()) {
-      gfx::Size tile_size = layerTreeImpl()->settings().defaultTileSize;
-      AddTiling(contentsScaleX(), tile_size);
+      AddTiling(contentsScaleX(), TileSize());
       // TODO(enne): Add a low-res tiling as well.
     }
   } else {
     // TODO(enne): This should be unnecessary once there are two trees.
     tilings_.Reset();
   }
 
-  gfx::Transform  current_screen_space_transform = screenSpaceTransform();
+  gfx::Transform current_screen_space_transform =
+      screenSpaceTransform();
   double current_time =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   double time_delta = 0;
   if (last_update_time_ != 0 && last_bounds_ == bounds() &&
       last_content_bounds_ == contentBounds() &&
       last_content_scale_x_ == contentsScaleX() &&
       last_content_scale_y_ == contentsScaleY()) {
     time_delta = current_time - last_update_time_;
   }
   WhichTree tree = layerTreeImpl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   tilings_.UpdateTilePriorities(
       tree,
       layerTreeImpl()->device_viewport_size(),
       contentsScaleX(),
       contentsScaleY(),
       last_screen_space_transform_,
       current_screen_space_transform,
       time_delta);
 
   last_screen_space_transform_ = current_screen_space_transform;
   last_update_time_ = current_time;
   last_bounds_ = bounds();
   last_content_bounds_ = contentBounds();
   last_content_scale_x_ = contentsScaleX();
   last_content_scale_y_ = contentsScaleY();
 }
 
 void PictureLayerImpl::didUpdateBounds() {
+  if (is_mask_)
+    tilings_.Reset();
   tilings_.SetLayerBounds(bounds());
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                  gfx::Rect rect) {
   TileManager* tile_manager = layerTreeImpl()->tile_manager();
 
   return make_scoped_refptr(new Tile(
       tile_manager,
       pile_.get(),
@@ skipping 20 matching lines @@
 
 void PictureLayerImpl::SyncFromActiveLayer(const PictureLayerImpl* other) {
   tilings_.CloneAll(other->tilings_, invalidation_);
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
   tilings_.Clone(tiling, invalidation_);
 }
 
+void PictureLayerImpl::SetIsMask(bool is_mask) {
+  if (is_mask_ == is_mask)
+    return;
+  is_mask_ = is_mask;
+  tilings_.Reset();
+}
+
+ResourceProvider::ResourceId PictureLayerImpl::contentsResourceId() const {
+  gfx::Rect content_rect(gfx::Point(), contentBounds());
+  float scale = contentsScaleX();
+  for (PictureLayerTilingSet::Iterator iter(&tilings_, scale, content_rect);
+       iter;
+       ++iter) {
+    // Mask resource not ready yet.
+    if (!*iter || !iter->GetResourceId())
+      return 0;
+    // Masks only supported if they fit on exactly one tile.
+    if (iter.geometry_rect() != content_rect)
+      return 0;
+    return iter->GetResourceId();
+  }
+  return 0;
+}
+
 void PictureLayerImpl::AddTiling(float contents_scale, gfx::Size tile_size) {
   const PictureLayerTiling* tiling = tilings_.AddTiling(
       contents_scale,
       tile_size);
 
   // If a new tiling is created on the active tree, sync it to the pending tree
   // so that it can share the same tiles.
   if (layerTreeImpl()->IsPendingTree())
     return;
 
   PictureLayerImpl* pending_twin = static_cast<PictureLayerImpl*>(
       layerTreeImpl()->FindPendingTreeLayerById(id()));
   if (!pending_twin)
     return;
   DCHECK_EQ(id(), pending_twin->id());
   pending_twin->SyncTiling(tiling);
 }
 
+gfx::Size PictureLayerImpl::TileSize() const {
+  if (is_mask_) {
+    int max_size = layerTreeImpl()->MaxTextureSize();
+    return gfx::Size(
+        std::min(max_size, contentBounds().width()),
+        std::min(max_size, contentBounds().height()));
+  }
+
+  return layerTreeImpl()->settings().defaultTileSize;
+}
+
 }  // namespace cc