Remove unneeded abstractions and simplify RecordingImageBufferSurface

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,
-    std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory>
-        fallback_factory,
     OpacityMode opacity_mode,
     const CanvasColorParams& color_params)
     : ImageBufferSurface(size, opacity_mode, color_params),
       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),
-      fallback_factory_(std::move(fallback_factory)) {
+      previous_frame_has_expensive_op_(false) {
   InitializeCurrentFrame();
 }
 
 RecordingImageBufferSurface::~RecordingImageBufferSurface() {}
 
 void RecordingImageBufferSurface::InitializeCurrentFrame() {
   current_frame_ = WTF::WrapUnique(new PaintRecorder);
   PaintCanvas* canvas =
       current_frame_->beginRecording(size().Width(), size().Height());
   // Always save an initial frame, to support resetting the top level matrix
@@ skipping 17 matching lines @@
     fallback_surface_->SetImageBuffer(image_buffer);
   }
 }
 
 bool RecordingImageBufferSurface::WritePixels(const SkImageInfo& orig_info,
                                               const void* pixels,
                                               size_t row_bytes,
                                               int x,
                                               int y) {
   if (!fallback_surface_) {
-    if (x <= 0 && y <= 0 && x + orig_info.width() >= size().Width() &&
-        y + orig_info.height() >= size().Height()) {
+    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(fallback_factory_);
   CHECK(reason != kFallbackReasonUnknown);
 
   if (fallback_surface_) {
     DCHECK(!current_frame_);
     return;
   }
 
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, canvas_fallback_histogram,
       new EnumerationHistogram("Canvas.DisplayListFallbackReason",
                                kFallbackReasonCount));
   canvas_fallback_histogram.Count(reason);
 
-  fallback_surface_ = fallback_factory_->CreateSurface(size(), GetOpacityMode(),
-                                                       color_params());
+  fallback_surface_ = WTF::WrapUnique(new UnacceleratedImageBufferSurface(
+      size(), GetOpacityMode(), kInitializeImagePixels, color_params()));
   fallback_surface_->SetImageBuffer(image_buffer_);
 
   if (previous_frame_) {
     fallback_surface_->Canvas()->PlaybackPaintRecord(previous_frame_);
     previous_frame_.reset();
   }
 
   if (current_frame_) {
     sk_sp<PaintRecord> record = current_frame_->finishRecordingAsPicture();
     if (record)
@@ skipping 115 matching lines @@
     FallBackToRasterCanvas(DisableDeferralReasonToFallbackReason(reason));
 }
 
 sk_sp<PaintRecord> RecordingImageBufferSurface::GetRecord() {
   if (fallback_surface_)
     return nullptr;
 
   FallbackReason fallback_reason = kFallbackReasonUnknown;
   bool can_use_record = FinalizeFrameInternal(&fallback_reason);
 
-  DCHECK(can_use_record || fallback_factory_);
-
   if (can_use_record) {
     return previous_frame_;
   }
 
   if (!fallback_surface_)
     FallBackToRasterCanvas(fallback_reason);
   return nullptr;
 }
 
 void RecordingImageBufferSurface::FinalizeFrame() {
@@ skipping 68 matching lines @@
     }
     CHECK(current_frame_);
     return true;
   }
 
   if (!frame_was_cleared_) {
     *fallback_reason = kFallbackReasonCanvasNotClearedBetweenFrames;
     return false;
   }
 
-  if (fallback_factory_ &&
-      current_frame_->getRecordingCanvas()->getSaveCount() - 1 >
-          ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth) {
+  if (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