Replace SkTLazy with base::Optional

skia/ext/benchmarking_canvas.cc

 // Copyright (c) 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 "skia/ext/benchmarking_canvas.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkString.h"
-#include "third_party/skia/include/core/SkTLazy.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
 namespace {
 
 class FlagsBuilder {
 public:
   FlagsBuilder(char separator)
       : separator_(separator) {}
 
@@ skipping 414 matching lines @@
   void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
 #endif
 };
 
 } // namespace
 
 namespace skia {
 
 class BenchmarkingCanvas::AutoOp {
 public:
+  // AutoOp objects are always scoped within draw call frames,
+  // so the paint is guaranteed to be valid for their lifetime.
   AutoOp(BenchmarkingCanvas* canvas, const char op_name[],
          const SkPaint* paint = nullptr)
       : canvas_(canvas)
       , op_record_(new base::DictionaryValue())
-      , op_params_(new base::ListValue())
-      // AutoOp objects are always scoped within draw call frames,
-      // so the paint is guaranteed to be valid for their lifetime.
-      , paint_(paint) {
+      , op_params_(new base::ListValue()) {
 
     DCHECK(canvas);
     DCHECK(op_name);
 
     op_record_->SetString("cmd_string", op_name);
     op_record_->Set("info", op_params_);
 
-    if (paint)
+    if (paint) {
       this->addParam("paint", AsValue(*paint));
+      filtered_paint_ = *paint;
+    }
 
     if (canvas->flags_ & kOverdrawVisualization_Flag) {
       DCHECK(canvas->overdraw_xfermode_);
 
-      paint_ = paint ? filtered_paint_.set(*paint) : filtered_paint_.init();
-      filtered_paint_.get()->setXfermode(canvas->overdraw_xfermode_);
-      filtered_paint_.get()->setAntiAlias(false);
+      filtered_paint_.setXfermode(canvas->overdraw_xfermode_);
+      filtered_paint_.setAntiAlias(false);
     }
 
     start_ticks_ = base::TimeTicks::Now();
   }
 
   ~AutoOp() {
     base::TimeDelta ticks = base::TimeTicks::Now() - start_ticks_;
     op_record_->SetDouble("cmd_time", ticks.InMillisecondsF());
 
     canvas_->op_records_.Append(op_record_);
   }
 
   void addParam(const char name[], std::unique_ptr<base::Value> value) {
     std::unique_ptr<base::DictionaryValue> param(new base::DictionaryValue());
     param->Set(name, std::move(value));
 
     op_params_->Append(param.release());
   }
 
-  const SkPaint* paint() const { return paint_; }
+  const SkPaint* paint() const { return &filtered_paint_; }
 
 private:
   BenchmarkingCanvas* canvas_;
   base::DictionaryValue* op_record_;
   base::ListValue* op_params_;
   base::TimeTicks start_ticks_;
 
-  const SkPaint* paint_;
-  SkTLazy<SkPaint> filtered_paint_;
+  SkPaint filtered_paint_;
 };
 
 BenchmarkingCanvas::BenchmarkingCanvas(SkCanvas* canvas, unsigned flags)
     : INHERITED(canvas->imageInfo().width(),
                 canvas->imageInfo().height())
     , flags_(flags) {
   addCanvas(canvas);
 
   if (flags & kOverdrawVisualization_Flag)
     overdraw_xfermode_ = sk_make_sp<OverdrawXfermode>();
@@ skipping 281 matching lines @@
   DCHECK(blob);
   AutoOp op(this, "DrawTextBlob", &paint);
   op.addParam("blob", AsValue(*blob));
   op.addParam("x", AsValue(x));
   op.addParam("y", AsValue(y));
 
   INHERITED::onDrawTextBlob(blob, x, y, *op.paint());
 }
 
 } // namespace skia