Use SkTLazy for ScopedDecodedImageLock's optional paint

cc/playback/display_list_raster_source.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 "cc/playback/display_list_raster_source.h"
 
 #include <stddef.h>
 
 #include "base/containers/adapters.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/playback/discardable_image_map.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/tiles/image_decode_controller.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "third_party/skia/include/core/SkTLazy.h"
 #include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
 SkIRect RoundOutRect(const SkRect& rect) {
   SkIRect result;
   rect.roundOut(&result);
@@ skipping 109 matching lines @@
   class ScopedDecodedImageLock {
    public:
     ScopedDecodedImageLock(ImageDecodeController* image_decode_controller,
                            const SkImage* image,
                            const SkRect& src_rect,
                            const SkSize& scale,
                            bool is_decomposable,
                            bool has_perspective,
                            const SkPaint* paint)
         : image_decode_controller_(image_decode_controller),
-          paint_(paint),
           draw_image_(image,
                       RoundOutRect(src_rect),
                       scale,
                       paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
                       has_perspective,
                       is_decomposable),
           decoded_draw_image_(
               image_decode_controller_->GetDecodedImageForDraw(draw_image_)) {
       DCHECK(image->isLazyGenerated());
-      if (paint) {
-        decoded_paint_ = *paint;
-        decoded_paint_.setFilterQuality(decoded_draw_image_.filter_quality());
-      }
+      if (paint)
+        decoded_paint_.set(*paint)->setFilterQuality(
+            decoded_draw_image_.filter_quality());
     }
 
     ~ScopedDecodedImageLock() {
       image_decode_controller_->DrawWithImageFinished(draw_image_,
                                                       decoded_draw_image_);
     }
 
     const DecodedDrawImage& decoded_image() const {
       return decoded_draw_image_;
     }
     const SkPaint* decoded_paint() const {
-      return paint_ ? &decoded_paint_ : nullptr;
+      return decoded_paint_.getMaybeNull();
     }
 
    private:
     ImageDecodeController* image_decode_controller_;
-    const SkPaint* paint_;
     DrawImage draw_image_;
     DecodedDrawImage decoded_draw_image_;
-    SkPaint decoded_paint_;
+    // TODO(fmalita): use base::Optional when it becomes available
+    SkTLazy<SkPaint> decoded_paint_;
   };
 
   ImageDecodeController* image_decode_controller_;
 };
 
 }  // namespace
 
 scoped_refptr<DisplayListRasterSource>
 DisplayListRasterSource::CreateFromDisplayListRecordingSource(
     const DisplayListRecordingSource* other,
@@ skipping 310 matching lines @@
     ImageDecodeController* image_decode_controller) {
   DCHECK(image_decode_controller);
   // Note that although this function should only be called once, tests tend to
   // call it several times using the same controller.
   DCHECK(!image_decode_controller_ ||
          image_decode_controller_ == image_decode_controller);
   image_decode_controller_ = image_decode_controller;
 }
 
 }  // namespace cc