cc: Clean up naming of paint-related identifiers

cc/playback/raster_source_unittest.cc

 // Copyright 2013 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/playback/raster_source.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
 #include "cc/tiles/software_image_decode_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
 TEST(RasterSourceTest, AnalyzeIsSolidUnscaled) {
   gfx::Size layer_bounds(400, 400);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
-  SkPaint solid_paint;
+  PaintFlags solid_flags;
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
-  solid_paint.setColor(solid_color);
+  solid_flags.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
   SkColor color = SK_ColorTRANSPARENT;
-  SkPaint non_solid_paint;
+  PaintFlags non_solid_flags;
   bool is_solid_color = false;
-  non_solid_paint.setColor(non_solid_color);
+  non_solid_flags.setColor(non_solid_color);
 
-  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                             solid_paint);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                             solid_flags);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   // Ensure everything is solid.
   for (int y = 0; y <= 300; y += 100) {
     for (int x = 0; x <= 300; x += 100) {
       gfx::Rect rect(x, y, 100, 100);
       is_solid_color = raster->PerformSolidColorAnalysis(rect, 1.f, &color);
       EXPECT_TRUE(is_solid_color) << rect.ToString();
       EXPECT_EQ(solid_color, color) << rect.ToString();
     }
   }
 
   // Add one non-solid pixel and recreate the raster source.
-  recording_source->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1),
-                                             non_solid_paint);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(50, 50, 1, 1),
+                                             non_solid_flags);
   recording_source->Rerecord();
   raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   color = SK_ColorTRANSPARENT;
   is_solid_color =
       raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), 1.f, &color);
   EXPECT_FALSE(is_solid_color);
 
   color = SK_ColorTRANSPARENT;
@@ skipping 23 matching lines @@
 }
 
 TEST(RasterSourceTest, AnalyzeIsSolidScaled) {
   gfx::Size layer_bounds(400, 400);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
   SkColor color = SK_ColorTRANSPARENT;
-  SkPaint solid_paint;
+  PaintFlags solid_flags;
   bool is_solid_color = false;
-  solid_paint.setColor(solid_color);
+  solid_flags.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
-  SkPaint non_solid_paint;
-  non_solid_paint.setColor(non_solid_color);
+  PaintFlags non_solid_flags;
+  non_solid_flags.setColor(non_solid_color);
 
-  recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 400, 400),
-                                             solid_paint);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(0, 0, 400, 400),
+                                             solid_flags);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   // Ensure everything is solid.
   for (int y = 0; y <= 30; y += 10) {
     for (int x = 0; x <= 30; x += 10) {
       gfx::Rect rect(x, y, 10, 10);
       is_solid_color = raster->PerformSolidColorAnalysis(rect, 0.1f, &color);
       EXPECT_TRUE(is_solid_color) << rect.ToString();
       EXPECT_EQ(color, solid_color) << rect.ToString();
     }
   }
 
   // Add one non-solid pixel and recreate the raster source.
-  recording_source->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1),
-                                             non_solid_paint);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(50, 50, 1, 1),
+                                             non_solid_flags);
   recording_source->Rerecord();
   raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   color = SK_ColorTRANSPARENT;
   is_solid_color =
       raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 10, 10), 0.1f, &color);
   EXPECT_FALSE(is_solid_color);
 
   color = SK_ColorTRANSPARENT;
@@ skipping 105 matching lines @@
   float contents_scale = 1.5f;
   float raster_divisions = 2.f;
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorBLACK);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // Because the caller sets content opaque, it also promises that it
   // has at least filled in layer_bounds opaquely.
-  SkPaint white_paint;
-  white_paint.setColor(SK_ColorWHITE);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                             white_paint);
+  PaintFlags white_flags;
+  white_flags.setColor(SK_ColorWHITE);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                             white_flags);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   gfx::Size content_bounds(
       gfx::ScaleToCeiledSize(layer_bounds, contents_scale));
 
   // Simulate drawing into different tiles at different offsets.
   int step_x = std::ceil(content_bounds.width() / raster_divisions);
@@ skipping 41 matching lines @@
 TEST(RasterSourceTest, RasterPartialContents) {
   gfx::Size layer_bounds(3, 5);
   float contents_scale = 1.5f;
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorGREEN);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // First record everything as white.
-  SkPaint white_paint;
-  white_paint.setColor(SK_ColorWHITE);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                             white_paint);
+  PaintFlags white_flags;
+  white_flags.setColor(SK_ColorWHITE);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                             white_flags);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   gfx::Size content_bounds(
       gfx::ScaleToCeiledSize(layer_bounds, contents_scale));
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(content_bounds.width(), content_bounds.height());
@@ skipping 14 matching lines @@
         SCOPED_TRACE(j);
         EXPECT_EQ(255u, SkColorGetA(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(255u, SkColorGetR(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(255u, SkColorGetG(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(255u, SkColorGetB(pixels[i + j * bitmap.width()]));
       }
     }
   }
 
   // Re-record everything as black.
-  SkPaint black_paint;
-  black_paint.setColor(SK_ColorBLACK);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                             black_paint);
+  PaintFlags black_flags;
+  black_flags.setColor(SK_ColorBLACK);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                             black_flags);
   recording_source->Rerecord();
 
   // Make a new RasterSource from the new recording.
   raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   // We're going to playback from "everything is black" into a smaller area,
   // that touches the edge pixels of the recording.
   playback_rect.Inset(1, 2, 0, 1);
   raster->PlaybackToCanvas(&canvas, raster_full_rect, playback_rect,
@@ skipping 32 matching lines @@
   float contents_scale = 1.5f;
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorGREEN);
   recording_source->SetRequiresClear(true);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // First record everything as white.
   const unsigned alpha_dark = 10u;
-  SkPaint white_paint;
-  white_paint.setColor(SK_ColorWHITE);
-  white_paint.setAlpha(alpha_dark);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                             white_paint);
+  PaintFlags white_flags;
+  white_flags.setColor(SK_ColorWHITE);
+  white_flags.setAlpha(alpha_dark);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                             white_flags);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   gfx::Size content_bounds(
       gfx::ScaleToCeiledSize(layer_bounds, contents_scale));
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(content_bounds.width(), content_bounds.height());
@@ skipping 21 matching lines @@
   }
 
   std::unique_ptr<FakeRecordingSource> recording_source_light =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source_light->SetBackgroundColor(SK_ColorGREEN);
   recording_source_light->SetRequiresClear(true);
   recording_source_light->SetClearCanvasWithDebugColor(false);
 
   // Record everything as a slightly lighter white.
   const unsigned alpha_light = 18u;
-  white_paint.setAlpha(alpha_light);
-  recording_source_light->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
-                                                   white_paint);
+  white_flags.setAlpha(alpha_light);
+  recording_source_light->add_draw_rect_with_flags(gfx::Rect(layer_bounds),
+                                                   white_flags);
   recording_source_light->Rerecord();
 
   // Make a new RasterSource from the new recording.
   raster = RasterSource::CreateFromRecordingSource(recording_source_light.get(),
                                                    false);
 
   // We're going to playback from alpha(18) white rectangle into a smaller area
   // of the recording resulting in a smaller lighter white rectangle over a
   // darker white background rectangle.
   playback_rect =
@@ skipping 51 matching lines @@
 TEST(RasterSourceTest, GetPictureMemoryUsageIncludesClientReportedMemory) {
   const size_t kReportedMemoryUsageInBytes = 100 * 1024 * 1024;
   gfx::Size layer_bounds(5, 3);
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->set_reported_memory_usage(kReportedMemoryUsageInBytes);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
-  size_t total_memory_usage = raster->GetPictureMemoryUsage();
+  size_t total_memory_usage = raster->GetMemoryUsage();
   EXPECT_GE(total_memory_usage, kReportedMemoryUsageInBytes);
   EXPECT_LT(total_memory_usage, 2 * kReportedMemoryUsageInBytes);
 }
 
 TEST(RasterSourceTest, ImageHijackCanvasRespectsSharedCanvasTransform) {
   gfx::Size size(100, 100);
 
   // Create a recording source that is filled with red and every corner is
   // green (4x4 rects in the corner are green to account for blending when
   // scaling). Note that we paint an image first, so that we can force image
   // hijack canvas to be used.
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(size);
 
   // 1. Paint the image.
   recording_source->add_draw_image(CreateDiscardableImage(gfx::Size(5, 5)),
                                    gfx::Point(0, 0));
 
   // 2. Cover everything in red.
-  SkPaint paint;
-  paint.setColor(SK_ColorRED);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(size), paint);
+  PaintFlags flags;
+  flags.setColor(SK_ColorRED);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(size), flags);
 
   // 3. Draw 4x4 green rects into every corner.
-  paint.setColor(SK_ColorGREEN);
-  recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 4, 4), paint);
-  recording_source->add_draw_rect_with_paint(
-      gfx::Rect(size.width() - 4, 0, 4, 4), paint);
-  recording_source->add_draw_rect_with_paint(
-      gfx::Rect(0, size.height() - 4, 4, 4), paint);
-  recording_source->add_draw_rect_with_paint(
-      gfx::Rect(size.width() - 4, size.height() - 4, 4, 4), paint);
+  flags.setColor(SK_ColorGREEN);
+  recording_source->add_draw_rect_with_flags(gfx::Rect(0, 0, 4, 4), flags);
+  recording_source->add_draw_rect_with_flags(
+      gfx::Rect(size.width() - 4, 0, 4, 4), flags);
+  recording_source->add_draw_rect_with_flags(
+      gfx::Rect(0, size.height() - 4, 4, 4), flags);
+  recording_source->add_draw_rect_with_flags(
+      gfx::Rect(size.width() - 4, size.height() - 4, 4, 4), flags);
 
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   bool can_use_lcd = true;
   scoped_refptr<RasterSource> raster_source =
       recording_source->CreateRasterSource(can_use_lcd);
   SoftwareImageDecodeCache controller(
       ResourceFormat::RGBA_8888,
       LayerTreeSettings().software_decoded_image_budget_bytes);
@@ skipping 15 matching lines @@
   EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(0, 24));
   EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(49, 24));
   for (int x = 0; x < 49; ++x)
     EXPECT_EQ(SK_ColorRED, bitmap.getColor(x, 12));
   for (int y = 0; y < 24; ++y)
     EXPECT_EQ(SK_ColorRED, bitmap.getColor(24, y));
 }
 
 }  // namespace
 }  // namespace cc