cc: turn on strict paint property checking

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 269 matching lines @@
     return;
 
   layer_tree_host_->property_trees()->needs_rebuild = true;
 }
 
 void Layer::AddChild(scoped_refptr<Layer> child) {
   InsertChild(child, children_.size());
 }
 
 void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   child->RemoveFromParent();
   AddDrawableDescendants(child->NumDescendantsThatDrawContent() +
                          (child->DrawsContent() ? 1 : 0));
   child->SetParent(this);
   child->stacking_order_changed_ = true;
 
   index = std::min(index, children_.size());
   children_.insert(children_.begin() + index, child);
   SetNeedsFullTreeSync();
 }
 
 void Layer::RemoveFromParent() {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (parent_)
     parent_->RemoveChildOrDependent(this);
 }
 
 void Layer::RemoveChildOrDependent(Layer* child) {
   if (mask_layer_.get() == child) {
     mask_layer_->SetParent(nullptr);
     mask_layer_ = nullptr;
     SetNeedsFullTreeSync();
     return;
@@ skipping 16 matching lines @@
                            (child->DrawsContent() ? 1 : 0));
     children_.erase(iter);
     SetNeedsFullTreeSync();
     return;
   }
 }
 
 void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) {
   DCHECK(reference);
   DCHECK_EQ(reference->parent(), this);
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
 
   if (reference == new_layer.get())
     return;
 
   // Find the index of |reference| in |children_|.
   auto reference_it =
       std::find_if(children_.begin(), children_.end(),
                    [reference](const scoped_refptr<Layer>& layer) {
                      return layer.get() == reference;
                    });
   DCHECK(reference_it != children_.end());
   size_t reference_index = reference_it - children_.begin();
   reference->RemoveFromParent();
 
   if (new_layer.get()) {
     new_layer->RemoveFromParent();
     InsertChild(new_layer, reference_index);
   }
 }
 
 void Layer::SetBounds(const gfx::Size& size) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
   bounds_ = size;
 
   if (!layer_tree_host_)
     return;
 
   if (ClipNode* clip_node = layer_tree_host_->property_trees()->clip_tree.Node(
           clip_tree_index())) {
     if (clip_node->owner_id == id()) {
       clip_node->data.clip.set_size(gfx::SizeF(size));
       layer_tree_host_->property_trees()->clip_tree.set_needs_update(true);
     }
   }
 
   SetNeedsCommitNoRebuild();
 }
 
 Layer* Layer::RootLayer() {
   Layer* layer = this;
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
 void Layer::RemoveAllChildren() {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   while (children_.size()) {
     Layer* layer = children_[0].get();
     DCHECK_EQ(this, layer->parent());
     layer->RemoveFromParent();
   }
 }
 
 void Layer::SetChildren(const LayerList& children) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (children == children_)
     return;
 
   RemoveAllChildren();
   for (size_t i = 0; i < children.size(); ++i)
     AddChild(children[i]);
 }
 
 bool Layer::HasAncestor(const Layer* ancestor) const {
   for (const Layer* layer = parent(); layer; layer = layer->parent()) {
     if (layer == ancestor)
       return true;
   }
   return false;
 }
 
 void Layer::RequestCopyOfOutput(
     scoped_ptr<CopyOutputRequest> request) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   bool had_no_copy_requests = copy_requests_.empty();
   if (void* source = request->source()) {
     auto it = std::find_if(copy_requests_.begin(), copy_requests_.end(),
                            [source](const scoped_ptr<CopyOutputRequest>& x) {
                              return x->source() == source;
                            });
     if (it != copy_requests_.end())
       copy_requests_.erase(it);
   }
   if (request->IsEmpty())
     return;
   copy_requests_.push_back(std::move(request));
   if (had_no_copy_requests) {
     UpdateNumCopyRequestsForSubtree(1);
   }
   SetNeedsCommit();
 }
 
 void Layer::UpdateNumCopyRequestsForSubtree(int delta) {
   if (!delta)
     return;
   for (Layer* layer = this; layer; layer = layer->parent()) {
     layer->num_layer_or_descendants_with_copy_request_ += delta;
     layer->SetNeedsPushProperties();
     DCHECK_GE(layer->num_layer_or_descendants_with_copy_request_, 0);
   }
 }
 
 void Layer::SetBackgroundColor(SkColor background_color) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (background_color_ == background_color)
     return;
   background_color_ = background_color;
   SetNeedsCommit();
 }
 
 SkColor Layer::SafeOpaqueBackgroundColor() const {
   SkColor color = background_color();
   if (SkColorGetA(color) == 255 && !contents_opaque()) {
     color = SK_ColorTRANSPARENT;
   } else if (SkColorGetA(color) != 255 && contents_opaque()) {
     for (const Layer* layer = parent(); layer;
          layer = layer->parent()) {
       color = layer->background_color();
       if (SkColorGetA(color) == 255)
         break;
     }
     if (SkColorGetA(color) != 255)
       color = layer_tree_host_->background_color();
     if (SkColorGetA(color) != 255)
       color = SkColorSetA(color, 255);
   }
   return color;
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (masks_to_bounds_ == masks_to_bounds)
     return;
   masks_to_bounds_ = masks_to_bounds;
   SetNeedsCommit();
 }
 
 void Layer::SetMaskLayer(Layer* mask_layer) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (mask_layer_.get() == mask_layer)
     return;
   if (mask_layer_.get()) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   mask_layer_ = mask_layer;
   if (mask_layer_.get()) {
     DCHECK(!mask_layer_->parent());
     mask_layer_->RemoveFromParent();
     mask_layer_->SetParent(this);
     mask_layer_->SetIsMask(true);
   }
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetReplicaLayer(Layer* layer) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (replica_layer_.get() == layer)
     return;
   if (replica_layer_.get()) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
   replica_layer_ = layer;
   if (replica_layer_.get()) {
     DCHECK(!replica_layer_->parent());
     replica_layer_->RemoveFromParent();
     replica_layer_->SetParent(this);
   }
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetFilters(const FilterOperations& filters) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (filters_ == filters)
     return;
   filters_ = filters;
   SetNeedsCommit();
 }
 
 bool Layer::FilterIsAnimating() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
                    Animation::FILTER,
                    LayerAnimationController::ObserverType::ACTIVE)
              : layer_tree_host_->IsAnimatingFilterProperty(this);
 }
 
 bool Layer::HasPotentiallyRunningFilterAnimation() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->IsPotentiallyAnimatingProperty(
         Animation::FILTER, LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasPotentiallyRunningFilterAnimation(this);
 }
 
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (background_filters_ == filters)
     return;
   background_filters_ = filters;
   SetNeedsCommit();
 }
 
 void Layer::SetOpacity(float opacity) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   SetNeedsCommit();
 }
 
 bool Layer::OpacityIsAnimating() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
                    Animation::OPACITY,
                    LayerAnimationController::ObserverType::ACTIVE)
              : layer_tree_host_->IsAnimatingOpacityProperty(this);
 }
 
 bool Layer::HasPotentiallyRunningOpacityAnimation() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->IsPotentiallyAnimatingProperty(
         Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasPotentiallyRunningOpacityAnimation(this);
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
 void Layer::SetBlendMode(SkXfermode::Mode blend_mode) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (blend_mode_ == blend_mode)
     return;
 
   // Allowing only blend modes that are defined in the CSS Compositing standard:
   // http://dev.w3.org/fxtf/compositing-1/#blending
   switch (blend_mode) {
     case SkXfermode::kSrcOver_Mode:
     case SkXfermode::kScreen_Mode:
     case SkXfermode::kOverlay_Mode:
     case SkXfermode::kDarken_Mode:
@@ skipping 28 matching lines @@
       // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators
       NOTREACHED();
       return;
   }
 
   blend_mode_ = blend_mode;
   SetNeedsCommit();
 }
 
 void Layer::SetIsRootForIsolatedGroup(bool root) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (is_root_for_isolated_group_ == root)
     return;
   is_root_for_isolated_group_ = root;
   SetNeedsCommit();
 }
 
 void Layer::SetContentsOpaque(bool opaque) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (contents_opaque_ == opaque)
     return;
   contents_opaque_ = opaque;
   SetNeedsCommit();
 }
 
 void Layer::SetPosition(const gfx::PointF& position) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (position_ == position)
     return;
   position_ = position;
 
   if (!layer_tree_host_)
     return;
 
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ skipping 27 matching lines @@
   }
 
   gfx::Transform inverse(gfx::Transform::kSkipInitialization);
   *is_invertible = b.GetInverse(&inverse);
 
   inverse *= a;
   return inverse.Preserves2dAxisAlignment();
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
 
   if (layer_tree_host_) {
     if (TransformNode* transform_node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
       if (transform_node->owner_id == id()) {
         // We need to trigger a rebuild if we could have affected 2d axis
         // alignment. We'll check to see if transform and transform_ are axis
@@ skipping 16 matching lines @@
     }
   }
 
   transform_ = transform;
   transform_is_invertible_ = transform.IsInvertible();
 
   SetNeedsCommit();
 }
 
 void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
 
   if (!layer_tree_host_)
     return;
 
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ skipping 69 matching lines @@
 
 bool Layer::ScrollOffsetAnimationWasInterrupted() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_
                    ->scroll_offset_animation_was_interrupted()
              : layer_tree_host_->ScrollOffsetAnimationWasInterrupted(this);
 }
 
 void Layer::SetScrollParent(Layer* parent) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (scroll_parent_ == parent)
     return;
 
   if (scroll_parent_)
     scroll_parent_->RemoveScrollChild(this);
 
   scroll_parent_ = parent;
 
   if (scroll_parent_)
     scroll_parent_->AddScrollChild(this);
 
   SetNeedsCommit();
 }
 
 void Layer::AddScrollChild(Layer* child) {
   if (!scroll_children_)
     scroll_children_.reset(new std::set<Layer*>);
   scroll_children_->insert(child);
   SetNeedsCommit();
 }
 
 void Layer::RemoveScrollChild(Layer* child) {
   scroll_children_->erase(child);
   if (scroll_children_->empty())
     scroll_children_ = nullptr;
   SetNeedsCommit();
 }
 
 void Layer::SetClipParent(Layer* ancestor) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (clip_parent_ == ancestor)
     return;
 
   if (clip_parent_)
     clip_parent_->RemoveClipChild(this);
 
   clip_parent_ = ancestor;
 
   if (clip_parent_)
     clip_parent_->AddClipChild(this);
@@ skipping 11 matching lines @@
 }
 
 void Layer::RemoveClipChild(Layer* child) {
   clip_children_->erase(child);
   if (clip_children_->empty())
     clip_children_ = nullptr;
   SetNeedsCommit();
 }
 
 void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
 
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
 
   if (!layer_tree_host_)
     return;
 
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
@@ skipping 17 matching lines @@
   scroll_compensation_adjustment_ = scroll_compensation_adjustment;
   SetNeedsCommit();
 }
 
 gfx::Vector2dF Layer::ScrollCompensationAdjustment() const {
   return scroll_compensation_adjustment_;
 }
 
 void Layer::SetScrollOffsetFromImplSide(
     const gfx::ScrollOffset& scroll_offset) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
 
   bool needs_rebuild = true;
   if (TransformNode* transform_node =
@@ skipping 10 matching lines @@
   if (needs_rebuild)
     layer_tree_host_->property_trees()->needs_rebuild = true;
 
   if (!did_scroll_callback_.is_null())
     did_scroll_callback_.Run();
   // The callback could potentially change the layer structure:
   // "this" may have been destroyed during the process.
 }
 
 void Layer::SetScrollClipLayerId(int clip_layer_id) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (scroll_clip_layer_id_ == clip_layer_id)
     return;
   scroll_clip_layer_id_ = clip_layer_id;
   SetNeedsCommit();
 }
 
 void Layer::SetUserScrollable(bool horizontal, bool vertical) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (user_scrollable_horizontal_ == horizontal &&
       user_scrollable_vertical_ == vertical)
     return;
   user_scrollable_horizontal_ = horizontal;
   user_scrollable_vertical_ = vertical;
   SetNeedsCommit();
 }
 
 void Layer::SetShouldScrollOnMainThread(bool should_scroll_on_main_thread) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (should_scroll_on_main_thread_ == should_scroll_on_main_thread)
     return;
   should_scroll_on_main_thread_ = should_scroll_on_main_thread;
   SetNeedsCommit();
 }
 
 void Layer::SetHaveWheelEventHandlers(bool have_wheel_event_handlers) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (have_wheel_event_handlers_ == have_wheel_event_handlers)
     return;
 
   have_wheel_event_handlers_ = have_wheel_event_handlers;
   SetNeedsCommit();
 }
 
 void Layer::SetHaveScrollEventHandlers(bool have_scroll_event_handlers) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (have_scroll_event_handlers_ == have_scroll_event_handlers)
     return;
   have_scroll_event_handlers_ = have_scroll_event_handlers;
   SetNeedsCommit();
 }
 
 void Layer::SetNonFastScrollableRegion(const Region& region) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (non_fast_scrollable_region_ == region)
     return;
   non_fast_scrollable_region_ = region;
   SetNeedsCommit();
 }
 
 void Layer::SetTouchEventHandlerRegion(const Region& region) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (touch_event_handler_region_ == region)
     return;
 
   touch_event_handler_region_ = region;
   SetNeedsCommit();
 }
 
 void Layer::SetScrollBlocksOn(ScrollBlocksOn scroll_blocks_on) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (scroll_blocks_on_ == scroll_blocks_on)
     return;
   scroll_blocks_on_ = scroll_blocks_on;
   SetNeedsCommit();
 }
 
 void Layer::SetForceRenderSurface(bool force) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (force_render_surface_ == force)
     return;
   force_render_surface_ = force;
   SetNeedsCommit();
 }
 
 void Layer::SetDoubleSided(bool double_sided) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (double_sided_ == double_sided)
     return;
   double_sided_ = double_sided;
   SetNeedsCommit();
 }
 
 void Layer::Set3dSortingContextId(int id) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (id == sorting_context_id_)
     return;
   sorting_context_id_ = id;
   SetNeedsCommit();
 }
 
 void Layer::SetTransformTreeIndex(int index) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (transform_tree_index_ == index)
     return;
   transform_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
 int Layer::transform_tree_index() const {
   if (!layer_tree_host_ ||
       layer_tree_host_->property_trees()->sequence_number !=
           property_tree_sequence_number_) {
     return -1;
   }
   return transform_tree_index_;
 }
 
 void Layer::SetClipTreeIndex(int index) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (clip_tree_index_ == index)
     return;
   clip_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
 int Layer::clip_tree_index() const {
   if (!layer_tree_host_ ||
       layer_tree_host_->property_trees()->sequence_number !=
           property_tree_sequence_number_) {
     return -1;
   }
   return clip_tree_index_;
 }
 
 void Layer::SetEffectTreeIndex(int index) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (effect_tree_index_ == index)
     return;
   effect_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
 int Layer::effect_tree_index() const {
   if (!layer_tree_host_ ||
       layer_tree_host_->property_trees()->sequence_number !=
           property_tree_sequence_number_) {
     return -1;
   }
   return effect_tree_index_;
 }
 
 void Layer::InvalidatePropertyTreesIndices() {
   int invalid_property_tree_index = -1;
   SetTransformTreeIndex(invalid_property_tree_index);
   SetClipTreeIndex(invalid_property_tree_index);
   SetEffectTreeIndex(invalid_property_tree_index);
 }
 
 void Layer::SetShouldFlattenTransform(bool should_flatten) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (should_flatten_transform_ == should_flatten)
     return;
   should_flatten_transform_ = should_flatten;
   SetNeedsCommit();
 }
 
 void Layer::SetIsDrawable(bool is_drawable) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (is_drawable_ == is_drawable)
     return;
 
   is_drawable_ = is_drawable;
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void Layer::SetHideLayerAndSubtree(bool hide) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
   SetNeedsCommit();
 }
 
 void Layer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
   if (dirty_rect.IsEmpty())
     return;
@@ skipping 21 matching lines @@
 
   if (layer_tree_host_ && layer_tree_host_->CommitRequested())
     return;
 
   // Only request a commit if we have a fixed positioned descendant.
   if (DescendantIsFixedToContainerLayer())
     SetNeedsCommit();
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (position_constraint_ == constraint)
     return;
   position_constraint_ = constraint;
   SetNeedsCommit();
 }
 
 static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request,
                                         scoped_ptr<CopyOutputResult> result) {
   request->SendResult(std::move(result));
 }
@@ skipping 606 matching lines @@
     const std::vector<FrameTimingRequest>& requests) {
   // TODO(vmpstr): Early out if there are no changes earlier in the call stack.
   if (requests == frame_timing_requests_)
     return;
   frame_timing_requests_ = requests;
   frame_timing_requests_dirty_ = true;
   SetNeedsCommit();
 }
 
 void Layer::SetElementId(uint64_t id) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (element_id_ == id)
     return;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "Layer::SetElementId", "id", id);
   element_id_ = id;
   SetNeedsCommit();
 }
 
 void Layer::SetMutableProperties(uint32_t properties) {
-  DCHECK(IsPropertyChangeAllowed());
+  CHECK(IsPropertyChangeAllowed());
   if (mutable_properties_ == properties)
     return;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "Layer::SetMutableProperties", "properties", properties);
   mutable_properties_ = properties;
   SetNeedsCommit();
 }
 
 void Layer::DidBeginTracing() {
   // We'll be dumping layer trees as part of trace, so make sure
@@ skipping 44 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc