Allow RecordingImageBufferSurface to prevent fallback.

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.h

 // 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.
 
 #ifndef RecordingImageBufferSurface_h
 #define RecordingImageBufferSurface_h
 
 #include <memory>
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBufferSurface.h"
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/Noncopyable.h"
 #include "public/platform/WebThread.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace blink {
 
 class ImageBuffer;
 class UnacceleratedImageBufferSurface;
 
 class PLATFORM_EXPORT RecordingImageBufferSurface : public ImageBufferSurface {
   WTF_MAKE_NONCOPYABLE(RecordingImageBufferSurface);
   USING_FAST_MALLOC(RecordingImageBufferSurface);
 
  public:
-  // If the fallbackFactory is null the buffer surface should only be used
-  // for one frame and should not be used for any operations which need a
-  // raster surface, (i.e. writePixels).
-  // Only #getRecord should be used to access the resulting frame.
-  RecordingImageBufferSurface(
-      const IntSize&,
-      OpacityMode = kNonOpaque,
-      const CanvasColorParams& = CanvasColorParams());
+  enum AllowFallback : bool { kDisallowFallback, kAllowFallback };
+
+  // If |AllowFallback| is kDisallowFallback the buffer surface should only be
+  // used for one frame and should not be used for any operations which need a
+  // raster surface, (i.e. WritePixels()).
+  // Only GetRecord() should be used to access the resulting frame.
+  RecordingImageBufferSurface(const IntSize&,
+                              AllowFallback,
+                              OpacityMode = kNonOpaque,
+                              const CanvasColorParams& = CanvasColorParams());
   ~RecordingImageBufferSurface() override;
 
   // Implementation of ImageBufferSurface interfaces
   PaintCanvas* Canvas() override;
   void DisableDeferral(DisableDeferralReason) override;
   sk_sp<PaintRecord> GetRecord() override;
   void Flush(FlushReason) override;
   void DidDraw(const FloatRect&) override;
   bool IsValid() const override { return true; }
   bool IsRecording() const override { return !fallback_surface_; }
@@ skipping 55 matching lines @@
     kFallbackReasonSnapshotForCreateImageBitmap = 29,
     kFallbackReasonCount,
   };
 
  private:
   void FallBackToRasterCanvas(FallbackReason);
   void InitializeCurrentFrame();
   bool FinalizeFrameInternal(FallbackReason*);
   int ApproximateOpCount();
 
+  const AllowFallback allow_fallback_;
   std::unique_ptr<PaintRecorder> current_frame_;
   sk_sp<PaintRecord> previous_frame_;
   std::unique_ptr<UnacceleratedImageBufferSurface> fallback_surface_;
   ImageBuffer* image_buffer_;
   int initial_save_count_;
   int current_frame_pixel_count_;
   int previous_frame_pixel_count_;
   bool frame_was_cleared_;
   bool did_record_draw_commands_in_current_frame_;
   bool current_frame_has_expensive_op_;
   bool previous_frame_has_expensive_op_;
 };
 
 }  // namespace blink
 
 #endif