Implements core logic for Pixel Canvas

ui/compositor/layer.cc

 // Copyright (c) 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 22 matching lines @@
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace {
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
+  // Parent walk cannot be done on a layer that is being used as a mask. Get the
+  // layer to which this layer is a mask of.
+  if (layer->layer_mask_back_link())
+    layer = layer->layer_mask_back_link();
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
 }  // namespace
 
 namespace ui {
 
 class Layer::LayerMirror : public LayerDelegate, LayerObserver {
@@ skipping 255 matching lines @@
     if (parent == this)
       return true;
   }
   return false;
 }
 
 void Layer::SetAnimator(LayerAnimator* animator) {
   Compositor* compositor = GetCompositor();
 
   if (animator_) {
-    if (compositor)
+    if (compositor && !layer_mask_back_link())
       animator_->DetachLayerAndTimeline(compositor);
     animator_->SetDelegate(nullptr);
   }
 
   animator_ = animator;
 
   if (animator_) {
     animator_->SetDelegate(this);
-    if (compositor)
+    if (compositor && !layer_mask_back_link())
       animator_->AttachLayerAndTimeline(compositor);
   }
 }
 
 LayerAnimator* Layer::GetAnimator() {
   if (!animator_)
     SetAnimator(LayerAnimator::CreateDefaultAnimator());
   return animator_.get();
 }
 
@@ skipping 598 matching lines @@
 
 scoped_refptr<cc::DisplayItemList> Layer::PaintContentsToDisplayList(
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
   gfx::Rect local_bounds(bounds().size());
   gfx::Rect invalidation(
       gfx::IntersectRects(paint_region_.bounds(), local_bounds));
   paint_region_.Clear();
   auto display_list = make_scoped_refptr(new cc::DisplayItemList);
   if (delegate_) {
-    delegate_->OnPaintLayer(
-        PaintContext(display_list.get(), device_scale_factor_, invalidation));
+    delegate_->OnPaintLayer(PaintContext(display_list.get(),
+                                         device_scale_factor_, invalidation,
+                                         GetCompositor()->is_pixel_canvas()));
   }
   display_list->Finalize();
   // TODO(domlaskowski): Move mirror invalidation to Layer::SchedulePaint.
   for (const auto& mirror : mirrors_)
     mirror->dest()->SchedulePaint(invalidation);
   return display_list;
 }
 
 bool Layer::FillsBoundsCompletely() const { return fills_bounds_completely_; }
 
@@ skipping 306 matching lines @@
   const auto it = std::find_if(mirrors_.begin(), mirrors_.end(),
       [mirror](const std::unique_ptr<LayerMirror>& mirror_ptr) {
         return mirror_ptr.get() == mirror;
       });
 
   DCHECK(it != mirrors_.end());
   mirrors_.erase(it);
 }
 
 }  // namespace ui