Refactoring: Make Resource::m_data private

third_party/WebKit/Source/core/fetch/ImageResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 99 matching lines @@
     HashCountedSet<ImageResourceObserver*> observers;
     m_observers.swap(observers);
     for (const auto& it : observers)
         m_finishedObservers.add(it.key, it.value);
 
     Resource::markClientsAndObserversFinished();
 }
 
 void ImageResource::didAddClient(ResourceClient* client)
 {
-    DCHECK((m_multipartParser && isLoading()) || !m_data || m_image);
+    DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
     Resource::didAddClient(client);
 }
 
 void ImageResource::addObserver(ImageResourceObserver* observer)
 {
     willAddClientOrObserver();
 
     m_observers.add(observer);
 
     if (isCacheValidator())
         return;
 
-    // When the response is not multipart, if |m_data| exists, |m_image| must
-    // be created. This is assured that |updateImage()| is called when
+    // When the response is not multipart, if |data()| exists, |m_image| must be
+    // created. This is assured that |updateImage()| is called when
     // |appendData()| is called.
     //
     // On the other hand, when the response is multipart, |updateImage()| is
     // not called in |appendData()|, which means |m_image| might not be created
-    // even when |m_data| exists. This is intentional since creating a |m_image|
+    // even when |data()| exists. This is intentional since creating a |m_image|
     // on receiving data might destroy an existing image in a previous part.
-    DCHECK((m_multipartParser && isLoading()) || !m_data || m_image);
+    DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
 
     if (m_image && !m_image->isNull()) {
         observer->imageChanged(this);
     }
 
     if (isLoaded()) {
         observer->imageNotifyFinished(this);
         if (m_observers.contains(observer)) {
             m_finishedObservers.add(observer);
             m_observers.remove(observer);
@@ skipping 36 matching lines @@
     ImageResourceObserverWalker walker(m_observers);
     while (const auto* observer = walker.next()) {
         priorityFromObserver(observer, priority);
     }
 
     return priority;
 }
 
 bool ImageResource::isSafeToUnlock() const
 {
-    // Note that |m_image| holds a reference to |m_data| in addition to the one held by the Resource parent class.
-    return !m_image || (m_image->hasOneRef() && m_data->refCount() == 2);
+    // Note that |m_image| holds a reference to |data()| in addition to the one held by the Resource parent class.
+    return !m_image || (m_image->hasOneRef() && data()->refCount() == 2);
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation()
 {
     clearImage();
     setDecodedSize(0);
 }
 
 void ImageResource::destroyDecodedDataIfPossible()
 {
@@ skipping 21 matching lines @@
         else
             m_image->resetAnimation();
     }
     if (m_multipartParser)
         m_multipartParser->cancel();
     Resource::allClientsAndObserversRemoved();
 }
 
 PassRefPtr<SharedBuffer> ImageResource::resourceBuffer() const
 {
-    if (m_data)
-        return m_data.get();
+    if (data())
+        return data();
     if (m_image)
         return m_image->data();
     return nullptr;
 }
 
 void ImageResource::appendData(const char* data, size_t length)
 {
     if (m_multipartParser) {
         m_multipartParser->appendData(data, length);
     } else {
@@ skipping 88 matching lines @@
 
     ImageResourceObserverWalker walker(m_observers);
     while (auto* observer = walker.next()) {
         observer->imageChanged(this, changeRect);
     }
 }
 
 void ImageResource::clear()
 {
     clearImage();
-    m_data.clear();
+    clearData();
     setEncodedSize(0);
 }
 
 inline void ImageResource::createImage()
 {
     // Create the image if it doesn't yet exist.
     if (m_image)
         return;
 
     if (response().mimeType() == "image/svg+xml") {
@@ skipping 11 matching lines @@
     // If our Image has an observer, it's always us so we need to clear the back pointer
     // before dropping our reference.
     m_image->clearImageObserver();
     m_image.clear();
 }
 
 void ImageResource::updateImage(bool allDataReceived)
 {
     TRACE_EVENT0("blink", "ImageResource::updateImage");
 
-    if (m_data)
+    if (data())
         createImage();
 
     Image::SizeAvailability sizeAvailable = Image::SizeUnavailable;
 
     // Have the image update its data from its internal buffer.
     // It will not do anything now, but will delay decoding until
     // queried for info (like size or specific image frames).
-    if (m_data) {
+    if (data()) {
         DCHECK(m_image);
-        sizeAvailable = m_image->setData(m_data, allDataReceived);
+        sizeAvailable = m_image->setData(data(), allDataReceived);
     }
 
     // Go ahead and tell our observers to try to draw if we have either
     // received all the data or the size is known. Each chunk from the
     // network causes observers to repaint, which will force that chunk
     // to decode.
     if (sizeAvailable == Image::SizeUnavailable && !allDataReceived)
         return;
     if (!m_image || m_image->isNull()) {
         if (!errorOccurred())
             setStatus(DecodeError);
         if (!allDataReceived && loader())
             loader()->didFinishLoading(nullptr, monotonicallyIncreasingTime(), encodedSize());
         clear();
         memoryCache()->remove(this);
     }
 
     // It would be nice to only redraw the decoded band of the image, but with the current design
     // (decoding delayed until painting) that seems hard.
     notifyObservers();
 }
 
 void ImageResource::updateImageAndClearBuffer()
 {
     clearImage();
     updateImage(true);
-    m_data.clear();
+    clearData();
 }
 
 void ImageResource::finish(double loadFinishTime)
 {
     if (m_multipartParser) {
         m_multipartParser->finish();
-        if (m_data)
+        if (data())
             updateImageAndClearBuffer();
     } else {
         updateImage(true);
         // As encoded image data can be created from m_image  (see
         // ImageResource::resourceBuffer(), we don't have to keep m_data. Let's
         // clear this. As for the lifetimes of m_image and m_data, see this
         // document:
         // https://docs.google.com/document/d/1v0yTAZ6wkqX2U_M6BNIGUJpM1s0TIw1VsqpxoL7aciY/edit?usp=sharing
-        m_data.clear();
+        clearData();
     }
     Resource::finish(loadFinishTime);
 }
 
 void ImageResource::error(const ResourceError& error)
 {
     if (m_multipartParser)
         m_multipartParser->cancel();
     clear();
     Resource::error(error);
@@ skipping 147 matching lines @@
     if (response().wasFetchedViaServiceWorker())
         return response().serviceWorkerResponseType() != WebServiceWorkerResponseTypeOpaque;
     if (!getImage()->currentFrameHasSingleSecurityOrigin())
         return false;
     if (passesAccessControlCheck(securityOrigin))
         return true;
     return !securityOrigin->taintsCanvas(response().url());
 }
 
 } // namespace blink