Allow RecordingImageBufferSurface to prevent fallback.

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

 // 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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include <memory>
 
 #include "platform/Histogram.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/paint/PaintRecorder.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 RecordingImageBufferSurface::RecordingImageBufferSurface(
     const IntSize& size,
+    AllowFallback allow_fallback,
     OpacityMode opacity_mode,
     const CanvasColorParams& color_params)
     : ImageBufferSurface(size, opacity_mode, color_params),
+      allow_fallback_(allow_fallback),
       image_buffer_(0),
       current_frame_pixel_count_(0),
       previous_frame_pixel_count_(0),
       frame_was_cleared_(true),
       did_record_draw_commands_in_current_frame_(false),
       current_frame_has_expensive_op_(false),
       previous_frame_has_expensive_op_(false) {
   InitializeCurrentFrame();
 }
 
@@ skipping 34 matching lines @@
     IntRect write_rect(x, y, orig_info.width(), orig_info.height());
     if (write_rect.Contains(IntRect(IntPoint(), size())))
       WillOverwriteCanvas();
     FallBackToRasterCanvas(kFallbackReasonWritePixels);
   }
   return fallback_surface_->WritePixels(orig_info, pixels, row_bytes, x, y);
 }
 
 void RecordingImageBufferSurface::FallBackToRasterCanvas(
     FallbackReason reason) {
+  DCHECK(allow_fallback_ == kAllowFallback);
   CHECK(reason != kFallbackReasonUnknown);
 
   if (fallback_surface_) {
     DCHECK(!current_frame_);
     return;
   }
 
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, canvas_fallback_histogram,
       new EnumerationHistogram("Canvas.DisplayListFallbackReason",
@@ skipping 218 matching lines @@
     }
     CHECK(current_frame_);
     return true;
   }
 
   if (!frame_was_cleared_) {
     *fallback_reason = kFallbackReasonCanvasNotClearedBetweenFrames;
     return false;
   }
 
-  if (current_frame_->getRecordingCanvas()->getSaveCount() - 1 >
-      ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth) {
+  if (allow_fallback_ == kAllowFallback &&
+      current_frame_->getRecordingCanvas()->getSaveCount() - 1 >
+          ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth) {
     // (getSaveCount() decremented to account  for the intial recording canvas
     // save frame.)
     *fallback_reason = kFallbackReasonRunawayStateStack;
     return false;
   }
 
   previous_frame_ = current_frame_->finishRecordingAsPicture();
   previous_frame_has_expensive_op_ = current_frame_has_expensive_op_;
   previous_frame_pixel_count_ = current_frame_pixel_count_;
   InitializeCurrentFrame();
@@ skipping 70 matching lines @@
 }
 
 void RecordingImageBufferSurface::SetIsHidden(bool hidden) {
   if (fallback_surface_)
     fallback_surface_->SetIsHidden(hidden);
   else
     ImageBufferSurface::SetIsHidden(hidden);
 }
 
 }  // namespace blink