Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
@@ skipping 149 matching lines @@
       DCHECK_EQ(static_cast<size_t>(sk_canvas->getSaveCount()),
                 state_stack_.size() + 1);
     }
   }
 #endif
   CHECK(state_stack_.front()
             .Get());  // Temporary for investigating crbug.com/648510
 }
 
 bool CanvasRenderingContext2D::IsAccelerated() const {
-  if (!canvas()->HasImageBuffer())
+  if (!host()->GetImageBuffer())
     return false;
-  return canvas()->Buffer()->IsAccelerated();
+  return host()->GetImageBuffer()->IsAccelerated();
 }
 
 bool CanvasRenderingContext2D::IsComposited() const {
   return IsAccelerated();
 }
 
 void CanvasRenderingContext2D::Stop() {
   if (!isContextLost()) {
     // Never attempt to restore the context because the page is being torn down.
     LoseContext(kSyntheticLostContext);
   }
 }
 
 bool CanvasRenderingContext2D::isContextLost() const {
   return context_lost_mode_ != kNotLostContext;
 }
 
 void CanvasRenderingContext2D::LoseContext(LostContextMode lost_mode) {
   if (context_lost_mode_ != kNotLostContext)
     return;
   context_lost_mode_ = lost_mode;
   if (context_lost_mode_ == kSyntheticLostContext && canvas()) {
-    canvas()->DiscardImageBuffer();
+    host()->DiscardImageBuffer();
   }
   dispatch_context_lost_event_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void CanvasRenderingContext2D::DidSetSurfaceSize() {
   if (!context_restorable_)
     return;
   // This code path is for restoring from an eviction
   // Restoring from surface failure is handled internally
-  DCHECK(context_lost_mode_ != kNotLostContext && !canvas()->HasImageBuffer());
+  DCHECK(context_lost_mode_ != kNotLostContext && !host()->GetImageBuffer());
 
-  if (canvas()->Buffer()) {
+  if (host()->GetOrCreateImageBuffer()) {
     if (ContextLostRestoredEventsEnabled()) {
       dispatch_context_restored_event_timer_.StartOneShot(0, BLINK_FROM_HERE);
     } else {
       // legacy synchronous context restoration.
       Reset();
       context_lost_mode_ = kNotLostContext;
     }
   }
 }
 
@@ skipping 25 matching lines @@
 
 void CanvasRenderingContext2D::TryRestoreContextEvent(TimerBase* timer) {
   if (context_lost_mode_ == kNotLostContext) {
     // Canvas was already restored (possibly thanks to a resize), so stop
     // trying.
     try_restore_context_event_timer_.Stop();
     return;
   }
 
   DCHECK(context_lost_mode_ == kRealLostContext);
-  if (canvas()->HasImageBuffer() && canvas()->Buffer()->RestoreSurface()) {
+  if (host()->GetImageBuffer() && host()->GetImageBuffer()->RestoreSurface()) {
     try_restore_context_event_timer_.Stop();
     DispatchContextRestoredEvent(nullptr);
   }
 
   if (++try_restore_context_attempt_count_ > kMaxTryRestoreContextAttempts) {
     // final attempt: allocate a brand new image buffer instead of restoring
-    canvas()->DiscardImageBuffer();
+    host()->DiscardImageBuffer();
     try_restore_context_event_timer_.Stop();
-    if (canvas()->Buffer())
+    if (host()->GetOrCreateImageBuffer())
       DispatchContextRestoredEvent(nullptr);
   }
 }
 
 void CanvasRenderingContext2D::DispatchContextRestoredEvent(TimerBase*) {
   if (context_lost_mode_ == kNotLostContext)
     return;
   Reset();
   context_lost_mode_ = kNotLostContext;
   if (ContextLostRestoredEventsEnabled()) {
@@ skipping 88 matching lines @@
     hit_region_manager_->RemoveHitRegionsInRect(rect, GetState().Transform());
   }
 }
 
 void CanvasRenderingContext2D::DidDraw(const SkIRect& dirty_rect) {
   if (dirty_rect.isEmpty())
     return;
 
   if (ExpensiveCanvasHeuristicParameters::kBlurredShadowsAreExpensive &&
       GetState().ShouldDrawShadows() && GetState().ShadowBlur() > 0) {
-    ImageBuffer* buffer = canvas()->Buffer();
+    ImageBuffer* buffer = host()->GetOrCreateImageBuffer();
     if (buffer)
       buffer->SetHasExpensiveOp();
   }
 
   CanvasRenderingContext::DidDraw(dirty_rect);
 }
 
 bool CanvasRenderingContext2D::StateHasFilter() {
   return GetState().HasFilter(canvas(), canvas()->Size(), this);
 }
@@ skipping 213 matching lines @@
 
 int CanvasRenderingContext2D::Width() const {
   return canvas()->width();
 }
 
 int CanvasRenderingContext2D::Height() const {
   return canvas()->height();
 }
 
 bool CanvasRenderingContext2D::HasImageBuffer() const {
-  return canvas()->HasImageBuffer();
+  return host()->GetImageBuffer();
 }
 
 ImageBuffer* CanvasRenderingContext2D::GetImageBuffer() const {
-  return canvas()->Buffer();
+  return const_cast<CanvasRenderingContextHost*>(host())
+      ->GetOrCreateImageBuffer();
 }
 
 PassRefPtr<Image> blink::CanvasRenderingContext2D::GetImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!HasImageBuffer())
     return nullptr;
-  return canvas()->Buffer()->NewImageSnapshot(hint, reason);
+  return host()->GetOrCreateImageBuffer()->NewImageSnapshot(hint, reason);
 }
 
 bool CanvasRenderingContext2D::ParseColorOrCurrentColor(
     Color& color,
     const String& color_string) const {
   return ::blink::ParseColorOrCurrentColor(color, color_string, canvas());
 }
 
 HitTestCanvasResult* CanvasRenderingContext2D::GetControlAndIdIfHitRegionExists(
     const LayoutPoint& location) {
@@ skipping 344 matching lines @@
                  : -font_metrics.Descent() + font_metrics.Height() / 2;
     case kAlphabeticTextBaseline:
     default:
       // Do nothing.
       break;
   }
   return 0;
 }
 
 void CanvasRenderingContext2D::SetIsHidden(bool hidden) {
-  if (canvas()->HasImageBuffer())
-    canvas()->Buffer()->SetIsHidden(hidden);
+  if (host()->GetImageBuffer())
+    host()->GetImageBuffer()->SetIsHidden(hidden);
   if (hidden) {
     PruneLocalFontCache(0);
   }
 }
 
 bool CanvasRenderingContext2D::IsTransformInvertible() const {
   return GetState().IsTransformInvertible();
 }
 
 WebLayer* CanvasRenderingContext2D::PlatformLayer() const {
-  return canvas()->Buffer() ? canvas()->Buffer()->PlatformLayer() : 0;
+  return host()->GetOrCreateImageBuffer()
+             ? host()->GetImageBuffer()->PlatformLayer()
+             : 0;
 }
 
 void CanvasRenderingContext2D::getContextAttributes(
     CanvasRenderingContext2DSettings& settings) const {
   settings.setAlpha(CreationAttributes().alpha());
   settings.setColorSpace(ColorSpaceAsString());
   settings.setPixelFormat(PixelFormatAsString());
   settings.setLinearPixelMath(color_params().LinearPixelMath());
 }
 
@@ skipping 184 matching lines @@
   }
   return true;
 }
 
 void CanvasRenderingContext2D::ResetUsageTracking() {
   UsageCounters new_counters;
   usage_counters_ = new_counters;
 }
 
 }  // namespace blink