cc: Reduce the size of PaintOpBuffer.

cc/paint/paint_op_buffer.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/paint/paint_record.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 
@@ skipping 25 matching lines @@
   M(NoopOp)                \
   M(RestoreOp)             \
   M(RotateOp)              \
   M(SaveOp)                \
   M(SaveLayerOp)           \
   M(SaveLayerAlphaOp)      \
   M(ScaleOp)               \
   M(SetMatrixOp)           \
   M(TranslateOp)
 
+using RasterFunction = void (*)(const PaintOp* op,
+                                SkCanvas* canvas,
+                                const SkMatrix& original_ctm);
+
+NOINLINE static void RasterWithAlphaInternal(RasterFunction raster_fn,
+                                             const PaintOp* op,
+                                             SkCanvas* canvas,
+                                             uint8_t alpha) {
+  // TODO(enne): is it ok to just drop the bounds here?
+  canvas->saveLayerAlpha(nullptr, alpha);
+  SkMatrix unused_matrix;
+  raster_fn(op, canvas, unused_matrix);
+  canvas->restore();
+}
+
 // Helper template to share common code for RasterWithAlpha when paint ops
 // have or don't have PaintFlags.
 template <typename T, bool HasFlags>
 struct Rasterizer {
-  static void Raster(const T* op,
-                     SkCanvas* canvas,
-                     const SkMatrix& original_ctm) {
-    // Paint ops with kHasPaintFlags need to declare RasterWithPaintFlags
-    // otherwise, the paint op needs its own Raster function.  Without its
-    // own, this becomes an infinite loop as PaintOp::Raster calls itself.
+  static void RasterWithAlpha(const T* op, SkCanvas* canvas, uint8_t alpha) {
     static_assert(
-        !std::is_same<decltype(&PaintOp::Raster), decltype(&T::Raster)>::value,
-        "No Raster function");
-
-    op->Raster(canvas);
-  }
-  static void RasterWithAlpha(const T* op, SkCanvas* canvas, uint8_t alpha) {
+        !T::kHasPaintFlags,
+        "This function should not be used for a PaintOp that has PaintFlags");
     DCHECK(T::kIsDrawOp);
-    // TODO(enne): is it ok to just drop the bounds here?
-    canvas->saveLayerAlpha(nullptr, alpha);
-    op->Raster(canvas);
-    canvas->restore();
+    RasterWithAlphaInternal(&T::Raster, op, canvas, alpha);
   }
 };
 
+NOINLINE static void RasterWithAlphaInternalForFlags(RasterFunction raster_fn,
+                                                     const PaintOpWithFlags* op,
+                                                     SkCanvas* canvas,
+                                                     uint8_t alpha) {
+  SkMatrix unused_matrix;
+  if (alpha == 255) {
+    raster_fn(op, canvas, unused_matrix);
+  } else if (op->flags.SupportsFoldingAlpha()) {
+    PaintOpWithFlags* mutable_op = const_cast<PaintOpWithFlags*>(op);
+    uint8_t flags_alpha = op->flags.getAlpha();
+    mutable_op->flags.setAlpha(SkMulDiv255Round(flags_alpha, alpha));
+    raster_fn(op, canvas, unused_matrix);
+    mutable_op->flags.setAlpha(flags_alpha);
+  } else {
+    canvas->saveLayerAlpha(nullptr, alpha);
+    raster_fn(op, canvas, unused_matrix);
+    canvas->restore();
+  }
+}
+
 template <typename T>
 struct Rasterizer<T, true> {
-  static void Raster(const T* op,
-                     SkCanvas* canvas,
-                     const SkMatrix& original_ctm) {
-    op->RasterWithFlags(canvas, op->flags);
-  }
   static void RasterWithAlpha(const T* op, SkCanvas* canvas, uint8_t alpha) {
+    static_assert(T::kHasPaintFlags,
+                  "This function expects the PaintOp to have PaintFlags");
     DCHECK(T::kIsDrawOp);
-    SkMatrix unused_matrix;
-    if (alpha == 255) {
-      Raster(op, canvas, unused_matrix);
-    } else if (op->flags.SupportsFoldingAlpha()) {
-      PaintFlags flags = op->flags;
-      flags.setAlpha(SkMulDiv255Round(flags.getAlpha(), alpha));
-      op->RasterWithFlags(canvas, flags);
-    } else {
-      canvas->saveLayerAlpha(nullptr, alpha);
-      op->RasterWithFlags(canvas, op->flags);
-      canvas->restore();
-    }
-  }
-};
-
-template <>
-struct Rasterizer<SetMatrixOp, false> {
-  static void Raster(const SetMatrixOp* op,
-                     SkCanvas* canvas,
-                     const SkMatrix& original_ctm) {
-    op->Raster(canvas, original_ctm);
-  }
-  static void RasterWithAlpha(const SetMatrixOp* op,
-                              SkCanvas* canvas,
-                              uint8_t alpha) {
-    NOTREACHED();
+    RasterWithAlphaInternalForFlags(&T::Raster, op, canvas, alpha);
   }
 };
 
 template <>
 struct Rasterizer<DrawRecordOp, false> {
-  static void Raster(const DrawRecordOp* op,
-                     SkCanvas* canvas,
-                     const SkMatrix& original_ctm) {
-    op->Raster(canvas);
-  }
   static void RasterWithAlpha(const DrawRecordOp* op,
                               SkCanvas* canvas,
                               uint8_t alpha) {
     // This "looking into records" optimization is done here instead of
     // in the PaintOpBuffer::Raster function as DisplayItemList calls
     // into RasterWithAlpha directly.
     if (op->record->approximateOpCount() == 1) {
       PaintOp* single_op = op->record->GetFirstOp();
       // RasterWithAlpha only supported for draw ops.
       if (single_op->IsDrawOp()) {
         single_op->RasterWithAlpha(canvas, alpha);
         return;
       }
     }
 
     canvas->saveLayerAlpha(nullptr, alpha);
-    op->Raster(canvas);
+    SkMatrix unused_matrix;
+    DrawRecordOp::Raster(op, canvas, unused_matrix);
     canvas->restore();
   }
 };
 
 // TODO(enne): partially specialize RasterWithAlpha for draw color?
 
 static constexpr size_t kNumOpTypes =
     static_cast<size_t>(PaintOpType::LastPaintOpType) + 1;
 
 // Verify that every op is in the TYPES macro.
 #define M(T) +1
 static_assert(kNumOpTypes == TYPES(M), "Missing op in list");
 #undef M
 
 using RasterFunction = void (*)(const PaintOp* op,
                                 SkCanvas* canvas,
                                 const SkMatrix& original_ctm);
-#define M(T)                                                              \
-  [](const PaintOp* op, SkCanvas* canvas, const SkMatrix& original_ctm) { \
-    Rasterizer<T, T::kHasPaintFlags>::Raster(static_cast<const T*>(op),   \
-                                             canvas, original_ctm);       \
-  },
+#define M(T) &T::Raster,
 static const RasterFunction g_raster_functions[kNumOpTypes] = {TYPES(M)};
 #undef M
 
 using RasterAlphaFunction = void (*)(const PaintOp* op,
                                      SkCanvas* canvas,
                                      uint8_t alpha);
 #define M(T) \
   T::kIsDrawOp ? \
   [](const PaintOp* op, SkCanvas* canvas, uint8_t alpha) { \
     Rasterizer<T, T::kHasPaintFlags>::RasterWithAlpha( \
@@ skipping 27 matching lines @@
 #define M(T)                                               \
   static_assert(ALIGNOF(T) <= PaintOpBuffer::PaintOpAlign, \
                 #T " must have alignment no bigger than PaintOpAlign");
 TYPES(M);
 #undef M
 
 #undef TYPES
 
 SkRect PaintOp::kUnsetRect = {SK_ScalarInfinity, 0, 0, 0};
 
-void AnnotateOp::Raster(SkCanvas* canvas) const {
-  switch (annotation_type) {
+void AnnotateOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const AnnotateOp*>(base_op);
+  switch (op->annotation_type) {
     case PaintCanvas::AnnotationType::URL:
-      SkAnnotateRectWithURL(canvas, rect, data.get());
+      SkAnnotateRectWithURL(canvas, op->rect, op->data.get());
       break;
     case PaintCanvas::AnnotationType::LINK_TO_DESTINATION:
-      SkAnnotateLinkToDestination(canvas, rect, data.get());
+      SkAnnotateLinkToDestination(canvas, op->rect, op->data.get());
       break;
     case PaintCanvas::AnnotationType::NAMED_DESTINATION: {
-      SkPoint point = SkPoint::Make(rect.x(), rect.y());
-      SkAnnotateNamedDestination(canvas, point, data.get());
+      SkPoint point = SkPoint::Make(op->rect.x(), op->rect.y());
+      SkAnnotateNamedDestination(canvas, point, op->data.get());
       break;
     }
   }
 }
 
-void ClipPathOp::Raster(SkCanvas* canvas) const {
-  canvas->clipPath(path, op, antialias);
-}
-
-void ClipRectOp::Raster(SkCanvas* canvas) const {
-  canvas->clipRect(rect, op, antialias);
-}
-
-void ClipRRectOp::Raster(SkCanvas* canvas) const {
-  canvas->clipRRect(rrect, op, antialias);
-}
-
-void ConcatOp::Raster(SkCanvas* canvas) const {
-  canvas->concat(matrix);
-}
-
-void DrawArcOp::RasterWithFlags(SkCanvas* canvas,
-                                const PaintFlags& flags) const {
-  canvas->drawArc(oval, start_angle, sweep_angle, use_center, ToSkPaint(flags));
-}
-
-void DrawCircleOp::RasterWithFlags(SkCanvas* canvas,
-                                   const PaintFlags& flags) const {
-  canvas->drawCircle(cx, cy, radius, ToSkPaint(flags));
-}
-
-void DrawColorOp::Raster(SkCanvas* canvas) const {
-  canvas->drawColor(color, mode);
-}
-
-void DrawDisplayItemListOp::Raster(SkCanvas* canvas) const {
-  list->Raster(canvas, nullptr);
-}
-
-void DrawDRRectOp::RasterWithFlags(SkCanvas* canvas,
-                                   const PaintFlags& flags) const {
-  canvas->drawDRRect(outer, inner, ToSkPaint(flags));
-}
-
-void DrawImageOp::RasterWithFlags(SkCanvas* canvas,
-                                  const PaintFlags& flags) const {
-  canvas->drawImage(image.sk_image().get(), left, top, ToSkPaint(&flags));
-}
-
-void DrawImageRectOp::RasterWithFlags(SkCanvas* canvas,
-                                      const PaintFlags& flags) const {
+void ClipPathOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const ClipPathOp*>(base_op);
+  canvas->clipPath(op->path, op->op, op->antialias);
+}
+
+void ClipRectOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const ClipRectOp*>(base_op);
+  canvas->clipRect(op->rect, op->op, op->antialias);
+}
+
+void ClipRRectOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const ClipRRectOp*>(base_op);
+  canvas->clipRRect(op->rrect, op->op, op->antialias);
+}
+
+void ConcatOp::Raster(const PaintOp* base_op,
+                      SkCanvas* canvas,
+                      const SkMatrix& original_ctm) {
+  auto* op = static_cast<const ConcatOp*>(base_op);
+  canvas->concat(op->matrix);
+}
+
+void DrawArcOp::Raster(const PaintOp* base_op,
+                       SkCanvas* canvas,
+                       const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawArcOp*>(base_op);
+  canvas->drawArc(op->oval, op->start_angle, op->sweep_angle, op->use_center,
+                  ToSkPaint(op->flags));
+}
+
+void DrawCircleOp::Raster(const PaintOp* base_op,
+                          SkCanvas* canvas,
+                          const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawCircleOp*>(base_op);
+  canvas->drawCircle(op->cx, op->cy, op->radius, ToSkPaint(op->flags));
+}
+
+void DrawColorOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawColorOp*>(base_op);
+  canvas->drawColor(op->color, op->mode);
+}
+
+void DrawDisplayItemListOp::Raster(const PaintOp* base_op,
+                                   SkCanvas* canvas,
+                                   const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawDisplayItemListOp*>(base_op);
+  op->list->Raster(canvas, nullptr);
+}
+
+void DrawDRRectOp::Raster(const PaintOp* base_op,
+                          SkCanvas* canvas,
+                          const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawDRRectOp*>(base_op);
+  canvas->drawDRRect(op->outer, op->inner, ToSkPaint(op->flags));
+}
+
+void DrawImageOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawImageOp*>(base_op);
+  canvas->drawImage(op->image.sk_image().get(), op->left, op->top,
+                    ToSkPaint(&op->flags));
+}
+
+void DrawImageRectOp::Raster(const PaintOp* base_op,
+                             SkCanvas* canvas,
+                             const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawImageRectOp*>(base_op);
   // TODO(enne): Probably PaintCanvas should just use the skia enum directly.
   SkCanvas::SrcRectConstraint skconstraint =
-      static_cast<SkCanvas::SrcRectConstraint>(constraint);
-  canvas->drawImageRect(image.sk_image().get(), src, dst, ToSkPaint(&flags),
-                        skconstraint);
-}
-
-void DrawIRectOp::RasterWithFlags(SkCanvas* canvas,
-                                  const PaintFlags& flags) const {
-  canvas->drawIRect(rect, ToSkPaint(flags));
-}
-
-void DrawLineOp::RasterWithFlags(SkCanvas* canvas,
-                                 const PaintFlags& flags) const {
-  canvas->drawLine(x0, y0, x1, y1, ToSkPaint(flags));
-}
-
-void DrawOvalOp::RasterWithFlags(SkCanvas* canvas,
-                                 const PaintFlags& flags) const {
-  canvas->drawOval(oval, ToSkPaint(flags));
-}
-
-void DrawPathOp::RasterWithFlags(SkCanvas* canvas,
-                                 const PaintFlags& flags) const {
-  canvas->drawPath(path, ToSkPaint(flags));
-}
-
-void DrawPosTextOp::RasterWithFlags(SkCanvas* canvas,
-                                    const PaintFlags& flags) const {
-  canvas->drawPosText(GetData(), bytes, GetArray(), ToSkPaint(flags));
-}
-
-void DrawRecordOp::Raster(SkCanvas* canvas) const {
-  record->playback(canvas);
-}
-
-void DrawRectOp::RasterWithFlags(SkCanvas* canvas,
-                                 const PaintFlags& flags) const {
-  canvas->drawRect(rect, ToSkPaint(flags));
-}
-
-void DrawRRectOp::RasterWithFlags(SkCanvas* canvas,
-                                  const PaintFlags& flags) const {
-  canvas->drawRRect(rrect, ToSkPaint(flags));
-}
-
-void DrawTextOp::RasterWithFlags(SkCanvas* canvas,
-                                 const PaintFlags& flags) const {
-  canvas->drawText(GetData(), bytes, x, y, ToSkPaint(flags));
-}
-
-void DrawTextBlobOp::RasterWithFlags(SkCanvas* canvas,
-                                     const PaintFlags& flags) const {
-  canvas->drawTextBlob(blob.get(), x, y, ToSkPaint(flags));
-}
-
-void RestoreOp::Raster(SkCanvas* canvas) const {
+      static_cast<SkCanvas::SrcRectConstraint>(op->constraint);
+  canvas->drawImageRect(op->image.sk_image().get(), op->src, op->dst,
+                        ToSkPaint(&op->flags), skconstraint);
+}
+
+void DrawIRectOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawIRectOp*>(base_op);
+  canvas->drawIRect(op->rect, ToSkPaint(op->flags));
+}
+
+void DrawLineOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawLineOp*>(base_op);
+  canvas->drawLine(op->x0, op->y0, op->x1, op->y1, ToSkPaint(op->flags));
+}
+
+void DrawOvalOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawOvalOp*>(base_op);
+  canvas->drawOval(op->oval, ToSkPaint(op->flags));
+}
+
+void DrawPathOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawPathOp*>(base_op);
+  canvas->drawPath(op->path, ToSkPaint(op->flags));
+}
+
+void DrawPosTextOp::Raster(const PaintOp* base_op,
+                           SkCanvas* canvas,
+                           const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawPosTextOp*>(base_op);
+  canvas->drawPosText(op->GetData(), op->bytes, op->GetArray(),
+                      ToSkPaint(op->flags));
+}
+
+void DrawRecordOp::Raster(const PaintOp* base_op,
+                          SkCanvas* canvas,
+                          const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawRecordOp*>(base_op);
+  op->record->playback(canvas);
+}
+
+void DrawRectOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawRectOp*>(base_op);
+  canvas->drawRect(op->rect, ToSkPaint(op->flags));
+}
+
+void DrawRRectOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawRRectOp*>(base_op);
+  canvas->drawRRect(op->rrect, ToSkPaint(op->flags));
+}
+
+void DrawTextOp::Raster(const PaintOp* base_op,
+                        SkCanvas* canvas,
+                        const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawTextOp*>(base_op);
+  canvas->drawText(op->GetData(), op->bytes, op->x, op->y,
+                   ToSkPaint(op->flags));
+}
+
+void DrawTextBlobOp::Raster(const PaintOp* base_op,
+                            SkCanvas* canvas,
+                            const SkMatrix& original_ctm) {
+  auto* op = static_cast<const DrawTextBlobOp*>(base_op);
+  canvas->drawTextBlob(op->blob.get(), op->x, op->y, ToSkPaint(op->flags));
+}
+
+void RestoreOp::Raster(const PaintOp* base_op,
+                       SkCanvas* canvas,
+                       const SkMatrix& original_ctm) {
   canvas->restore();
 }
 
-void RotateOp::Raster(SkCanvas* canvas) const {
-  canvas->rotate(degrees);
-}
-
-void SaveOp::Raster(SkCanvas* canvas) const {
+void RotateOp::Raster(const PaintOp* base_op,
+                      SkCanvas* canvas,
+                      const SkMatrix& original_ctm) {
+  auto* op = static_cast<const RotateOp*>(base_op);
+  canvas->rotate(op->degrees);
+}
+
+void SaveOp::Raster(const PaintOp* base_op,
+                    SkCanvas* canvas,
+                    const SkMatrix& original_ctm) {
   canvas->save();
 }
 
-void SaveLayerOp::RasterWithFlags(SkCanvas* canvas,
-                                  const PaintFlags& flags) const {
+void SaveLayerOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const SaveLayerOp*>(base_op);
   // See PaintOp::kUnsetRect
-  bool unset = bounds.left() == SK_ScalarInfinity;
-
-  canvas->saveLayer(unset ? nullptr : &bounds, ToSkPaint(&flags));
-}
-
-void SaveLayerAlphaOp::Raster(SkCanvas* canvas) const {
+  bool unset = op->bounds.left() == SK_ScalarInfinity;
+
+  canvas->saveLayer(unset ? nullptr : &op->bounds, ToSkPaint(&op->flags));
+}
+
+void SaveLayerAlphaOp::Raster(const PaintOp* base_op,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm) {
+  auto* op = static_cast<const SaveLayerAlphaOp*>(base_op);
   // See PaintOp::kUnsetRect
-  bool unset = bounds.left() == SK_ScalarInfinity;
-  canvas->saveLayerAlpha(unset ? nullptr : &bounds, alpha);
-}
-
-void ScaleOp::Raster(SkCanvas* canvas) const {
-  canvas->scale(sx, sy);
-}
-
-void SetMatrixOp::Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const {
-  canvas->setMatrix(SkMatrix::Concat(original_ctm, matrix));
-}
-
-void TranslateOp::Raster(SkCanvas* canvas) const {
-  canvas->translate(dx, dy);
+  bool unset = op->bounds.left() == SK_ScalarInfinity;
+  canvas->saveLayerAlpha(unset ? nullptr : &op->bounds, op->alpha);
+}
+
+void ScaleOp::Raster(const PaintOp* base_op,
+                     SkCanvas* canvas,
+                     const SkMatrix& original_ctm) {
+  auto* op = static_cast<const ScaleOp*>(base_op);
+  canvas->scale(op->sx, op->sy);
+}
+
+void SetMatrixOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const SetMatrixOp*>(base_op);
+  canvas->setMatrix(SkMatrix::Concat(original_ctm, op->matrix));
+}
+
+void TranslateOp::Raster(const PaintOp* base_op,
+                         SkCanvas* canvas,
+                         const SkMatrix& original_ctm) {
+  auto* op = static_cast<const TranslateOp*>(base_op);
+  canvas->translate(op->dx, op->dy);
 }
 
 bool PaintOp::IsDrawOp() const {
   return g_is_draw_op[type];
 }
 
 void PaintOp::Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const {
   g_raster_functions[type](this, canvas, original_ctm);
 }
 
@@ skipping 60 matching lines @@
 
 DrawDisplayItemListOp& DrawDisplayItemListOp::operator=(
     const DrawDisplayItemListOp& op) = default;
 
 DrawDisplayItemListOp::~DrawDisplayItemListOp() = default;
 
 DrawImageOp::DrawImageOp(const PaintImage& image,
                          SkScalar left,
                          SkScalar top,
                          const PaintFlags* flags)
-    : image(image),
+    : PaintOpWithFlags(flags ? *flags : PaintFlags()),
+      image(image),
       left(left),
-      top(top),
-      flags(flags ? *flags : PaintFlags()) {}
+      top(top) {}
 
 DrawImageOp::~DrawImageOp() = default;
 
 DrawImageRectOp::DrawImageRectOp(const PaintImage& image,
                                  const SkRect& src,
                                  const SkRect& dst,
                                  const PaintFlags* flags,
                                  PaintCanvas::SrcRectConstraint constraint)
-    : image(image),
-      flags(flags ? *flags : PaintFlags()),
+    : PaintOpWithFlags(flags ? *flags : PaintFlags()),
+      image(image),
       src(src),
       dst(dst),
       constraint(constraint) {}
 
 DrawImageRectOp::~DrawImageRectOp() = default;
 
 DrawPosTextOp::DrawPosTextOp(size_t bytes,
                              size_t count,
                              const PaintFlags& flags)
-    : PaintOpWithArray(bytes, count), flags(flags) {}
+    : PaintOpWithArray(flags, bytes, count) {}
 
 DrawPosTextOp::~DrawPosTextOp() = default;
 
 DrawRecordOp::DrawRecordOp(sk_sp<const PaintRecord> record)
     : record(std::move(record)) {}
 
 DrawRecordOp::~DrawRecordOp() = default;
 
 size_t DrawRecordOp::AdditionalBytesUsed() const {
   return record->approximateBytesUsed();
 }
 
 DrawTextBlobOp::DrawTextBlobOp(sk_sp<SkTextBlob> blob,
                                SkScalar x,
                                SkScalar y,
                                const PaintFlags& flags)
-    : blob(std::move(blob)), x(x), y(y), flags(flags) {}
+    : PaintOpWithFlags(flags), blob(std::move(blob)), x(x), y(y) {}
 
 DrawTextBlobOp::~DrawTextBlobOp() = default;
 
 PaintOpBuffer::PaintOpBuffer() : cull_rect_(SkRect::MakeEmpty()) {}
 
 PaintOpBuffer::PaintOpBuffer(const SkRect& cull_rect) : cull_rect_(cull_rect) {}
 
 PaintOpBuffer::~PaintOpBuffer() {
   Reset();
 }
@@ skipping 76 matching lines @@
 
 void PaintOpBuffer::ReallocBuffer(size_t new_size) {
   DCHECK_GE(new_size, used_);
   std::unique_ptr<char, base::AlignedFreeDeleter> new_data(
       static_cast<char*>(base::AlignedAlloc(new_size, PaintOpAlign)));
   memcpy(new_data.get(), data_.get(), used_);
   data_ = std::move(new_data);
   reserved_ = new_size;
 }
 
+std::pair<void*, size_t> PaintOpBuffer::AllocatePaintOp(size_t sizeof_op,
+                                                        size_t bytes) {
+  if (!op_count_) {
+    if (bytes) {
+      // Internal first_op buffer doesn't have room for extra data.
+      // If the op wants extra bytes, then we'll just store a Noop
+      // in the first_op and proceed from there.  This seems unlikely
+      // to be a common case.
+      push<NoopOp>();
+    } else {
+      op_count_++;
+      return std::make_pair(first_op_.void_data(), 0);
+    }
+  }
+
+  // We've filled |first_op_| by now so we need to allocate space in |data_|.
+  DCHECK(op_count_);
+
+  // Compute a skip such that all ops in the buffer are aligned to the
+  // maximum required alignment of all ops.
+  size_t skip = MathUtil::UncheckedRoundUp(sizeof_op + bytes, PaintOpAlign);
+  DCHECK_LT(skip, static_cast<size_t>(1) << 24);
+  if (used_ + skip > reserved_) {
+    // Start reserved_ at kInitialBufferSize and then double.
+    // ShrinkToFit can make this smaller afterwards.
+    size_t new_size = reserved_ ? reserved_ : kInitialBufferSize;
+    while (used_ + skip > new_size)
+      new_size *= 2;
+    ReallocBuffer(new_size);
+  }
+  DCHECK_LE(used_ + skip, reserved_);
+
+  void* op = data_.get() + used_;
+  used_ += skip;
+  op_count_++;
+  return std::make_pair(op, skip);
+}
+
 void PaintOpBuffer::ShrinkToFit() {
   if (!used_ || used_ == reserved_)
     return;
   ReallocBuffer(used_);
 }
 
 }  // namespace cc