Remove DCHECK_IMPLIES and CHECK_IMPLIES

cc/layers/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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 83 matching lines @@
                                   synced_scroll_offset());
 }
 
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
   DCHECK_EQ(layer_impl->is_mask_, is_mask_);
 
   LayerImpl::PushPropertiesTo(base_layer);
 
   // Twin relationships should never change once established.
-  DCHECK_IMPLIES(twin_layer_, twin_layer_ == layer_impl);
-  DCHECK_IMPLIES(twin_layer_, layer_impl->twin_layer_ == this);
+  DCHECK(!twin_layer_ || (twin_layer_ == layer_impl));
+  DCHECK(!twin_layer_ || (layer_impl->twin_layer_ == this));
   // The twin relationship does not need to exist before the first
   // PushPropertiesTo from pending to active layer since before that the active
   // layer can not have a pile or tilings, it has only been created and inserted
   // into the tree at that point.
   twin_layer_ = layer_impl;
   layer_impl->twin_layer_ = this;
 
   layer_impl->SetNearestNeighbor(nearest_neighbor_);
 
   // Solid color layers have no tilings.
-  DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
+  DCHECK(!raster_source_->IsSolidColor() || (tilings_->num_tilings() == 0));
   // The pending tree should only have a high res (and possibly low res) tiling.
   DCHECK_LE(tilings_->num_tilings(),
             layer_tree_impl()->create_low_res_tiling() ? 2u : 1u);
 
   layer_impl->set_gpu_raster_max_texture_size(gpu_raster_max_texture_size_);
   layer_impl->UpdateRasterSource(raster_source_, &invalidation_,
                                  tilings_.get());
   DCHECK(invalidation_.IsEmpty());
 
   // After syncing a solid color layer, the active layer has no tilings.
-  DCHECK_IMPLIES(raster_source_->IsSolidColor(),
-                 layer_impl->tilings_->num_tilings() == 0);
+  DCHECK(!raster_source_->IsSolidColor() ||
+         (layer_impl->tilings_->num_tilings() == 0));
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
 
   layer_impl->SanityCheckTilingState();
 
   // We always need to push properties.
   // See http://crbug.com/303943
   // TODO(danakj): Stop always pushing properties since we don't swap tilings.
   needs_push_properties_ = true;
 }
 
 void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
                                    AppendQuadsData* append_quads_data) {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
-  DCHECK_IMPLIES(!raster_source_->GetSize().IsEmpty(),
-                 bounds() == raster_source_->GetSize())
+  DCHECK(raster_source_->GetSize().IsEmpty() ||
+         (bounds() == raster_source_->GetSize()))
       << " bounds " << bounds().ToString() << " pile "
       << raster_source_->GetSize().ToString();
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
 
   if (raster_source_->IsSolidColor()) {
     PopulateSharedQuadState(shared_quad_state);
 
     AppendDebugBorderQuad(
@@ skipping 342 matching lines @@
     return nullptr;
   return twin_layer_;
 }
 
 void PictureLayerImpl::UpdateRasterSource(
     scoped_refptr<RasterSource> raster_source,
     Region* new_invalidation,
     const PictureLayerTilingSet* pending_set) {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
-  DCHECK_IMPLIES(!raster_source->GetSize().IsEmpty(),
-                 bounds() == raster_source->GetSize())
+  DCHECK(raster_source->GetSize().IsEmpty() ||
+         (bounds() == raster_source->GetSize()))
       << " bounds " << bounds().ToString() << " pile "
       << raster_source->GetSize().ToString();
 
   // The |raster_source_| is initially null, so have to check for that for the
   // first frame.
   bool could_have_tilings = raster_source_.get() && CanHaveTilings();
   raster_source_.swap(raster_source);
 
   // The |new_invalidation| must be cleared before updating tilings since they
   // access the invalidation through the PictureLayerTilingClient interface.
   invalidation_.Clear();
   invalidation_.Swap(new_invalidation);
 
   bool can_have_tilings = CanHaveTilings();
-  DCHECK_IMPLIES(
-      pending_set,
-      can_have_tilings == GetPendingOrActiveTwinLayer()->CanHaveTilings());
+  DCHECK(!pending_set ||
+         (can_have_tilings == GetPendingOrActiveTwinLayer()->CanHaveTilings()));
 
   // Need to call UpdateTiles again if CanHaveTilings changed.
   if (could_have_tilings != can_have_tilings)
     layer_tree_impl()->set_needs_update_draw_properties();
 
   if (!can_have_tilings) {
     RemoveAllTilings();
     return;
   }
 
@@ skipping 209 matching lines @@
   // Under no circumstance should we be larger than the max texture size.
   tile_width = std::min(tile_width, max_texture_size);
   tile_height = std::min(tile_height, max_texture_size);
   return gfx::Size(tile_width, tile_height);
 }
 
 void PictureLayerImpl::GetContentsResourceId(ResourceId* resource_id,
                                              gfx::Size* resource_size) const {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
-  DCHECK_IMPLIES(!raster_source_->GetSize().IsEmpty(),
-                 bounds() == raster_source_->GetSize())
+  DCHECK(raster_source_->GetSize().IsEmpty() ||
+         (bounds() == raster_source_->GetSize()))
       << " bounds " << bounds().ToString() << " pile "
       << raster_source_->GetSize().ToString();
   gfx::Rect content_rect(bounds());
   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), 1.f, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
   if (!iter || !*iter) {
     *resource_id = 0;
     return;
@@ skipping 463 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc