Move overdraw tracking code from GraphicsContext to CanvasRenderingContext2D

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 14 matching lines @@
  */
 
 #include "config.h"
 #include "platform/graphics/GraphicsContext.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Gradient.h"
-#include "platform/graphics/GraphicsContextClient.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkClipStack.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDevice.h"
@@ skipping 34 matching lines @@
         , m_savedMatrix(matrix)
     { }
 
     SkPictureRecorder m_recorder;
     SkCanvas* m_savedCanvas;
     const SkMatrix m_savedMatrix;
 };
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisplayItemList* displayItemList, DisabledMode disableContextOrPainting)
     : m_canvas(canvas)
-    , m_client(0)
     , m_displayItemList(displayItemList)
     , m_clipRecorderStack(0)
     , m_paintStateStack()
     , m_paintStateIndex(0)
     , m_annotationMode(0)
     , m_layerCount(0)
 #if ENABLE(ASSERT)
     , m_annotationCount(0)
     , m_disableDestructionChecks(false)
     , m_inDrawingRecorder(false)
@@ skipping 1026 matching lines @@
 
     image->draw(this, dest, src, op);
 }
 
 void GraphicsContext::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (m_client) {
-        SkRect rect = SkRect::MakeXYWH(x, y, info.width(), info.height());
-        m_client->willDrawRect(this, rect, 0, GraphicsContextClient::NoImage, GraphicsContextClient::UntransformedUnclippedFill);
-    }
-
     m_canvas->writePixels(info, pixels, rowBytes, x, y);
 }
 
-template<typename T>
-inline GraphicsContextClient::ImageType toImageType(T* image)
-{
-    if (!image)
-        return GraphicsContextClient::NoImage;
-    if (image->isOpaque())
-        return GraphicsContextClient::OpaqueImage;
-    return GraphicsContextClient::NonOpaqueImage;
-}
-
 void GraphicsContext::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint)
 {
     ASSERT(m_canvas);
     // Textures are bound to the blink main-thread GrContext, which can not be
     // used on the compositor raster thread.
     // FIXME: Mailbox support would make this possible in the GPU-raster case.
     ASSERT(!isRecording() || !bitmap.getTexture());
     if (contextDisabled())
         return;
 
-    if (m_client) {
-        SkRect rect = SkRect::MakeXYWH(left, top, bitmap.width(), bitmap.height());
-        m_client->willDrawRect(this, rect, paint, toImageType(&bitmap), GraphicsContextClient::Fill);
-    }
-
     m_canvas->drawBitmap(bitmap, left, top, paint);
 }
 
 void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
     const SkRect& dst, const SkPaint* paint)
 {
     ASSERT(m_canvas);
     // Textures are bound to the blink main-thread GrContext, which can not be
     // used on the compositor raster thread.
     // FIXME: Mailbox support would make this possible in the GPU-raster case.
     ASSERT(!isRecording() || !bitmap.getTexture());
     if (contextDisabled())
         return;
 
     SkCanvas::DrawBitmapRectFlags flags =
         immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
 
-    if (m_client)
-        m_client->willDrawRect(this, dst, paint, toImageType(&bitmap), GraphicsContextClient::Fill);
-
     m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
 }
 
 void GraphicsContext::drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (m_client)
-        m_client->willDrawRect(this, SkRect::MakeXYWH(left, top, image->width(), image->height()), paint, toImageType(image), GraphicsContextClient::Fill);
-
     m_canvas->drawImage(image, left, top, paint);
 }
 
 void GraphicsContext::drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, const SkPaint* paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (m_client)
-        m_client->willDrawRect(this, dst, paint, toImageType(image), GraphicsContextClient::Fill);
-
     m_canvas->drawImageRect(image, src, dst, paint);
 }
 
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawOval(oval, paint);
 }
 
 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawPath(path, paint);
 }
 
 void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (m_client)
-        m_client->willDrawRect(this, rect, &paint, GraphicsContextClient::NoImage, GraphicsContextClient::FillOrStroke);
-
     m_canvas->drawRect(rect, paint);
 }
 
 void GraphicsContext::drawRRect(const SkRRect& rrect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawRRect(rrect, paint);
@@ skipping 258 matching lines @@
 
     clipRoundedRect(rect, SkRegion::kDifference_Op);
 }
 
 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (op != SkRegion::kIntersect_Op && op != SkRegion::kReplace_Op)
-        setHasComplexClip();
-
     m_canvas->clipRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (!path.isRect(0) || (op != SkRegion::kIntersect_Op && op != SkRegion::kReplace_Op))
-        setHasComplexClip();
-
     m_canvas->clipPath(path, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    if (!rect.isRect() || (op != SkRegion::kIntersect_Op && op != SkRegion::kReplace_Op))
-        setHasComplexClip();
-
     m_canvas->clipRRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::rotate(float angleInRadians)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->rotate(WebCoreFloatToSkScalar(angleInRadians * (180.0f / 3.14159265f)));
@@ skipping 376 matching lines @@
         // being set to true). We need to decide if we respect InterpolationNone
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterLevel(static_cast<SkPaint::FilterLevel>(resampling));
 
     return initialSaveCount;
 }
 
-void GraphicsContext::setClient(GraphicsContextClient* client)
-{
-    ASSERT(client == 0 || m_client == 0); // No clobbering
-    m_client = client;
-}
-
 } // namespace blink