[Oilpan] Unify memory usage reporters of Oilpan

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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.
@@ skipping 111 matching lines @@
     return StaticBitmapImage::create(adoptRef(surface->newImageSnapshot()));
 }
 
 } // namespace
 
 inline HTMLCanvasElement::HTMLCanvasElement(Document& document)
     : HTMLElement(canvasTag, document)
     , DocumentVisibilityObserver(document)
     , m_size(DefaultWidth, DefaultHeight)
     , m_ignoreReset(false)
-    , m_externallyAllocatedMemory(0)
     , m_originClean(true)
     , m_didFailToCreateImageBuffer(false)
     , m_imageBufferIsClear(false)
 {
     setHasCustomStyleCallbacks();
     CanvasMetrics::countCanvasContextUsage(CanvasMetrics::CanvasCreated);
 }
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
 HTMLCanvasElement::~HTMLCanvasElement()
 {
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
 #if !ENABLE(OILPAN)
     // Ensure these go away before the ImageBuffer.
     m_context.clear();
 #endif
 }
 
 void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
     if (name == widthAttr || name == heightAttr)
         reset();
@@ skipping 102 matching lines @@
     }
 
     m_context = factory->create(this, attributes, document());
     if (!m_context)
         return nullptr;
 
     if (m_context->is3d()) {
         const ComputedStyle* style = ensureComputedStyle();
         if (style)
             m_context->setFilterQuality(style->imageRendering() == ImageRenderingPixelated ? kNone_SkFilterQuality : kLow_SkFilterQuality);
-        updateExternallyAllocatedMemory();
     }
     setNeedsCompositingUpdate();
 
     return m_context.get();
 }
 
 bool HTMLCanvasElement::shouldBeDirectComposited() const
 {
     return (m_context && m_context->isAccelerated()) || (hasImageBuffer() && buffer()->isExpensiveToPaint());
 }
@@ skipping 498 matching lines @@
     if (!m_imageBuffer)
         return;
     m_imageBuffer->setClient(this);
 
     document().updateLayoutTreeIfNeeded();
     const ComputedStyle* style = ensureComputedStyle();
     m_imageBuffer->setFilterQuality((style && (style->imageRendering() == ImageRenderingPixelated)) ? kNone_SkFilterQuality : kLow_SkFilterQuality);
 
     m_didFailToCreateImageBuffer = false;
 
-    updateExternallyAllocatedMemory();
-
     if (is3D()) {
         // Early out for WebGL canvases
         return;
     }
 
     m_imageBuffer->setClient(this);
     // Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
     // rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
     // canvases but not in unaccelerated canvases.
     if (!msaaSampleCount && document().settings() && !document().settings()->antialiased2dCanvasEnabled())
@@ skipping 10 matching lines @@
 }
 
 DEFINE_TRACE(HTMLCanvasElement)
 {
     visitor->trace(m_listeners);
     visitor->trace(m_context);
     DocumentVisibilityObserver::trace(visitor);
     HTMLElement::trace(visitor);
 }
 
-void HTMLCanvasElement::updateExternallyAllocatedMemory() const
-{
-    int bufferCount = 0;
-    if (m_imageBuffer) {
-        bufferCount++;
-        if (m_imageBuffer->isAccelerated()) {
-            // The number of internal GPU buffers vary between one (stable
-            // non-displayed state) and three (triple-buffered animations).
-            // Adding 2 is a pessimistic but relevant estimate.
-            // Note: These buffers might be allocated in GPU memory.
-            bufferCount += 2;
-        }
-    }
-    if (m_copiedImage)
-        bufferCount++;
-
-    // Four bytes per pixel per buffer.
-    Checked<intptr_t, RecordOverflow> checkedExternallyAllocatedMemory = 4 * bufferCount;
-    if (is3D())
-        checkedExternallyAllocatedMemory += m_context->externallyAllocatedBytesPerPixel();
-
-    checkedExternallyAllocatedMemory *= width();
-    checkedExternallyAllocatedMemory *= height();
-    intptr_t externallyAllocatedMemory;
-    if (checkedExternallyAllocatedMemory.safeGet(externallyAllocatedMemory) == CheckedState::DidOverflow)
-        externallyAllocatedMemory = std::numeric_limits<intptr_t>::max();
-
-    // Subtracting two intptr_t that are known to be positive will never underflow.
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(externallyAllocatedMemory - m_externallyAllocatedMemory);

[haraken, 2016/02/08 11:17:20]

This AdjustAmountOfMemory is explaining GPU's memory, so we shouldn't remove it
in this CL, right?

[peria, 2016/02/09 06:39:59]

You're right. reverted.

-    m_externallyAllocatedMemory = externallyAllocatedMemory;
-}
-
 SkCanvas* HTMLCanvasElement::drawingCanvas() const
 {
     return buffer() ? m_imageBuffer->canvas() : nullptr;
 }
 
 void HTMLCanvasElement::disableDeferral() const
 {
     if (buffer())
         m_imageBuffer->disableDeferral();
 }
@@ skipping 39 matching lines @@
         return nullptr;
     if (!m_context)
         return createTransparentImage(size());
 
     bool needToUpdate = !m_copiedImage;
     // The concept of SourceDrawingBuffer is valid on only WebGL.
     if (m_context->is3d())
         needToUpdate |= m_context->paintRenderingResultsToCanvas(sourceBuffer);
     if (needToUpdate && buffer()) {
         m_copiedImage = buffer()->newImageSnapshot(hint);
-        updateExternallyAllocatedMemory();
     }
     return m_copiedImage;
 }
 
 void HTMLCanvasElement::discardImageBuffer()
 {
     m_imageBuffer.clear();
     m_dirtyRect = FloatRect();
-    updateExternallyAllocatedMemory();
 }
 
 void HTMLCanvasElement::clearCopiedImage()
 {
     if (m_copiedImage) {
         m_copiedImage.clear();
-        updateExternallyAllocatedMemory();
     }
 }
 
 AffineTransform HTMLCanvasElement::baseTransform() const
 {
     ASSERT(hasImageBuffer() && !m_didFailToCreateImageBuffer);
     return m_imageBuffer->baseTransform();
 }
 
 void HTMLCanvasElement::didChangeVisibilityState(PageVisibilityState visibility)
@@ skipping 79 matching lines @@
     }
     return ImageBitmapSource::fulfillImageBitmap(scriptState, isPaintable() ? ImageBitmap::create(this, IntRect(sx, sy, sw, sh), options) : nullptr);
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // namespace blink