Replace Resource::Status with ResourceStatus

third_party/WebKit/Source/platform/loader/fetch/Resource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 68 matching lines @@
     XSLStyleSheet,
     LinkPrefetch,
     TextTrack,
     ImportResource,
     Media,  // Audio or video file requested by a HTML5 media element
     Manifest,
     Mock  // Only for testing
   };
   static const int kLastResourceType = Mock + 1;
 
-  using Status = ResourceStatus;
-
-  // TODO(hiroshige): Remove the following declarations.
-  static constexpr Status NotStarted = ResourceStatus::NotStarted;
-  static constexpr Status Pending = ResourceStatus::Pending;
-  static constexpr Status Cached = ResourceStatus::Cached;
-  static constexpr Status LoadError = ResourceStatus::LoadError;
-  static constexpr Status DecodeError = ResourceStatus::DecodeError;
-
   // Whether a resource client for a preload should mark the preload as
   // referenced.
   enum PreloadReferencePolicy {
     MarkAsReferenced,
     DontMarkAsReferenced,
   };
 
   // Used by reloadIfLoFiOrPlaceholderImage().
   enum ReloadLoFiOrPlaceholderPolicy {
     kReloadIfNeeded,
@@ skipping 57 matching lines @@
   void removeClient(ResourceClient*);
 
   enum PreloadResult {
     PreloadNotReferenced,
     PreloadReferenced,
     PreloadReferencedWhileLoading,
     PreloadReferencedWhileComplete
   };
   PreloadResult getPreloadResult() const { return m_preloadResult; }
 
-  Status getStatus() const { return m_status; }
-  void setStatus(Status status) { m_status = status; }
+  ResourceStatus getStatus() const { return m_status; }
+  void setStatus(ResourceStatus status) { m_status = status; }
 
   size_t size() const { return encodedSize() + decodedSize() + overheadSize(); }
 
   // Returns the size of content (response body) before decoding. Adding a new
   // usage of this function is not recommended (See the TODO below).
   //
   // TODO(hiroshige): Now encodedSize/decodedSize states are inconsistent and
   // need to be refactored (crbug/643135).
   size_t encodedSize() const { return m_encodedSize; }
 
   // Returns the current memory usage for the encoded data. Adding a new usage
   // of this function is not recommended as the same reason as |encodedSize()|.
   //
   // |encodedSize()| and |encodedSizeMemoryUsageForTesting()| can return
   // different values, e.g., when ImageResource purges encoded image data after
   // finishing loading.
   size_t encodedSizeMemoryUsageForTesting() const {
     return m_encodedSizeMemoryUsage;
   }
 
   size_t decodedSize() const { return m_decodedSize; }
   size_t overheadSize() const { return m_overheadSize; }
 
-  bool isLoaded() const { return m_status > Pending; }
+  bool isLoaded() const { return m_status > ResourceStatus::Pending; }
 
-  bool isLoading() const { return m_status == Pending; }
-  bool stillNeedsLoad() const { return m_status < Pending; }
+  bool isLoading() const { return m_status == ResourceStatus::Pending; }
+  bool stillNeedsLoad() const { return m_status < ResourceStatus::Pending; }
 
   void setLoader(ResourceLoader*);
   ResourceLoader* loader() const { return m_loader.get(); }
 
   virtual bool isImage() const { return false; }
   bool shouldBlockLoadEvent() const;
   bool isLoadEventBlockingResourceType() const;
 
   // Computes the status of an object after loading. Updates the expire date on
   // the cache entry file
@@ skipping 24 matching lines @@
   // Sets the serialized metadata retrieved from the platform's cache.
   virtual void setSerializedCachedMetadata(const char*, size_t);
 
   // This may return nullptr when the resource isn't cacheable.
   CachedMetadataHandler* cacheHandler();
 
   AtomicString httpContentType() const;
 
   bool wasCanceled() const { return m_error.isCancellation(); }
   bool errorOccurred() const {
-    return m_status == LoadError || m_status == DecodeError;
+    return m_status == ResourceStatus::LoadError ||
+           m_status == ResourceStatus::DecodeError;
   }
   bool loadFailedOrCanceled() const { return !m_error.isNull(); }
 
   DataBufferingPolicy getDataBufferingPolicy() const {
     return m_options.dataBufferingPolicy;
   }
   void setDataBufferingPolicy(DataBufferingPolicy);
 
   // The isPreloaded() flag is using a counter in order to make sure that even
   // when multiple ResourceFetchers are preloading the resource, it will remain
@@ skipping 196 matching lines @@
   const size_t m_overheadSize;
 
   unsigned m_preloadCount;
 
   double m_preloadDiscoveryTime;
 
   String m_cacheIdentifier;
 
   PreloadResult m_preloadResult;
   Type m_type;
-  Status m_status;
+  ResourceStatus m_status;
 
   bool m_needsSynchronousCacheHit;
   bool m_linkPreload;
   bool m_isRevalidating;
   bool m_isAlive;
   bool m_isAddRemoveClientProhibited;
   bool m_isRevalidationStartForbidden = false;
 
   ResourceIntegrityDisposition m_integrityDisposition;
   IntegrityMetadataSet m_integrityMetadata;
@@ skipping 34 matching lines @@
 };
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName)                   \
   DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource,    \
                     resource->getType() == Resource::typeName, \
                     resource.getType() == Resource::typeName);
 
 }  // namespace blink
 
 #endif