Tweak PaintInvalidationReasons

third_party/WebKit/Source/platform/graphics/paint/DisplayItemClient.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef DisplayItemClient_h
 #define DisplayItemClient_h
 
 #include "platform/PlatformExport.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/PaintInvalidationReason.h"
@@ skipping 53 matching lines @@
   // effective painted output if it was set a non-empty size. It's used to skip
   // unforced paint invalidation of LayoutObjects (which is when
   // shouldDoFullPaintInvalidation is false, but mayNeedPaintInvalidation or
   // childShouldCheckForPaintInvalidation is true) to avoid unnecessary paint
   // invalidations of empty areas covered by such objects.
   virtual bool PaintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
     return false;
   }
 
   void SetDisplayItemsUncached(
-      PaintInvalidationReason reason = kPaintInvalidationFull) const {
+      PaintInvalidationReason reason = PaintInvalidationReason::kFull) const {
     cache_generation_or_invalidation_reason_.Invalidate(reason);
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
     // Clear should-keep-alive of DisplayItemClients in a subsequence if this
     // object is a subsequence.
     EndShouldKeepAliveAllClients(this);
 #endif
   }
 
   PaintInvalidationReason GetPaintInvalidationReason() const {
     return cache_generation_or_invalidation_reason_
@@ skipping 30 matching lines @@
   // other paint controllers regardless if it's validly cached by these paint
   // controllers. This situation is very rare (about 0.07% of clients were
   // painted on multiple paint controllers) so the performance penalty is
   // trivial.
   class PLATFORM_EXPORT CacheGenerationOrInvalidationReason {
     DISALLOW_NEW();
 
    public:
     CacheGenerationOrInvalidationReason() : value_(kJustCreated) {}
 
-    void Invalidate(PaintInvalidationReason reason = kPaintInvalidationFull) {
+    void Invalidate(
+        PaintInvalidationReason reason = PaintInvalidationReason::kFull) {
       if (value_ != kJustCreated)
         value_ = static_cast<ValueType>(reason);
     }
 
     static CacheGenerationOrInvalidationReason Next() {
       // In case the value overflowed in the previous call.
       if (next_generation_ < kFirstValidGeneration)
         next_generation_ = kFirstValidGeneration;
       return CacheGenerationOrInvalidationReason(next_generation_++);
     }
 
     bool Matches(const CacheGenerationOrInvalidationReason& other) const {
       return value_ >= kFirstValidGeneration &&
              other.value_ >= kFirstValidGeneration && value_ == other.value_;
     }
 
     PaintInvalidationReason GetPaintInvalidationReason() const {
       return value_ < kJustCreated
                  ? static_cast<PaintInvalidationReason>(value_)
-                 : kPaintInvalidationNone;
+                 : PaintInvalidationReason::kNone;
     }
 
     bool IsJustCreated() const { return value_ == kJustCreated; }
     void ClearIsJustCreated() {
-      value_ = static_cast<ValueType>(kPaintInvalidationFull);
+      value_ = static_cast<ValueType>(PaintInvalidationReason::kFull);
     }
 
    private:
     typedef uint32_t ValueType;
     explicit CacheGenerationOrInvalidationReason(ValueType value)
         : value_(value) {}
 
     static const ValueType kJustCreated =
-        static_cast<ValueType>(kPaintInvalidationReasonMax) + 1;
+        static_cast<ValueType>(PaintInvalidationReason::kMax) + 1;
     static const ValueType kFirstValidGeneration =
-        static_cast<ValueType>(kPaintInvalidationReasonMax) + 2;
+        static_cast<ValueType>(PaintInvalidationReason::kMax) + 2;
     static ValueType next_generation_;
     ValueType value_;
   };
 
   bool DisplayItemsAreCached(CacheGenerationOrInvalidationReason other) const {
     return cache_generation_or_invalidation_reason_.Matches(other);
   }
   void SetDisplayItemsCached(
       CacheGenerationOrInvalidationReason cache_generation) const {
     cache_generation_or_invalidation_reason_ = cache_generation;
@@ skipping 10 matching lines @@
   return &client1 == &client2;
 }
 inline bool operator!=(const DisplayItemClient& client1,
                        const DisplayItemClient& client2) {
   return &client1 != &client2;
 }
 
 }  // namespace blink
 
 #endif  // DisplayItemClient_h