cc: Renamed approximate{BytesUsed,OpCount} in paint op buffer.

cc/paint/paint_op_buffer_unittest.cc

 // Copyright 2017 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/paint/paint_op_buffer.h"
 #include "cc/paint/display_item_list.h"
 #include "cc/test/skia_common.h"
 #include "cc/test/test_skcanvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
 
 namespace {
 
 template <typename T>
 void CheckRefCnt(const T& obj, int32_t count) {
 // Skia doesn't define getRefCnt in all builds.
 #ifdef SK_DEBUG
   EXPECT_EQ(obj->getRefCnt(), count);
 #endif
 }
 
 }  // namespace
 
 namespace cc {
 
 TEST(PaintOpBufferTest, Empty) {
   PaintOpBuffer buffer;
-  EXPECT_EQ(buffer.approximateOpCount(), 0);
-  EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer));
+  EXPECT_EQ(buffer.size(), 0u);
+  EXPECT_EQ(buffer.bytes_used(), sizeof(PaintOpBuffer));
   EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false);
 
   buffer.Reset();
-  EXPECT_EQ(buffer.approximateOpCount(), 0);
-  EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer));
+  EXPECT_EQ(buffer.size(), 0u);
+  EXPECT_EQ(buffer.bytes_used(), sizeof(PaintOpBuffer));
   EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false);
 }
 
 TEST(PaintOpBufferTest, SimpleAppend) {
   SkRect rect = SkRect::MakeXYWH(2, 3, 4, 5);
   PaintFlags flags;
   flags.setColor(SK_ColorMAGENTA);
   flags.setAlpha(100);
   SkColor draw_color = SK_ColorRED;
   SkBlendMode blend = SkBlendMode::kSrc;
 
   PaintOpBuffer buffer;
   buffer.push<SaveLayerOp>(&rect, &flags);
   buffer.push<SaveOp>();
   buffer.push<DrawColorOp>(draw_color, blend);
   buffer.push<RestoreOp>();
 
-  EXPECT_EQ(buffer.approximateOpCount(), 4);
+  EXPECT_EQ(buffer.size(), 4u);
 
   PaintOpBuffer::Iterator iter(&buffer);
   ASSERT_EQ(iter->GetType(), PaintOpType::SaveLayer);
   SaveLayerOp* save_op = static_cast<SaveLayerOp*>(*iter);
   EXPECT_EQ(save_op->bounds, rect);
   EXPECT_TRUE(save_op->flags == flags);
   ++iter;
 
   ASSERT_EQ(iter->GetType(), PaintOpType::Save);
   ++iter;
@@ skipping 24 matching lines @@
       SkColorFilter::MakeModeFilter(SK_ColorMAGENTA, SkBlendMode::kSrcOver);
   flags.setColorFilter(filter);
   CheckRefCnt(filter, 2);
 
   buffer.push_with_data<DrawTextOp>(text, arraysize(text), 0.f, 0.f, flags);
   CheckRefCnt(filter, 3);
 
   // Verify that when the first op has data, which may not fit in the
   // PaintRecord internal buffer, that it adds a noop as the first op
   // and then appends the "op with data" into the heap buffer.
-  ASSERT_EQ(buffer.approximateOpCount(), 2);
+  ASSERT_EQ(buffer.size(), 2u);
   EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::Noop);
 
   // Verify iteration behavior and brief smoke test of op state.
   {
     PaintOpBuffer::Iterator iter(&buffer);
     PaintOp* noop = *iter;
     EXPECT_EQ(buffer.GetFirstOp(), noop);
     ++iter;
 
     PaintOp* op = *iter;
     ASSERT_EQ(op->GetType(), PaintOpType::DrawText);
     DrawTextOp* draw_text_op = static_cast<DrawTextOp*>(op);
     EXPECT_EQ(draw_text_op->bytes, arraysize(text));
 
     const void* data = draw_text_op->GetData();
     EXPECT_EQ(memcmp(data, text, arraysize(text)), 0);
 
     ++iter;
     EXPECT_FALSE(iter);
   }
 
   // Reset, verify state, and append an op that will fit in the first slot.
   buffer.Reset();
   CheckRefCnt(filter, 2);
 
-  ASSERT_EQ(buffer.approximateOpCount(), 0);
+  ASSERT_EQ(buffer.size(), 0u);
   EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false);
 
   SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4);
   buffer.push<DrawRectOp>(rect, flags);
   CheckRefCnt(filter, 3);
 
-  ASSERT_EQ(buffer.approximateOpCount(), 1);
+  ASSERT_EQ(buffer.size(), 1u);
   EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::DrawRect);
 
   PaintOpBuffer::Iterator iter(&buffer);
   ASSERT_EQ(iter->GetType(), PaintOpType::DrawRect);
   DrawRectOp* draw_rect_op = static_cast<DrawRectOp*>(*iter);
   EXPECT_EQ(draw_rect_op->rect, rect);
 
   ++iter;
   EXPECT_FALSE(iter);
 
   buffer.Reset();
-  ASSERT_EQ(buffer.approximateOpCount(), 0);
+  ASSERT_EQ(buffer.size(), 0u);
   CheckRefCnt(filter, 2);
 }
 
 TEST(PaintOpBufferTest, Peek) {
   PaintOpBuffer buffer;
 
   uint8_t alpha = 100;
   buffer.push<SaveLayerAlphaOp>(nullptr, alpha);
   PaintFlags draw_flags;
   buffer.push<DrawRectOp>(SkRect::MakeXYWH(1, 2, 3, 4), draw_flags);
@@ skipping 21 matching lines @@
   PaintOpBuffer buffer;
 
   buffer.push<SaveOp>();
   PaintFlags flags;
   char text1[] = "asdfasdf";
   buffer.push_with_data<DrawTextOp>(text1, arraysize(text1), 0.f, 0.f, flags);
 
   char text2[] = "qwerty";
   buffer.push_with_data<DrawTextOp>(text2, arraysize(text2), 0.f, 0.f, flags);
 
-  ASSERT_EQ(buffer.approximateOpCount(), 3);
+  ASSERT_EQ(buffer.size(), 3u);
 
   // Verify iteration behavior and brief smoke test of op state.
   PaintOpBuffer::Iterator iter(&buffer);
   PaintOp* save_op = *iter;
   EXPECT_EQ(save_op->GetType(), PaintOpType::Save);
   ++iter;
 
   PaintOp* op1 = *iter;
   ASSERT_EQ(op1->GetType(), PaintOpType::DrawText);
   DrawTextOp* draw_text_op1 = static_cast<DrawTextOp*>(op1);
@@ skipping 174 matching lines @@
 // is a DrawRecord that itself has a single draw op.
 TEST(PaintOpBufferTest, SaveDrawRestore_SingleOpRecordWithSingleOp) {
   sk_sp<PaintRecord> record = sk_make_sp<PaintRecord>();
 
   PaintFlags draw_flags;
   draw_flags.setColor(SK_ColorMAGENTA);
   draw_flags.setAlpha(50);
   EXPECT_TRUE(draw_flags.SupportsFoldingAlpha());
   SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4);
   record->push<DrawRectOp>(rect, draw_flags);
-  EXPECT_EQ(record->approximateOpCount(), 1);
+  EXPECT_EQ(record->size(), 1u);
 
   PaintOpBuffer buffer;
 
   uint8_t alpha = 100;
   buffer.push<SaveLayerAlphaOp>(nullptr, alpha);
   buffer.push<DrawRecordOp>(std::move(record));
   buffer.push<RestoreOp>();
 
   SaveCountingCanvas canvas;
   buffer.playback(&canvas);
 
   EXPECT_EQ(0, canvas.save_count_);
   EXPECT_EQ(0, canvas.restore_count_);
   EXPECT_EQ(rect, canvas.draw_rect_);
 
   float expected_alpha = alpha * 50 / 255.f;
   EXPECT_LE(std::abs(expected_alpha - canvas.paint_.getAlpha()), 1.f);
 }
 
 // The same as the above SingleOpRecord test, but the single op is not
 // a draw op.  So, there's no way to fold in the save layer optimization.
 // Verify that the optimization doesn't apply and that this doesn't crash.
 // See: http://crbug.com/712093.
 TEST(PaintOpBufferTest, SaveDrawRestore_SingleOpRecordWithSingleNonDrawOp) {
   sk_sp<PaintRecord> record = sk_make_sp<PaintRecord>();
   record->push<NoopOp>();
-  EXPECT_EQ(record->approximateOpCount(), 1);
+  EXPECT_EQ(record->size(), 1u);
   EXPECT_FALSE(record->GetFirstOp()->IsDrawOp());
 
   PaintOpBuffer buffer;
 
   uint8_t alpha = 100;
   buffer.push<SaveLayerAlphaOp>(nullptr, alpha);
   buffer.push<DrawRecordOp>(std::move(record));
   buffer.push<RestoreOp>();
 
   SaveCountingCanvas canvas;
@@ skipping 103 matching lines @@
 
   // Drawing a record with slow paths into another adds the same
   // number of slow paths as the record.
   auto buffer2 = sk_make_sp<PaintOpBuffer>();
   EXPECT_EQ(buffer2->numSlowPaths(), 0);
   buffer2->push<DrawRecordOp>(buffer);
   EXPECT_EQ(buffer->numSlowPaths(), buffer2->numSlowPaths());
 }
 
 }  // namespace cc