Remove DCHECK_IMPLIES and CHECK_IMPLIES

content/common/discardable_shared_memory_heap.cc

 // Copyright 2014 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 "content/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 
 #include "base/memory/discardable_shared_memory.h"
 #include "base/strings/stringprintf.h"
@@ skipping 131 matching lines @@
   InsertIntoFreeList(span.Pass());
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::Split(Span* span, size_t blocks) {
   DCHECK(blocks);
   DCHECK_LT(blocks, span->length_);
 
   scoped_ptr<Span> leftover(new Span(
       span->shared_memory_, span->start_ + blocks, span->length_ - blocks));
-  DCHECK_IMPLIES(leftover->length_ > 1,
-                 spans_.find(leftover->start_) == spans_.end());
+  DCHECK((leftover->length_ <= 1) ||

[danakj, 2015/06/29 19:30:58]

can you make this == 1? I think that blocks<span->length due to above, so this
will be >= 1 (please double check my thinking :))

+         (spans_.find(leftover->start_) == spans_.end()));
   RegisterSpan(leftover.get());
   spans_[span->start_ + blocks - 1] = span;
   span->length_ = blocks;
   return leftover.Pass();
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::SearchFreeLists(size_t blocks, size_t slack) {
   DCHECK(blocks);
 
@@ skipping 82 matching lines @@
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::Carve(Span* span, size_t blocks) {
   scoped_ptr<Span> serving = RemoveFromFreeList(span);
 
   const int extra = serving->length_ - blocks;
   if (extra) {
     scoped_ptr<Span> leftover(
         new Span(serving->shared_memory_, serving->start_ + blocks, extra));
-    DCHECK_IMPLIES(extra > 1, spans_.find(leftover->start_) == spans_.end());
+    DCHECK((extra <= 1) || (spans_.find(leftover->start_) == spans_.end()));

[danakj, 2015/06/29 19:30:58]

can you make this == 1

     RegisterSpan(leftover.get());
 
     // No need to coalesce as the previous span of |leftover| was just split
     // and the next span of |leftover| was not previously coalesced with
     // |span|.
     InsertIntoFreeList(leftover.Pass());
 
     serving->length_ = blocks;
     spans_[serving->start_ + blocks - 1] = serving.get();
   }
@@ skipping 99 matching lines @@
       pmd->CreateAllocatorDump(segment_dump_name + "/allocated_objects");
   obj_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameObjectsCount,
                       base::trace_event::MemoryAllocatorDump::kUnitsObjects,
                       static_cast<uint64_t>(allocated_objects_count));
   obj_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                       base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                       static_cast<uint64_t>(allocated_objects_size_in_bytes));
 }
 
 }  // namespace content