Title: [288700] trunk
Revision
288700
Author
[email protected]
Date
2022-01-27 13:37:28 -0800 (Thu, 27 Jan 2022)

Log Message

Default to 32 bit refcount for CanMakeCheckedPtr
https://bugs.webkit.org/show_bug.cgi?id=235723
rdar://86602114

Reviewed by Darin Adler.

Source/WTF:

It is currently uint16_t for no good reason. It is no unreasonable to have an object being referenced
by a large number of other objects.

We just hit the first bug caused by overrunning it (in IFC).

* wtf/CheckedRef.h:

uint16_t -> uint32_t

Tools:

* TestWebKitAPI/Tests/WTF/CheckedPtr.cpp:
(TestWebKitAPI::TEST):
* TestWebKitAPI/Tests/WTF/CheckedRef.cpp:

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (288699 => 288700)


--- trunk/Source/WTF/ChangeLog	2022-01-27 21:21:30 UTC (rev 288699)
+++ trunk/Source/WTF/ChangeLog	2022-01-27 21:37:28 UTC (rev 288700)
@@ -1,3 +1,20 @@
+2022-01-27  Antti Koivisto  <[email protected]>
+
+        Default to 32 bit refcount for CanMakeCheckedPtr
+        https://bugs.webkit.org/show_bug.cgi?id=235723
+        rdar://86602114
+
+        Reviewed by Darin Adler.
+
+        It is currently uint16_t for no good reason. It is no unreasonable to have an object being referenced
+        by a large number of other objects.
+
+        We just hit the first bug caused by overrunning it (in IFC).
+
+        * wtf/CheckedRef.h:
+
+        uint16_t -> uint32_t
+
 2022-01-27  Ada Chan  <[email protected]>
 
         Disable WebXR experimental feature by default

Modified: trunk/Source/WTF/wtf/CheckedRef.h (288699 => 288700)


--- trunk/Source/WTF/wtf/CheckedRef.h	2022-01-27 21:21:30 UTC (rev 288699)
+++ trunk/Source/WTF/wtf/CheckedRef.h	2022-01-27 21:37:28 UTC (rev 288700)
@@ -298,8 +298,8 @@
     return *this;
 }
 
-using CanMakeCheckedPtr = CanMakeCheckedPtrBase<SingleThreadIntegralWrapper<uint16_t>, uint16_t>;
-using CanMakeThreadSafeCheckedPtr = CanMakeCheckedPtrBase<std::atomic<uint16_t>, uint16_t>;
+using CanMakeCheckedPtr = CanMakeCheckedPtrBase<SingleThreadIntegralWrapper<uint32_t>, uint32_t>;
+using CanMakeThreadSafeCheckedPtr = CanMakeCheckedPtrBase<std::atomic<uint32_t>, uint32_t>;
 
 } // namespace WTF
 

Modified: trunk/Tools/ChangeLog (288699 => 288700)


--- trunk/Tools/ChangeLog	2022-01-27 21:21:30 UTC (rev 288699)
+++ trunk/Tools/ChangeLog	2022-01-27 21:37:28 UTC (rev 288700)
@@ -1,3 +1,15 @@
+2022-01-27  Antti Koivisto  <[email protected]>
+
+        Default to 32 bit refcount for CanMakeCheckedPtr
+        https://bugs.webkit.org/show_bug.cgi?id=235723
+        rdar://86602114
+
+        Reviewed by Darin Adler.
+
+        * TestWebKitAPI/Tests/WTF/CheckedPtr.cpp:
+        (TestWebKitAPI::TEST):
+        * TestWebKitAPI/Tests/WTF/CheckedRef.cpp:
+
 2022-01-27  Elliott Williams  <[email protected]>
 
         [XCBuild] Add missing task dependencies on generate-unified-source-bundles.rb

Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedPtr.cpp (288699 => 288700)


--- trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedPtr.cpp	2022-01-27 21:21:30 UTC (rev 288699)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedPtr.cpp	2022-01-27 21:37:28 UTC (rev 288700)
@@ -47,67 +47,67 @@
 {
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedPtr ptr { &checkedObject };
             EXPECT_TRUE(!!ptr);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedPtr ptr = { &checkedObject };
         EXPECT_TRUE(!!ptr);
         EXPECT_EQ(ptr.get(), &checkedObject);
         EXPECT_EQ(ptr->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
         ptr = nullptr;
 
         EXPECT_FALSE(!!ptr);
         EXPECT_EQ(ptr.get(), nullptr);
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedPtr ptr1 { &checkedObject };
         EXPECT_TRUE(!!ptr1);
         EXPECT_EQ(ptr1.get(), &checkedObject);
         EXPECT_EQ(ptr1->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
         const CheckedPtr ptr2 { &checkedObject };
         EXPECT_TRUE(!!ptr2);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr2->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
 
         CheckedPtr ptr3 = ptr2;
         EXPECT_TRUE(!!ptr3);
         EXPECT_EQ(ptr3.get(), &checkedObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 3);
+        EXPECT_EQ(checkedObject.ptrCount(), 3u);
 
         ptr1 = nullptr;
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
         EXPECT_EQ(ptr1.get(), nullptr);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr3.get(), &checkedObject);
 
         ptr1 = WTFMove(ptr3);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
         EXPECT_EQ(ptr1.get(), &checkedObject);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr3.get(), nullptr);
@@ -118,72 +118,72 @@
 {
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef ref { checkedObject };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
             CheckedPtr ptr { ref };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 2);
+            EXPECT_EQ(checkedObject.ptrCount(), 2u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef<DerivedCheckedObject> ref { checkedObject };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
             CheckedPtr<CheckedObject> ptr { ref };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 2);
+            EXPECT_EQ(checkedObject.ptrCount(), 2u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef ref { checkedObject };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
             CheckedPtr ptr { WTFMove(ref) };
             EXPECT_EQ(ref.ptr(), nullptr);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef<DerivedCheckedObject> ref { checkedObject };
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
             CheckedPtr<CheckedObject> ptr { WTFMove(ref) };
             EXPECT_EQ(ref.ptr(), nullptr);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 }
 
@@ -191,67 +191,67 @@
 {
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedPtr ptr = { &checkedObject };
             EXPECT_TRUE(!!ptr);
             EXPECT_EQ(ptr.get(), &checkedObject);
             EXPECT_EQ(ptr->someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedPtr<CheckedObject> ptr { &checkedObject };
         EXPECT_TRUE(!!ptr);
         EXPECT_EQ(ptr.get(), &checkedObject);
         EXPECT_EQ(ptr->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
         ptr = nullptr;
 
         EXPECT_FALSE(!!ptr);
         EXPECT_EQ(ptr.get(), nullptr);
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedPtr<DerivedCheckedObject> ptr1 { &checkedObject };
         EXPECT_TRUE(!!ptr1);
         EXPECT_EQ(ptr1.get(), &checkedObject);
         EXPECT_EQ(ptr1->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
         const CheckedPtr<CheckedObject> ptr2 = ptr1;
         EXPECT_TRUE(!!ptr2);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr2->someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
 
         CheckedPtr<CheckedObject> ptr3 = ptr1;
         EXPECT_TRUE(!!ptr3);
         EXPECT_EQ(ptr3.get(), &checkedObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 3);
+        EXPECT_EQ(checkedObject.ptrCount(), 3u);
 
         ptr1 = nullptr;
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
         EXPECT_EQ(ptr1.get(), nullptr);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr3.get(), &checkedObject);
 
         CheckedPtr<CheckedObject> ptr4 = WTFMove(ptr3);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
         EXPECT_EQ(ptr1.get(), nullptr);
         EXPECT_EQ(ptr2.get(), &checkedObject);
         EXPECT_EQ(ptr3.get(), nullptr);
@@ -263,53 +263,53 @@
 {
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedPtr ptr = { &checkedObject };
         EXPECT_EQ(ptr.get(), &checkedObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
         HashSet<CheckedPtr<CheckedObject>> set;
         set.add(ptr);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
 
         ptr = nullptr;
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
     }
 
     {
         CheckedObject object1;
         DerivedCheckedObject object2;
-        EXPECT_EQ(object1.ptrCount(), 0);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 0u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
 
         HashSet<CheckedPtr<CheckedObject>> set;
         set.add(&object1);
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
 
         set.add(&object1);
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
 
         CheckedPtr<DerivedCheckedObject> ptr { &object2 };
         set.add(ptr);
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 2);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 2u);
         ptr = nullptr;
 
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 1);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 1u);
 
         set.remove(&object1);
-        EXPECT_EQ(object1.ptrCount(), 0);
-        EXPECT_EQ(object2.ptrCount(), 1);
+        EXPECT_EQ(object1.ptrCount(), 0u);
+        EXPECT_EQ(object2.ptrCount(), 1u);
     }
 
     {
         Vector<std::unique_ptr<CheckedObject>> objects;
         objects.append(makeUniqueWithoutFastMallocCheck<CheckedObject>());
-        EXPECT_EQ(objects[0]->ptrCount(), 0);
+        EXPECT_EQ(objects[0]->ptrCount(), 0u);
 
         HashSet<CheckedPtr<CheckedObject>> set;
         set.add(objects[0].get());
@@ -324,15 +324,24 @@
         }
 
         for (auto& object : objects)
-            EXPECT_EQ(object->ptrCount(), 1);
+            EXPECT_EQ(object->ptrCount(), 1u);
 
         auto setVector = WTF::copyToVector(set);
 
         for (auto& object : objects)
-            EXPECT_EQ(object->ptrCount(), 2);
+            EXPECT_EQ(object->ptrCount(), 2u);
     }
 }
 
+TEST(WTF_CheckedPtr, ReferenceCountLimit)
+{
+    CheckedObject object;
+    constexpr unsigned count = 256 * 1024;
+    Vector<CheckedPtr<CheckedObject>> ptrs;
+    ptrs.fill(&object, count);
+    EXPECT_EQ(object.ptrCount(), count);
+}
+
 class ThreadSafeCheckedPtrObject : public CanMakeThreadSafeCheckedPtr {
 public:
     std::atomic<unsigned> value { 0 };

Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedRef.cpp (288699 => 288700)


--- trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedRef.cpp	2022-01-27 21:21:30 UTC (rev 288699)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/CheckedRef.cpp	2022-01-27 21:37:28 UTC (rev 288700)
@@ -60,12 +60,12 @@
 {
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef ref = checkedObject;
             EXPECT_EQ(&ref.get(), &checkedObject);
@@ -72,59 +72,59 @@
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(ref->someFunction(), -7);
             EXPECT_EQ(static_cast<CheckedObject&>(ref).someFunction(), -7);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         CheckedObject checkedObject;
         CheckedObject anotherObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedRef ref = checkedObject;
         EXPECT_EQ(ref.ptr(), &checkedObject);
         EXPECT_EQ(ref->someFunction(), -7);
         EXPECT_EQ(static_cast<CheckedObject&>(ref).someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
         ref = anotherObject;
         EXPECT_EQ(ref.ptr(), &anotherObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
     }
 
     {
         CheckedObject checkedObject;
         CheckedObject anotherObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         CheckedRef ref1 = checkedObject;
         EXPECT_EQ(ref1.ptr(), &checkedObject);
         EXPECT_EQ(ref1->someFunction(), -7);
         EXPECT_EQ(static_cast<CheckedObject&>(ref1).someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
         const CheckedRef ref2 = checkedObject;
         EXPECT_EQ(ref2.ptr(), &checkedObject);
         EXPECT_EQ(ref2.get().someFunction(), -7);
         EXPECT_EQ(static_cast<const CheckedObject&>(ref2).someFunction(), -7);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
 
         CheckedRef ref3 = ref2;
         EXPECT_EQ(ref3.ptr(), &checkedObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 3);
+        EXPECT_EQ(checkedObject.ptrCount(), 3u);
 
         ref1 = anotherObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
         EXPECT_EQ(ref1.ptr(), &anotherObject);
         EXPECT_EQ(ref2.ptr(), &checkedObject);
         EXPECT_EQ(ref3.ptr(), &checkedObject);
 
         ref1 = WTFMove(ref3);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
         EXPECT_EQ(ref1.ptr(), &checkedObject);
         EXPECT_EQ(ref2.ptr(), &checkedObject);
     }
@@ -134,7 +134,7 @@
 {
     {
         DerivedCheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
         {
             CheckedRef ref = checkedObject;
             EXPECT_EQ(&ref.get(), &checkedObject);
@@ -141,59 +141,59 @@
             EXPECT_EQ(ref.ptr(), &checkedObject);
             EXPECT_EQ(static_cast<DerivedCheckedObject&>(ref).someFunction(), -11);
             EXPECT_EQ(ref->someFunction(), -11);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
     }
 
     {
         DerivedCheckedObject checkedObject;
         DerivedCheckedObject anotherObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         CheckedRef<CheckedObject> ref = checkedObject;
         EXPECT_EQ(ref.ptr(), &checkedObject);
         EXPECT_EQ(ref->someFunction(), -11);
         EXPECT_EQ(static_cast<CheckedObject&>(ref).someFunction(), -11);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         ref = anotherObject;
         EXPECT_EQ(ref.ptr(), &anotherObject);
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
     }
 
     {
         DerivedCheckedObject checkedObject { 10 };
         DerivedCheckedObject anotherObject { 20 };
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         CheckedRef<DerivedCheckedObject> ref1 = checkedObject;
         EXPECT_EQ(ref1.ptr(), &checkedObject);
         EXPECT_EQ(ref1->someFunction(), 10);
         EXPECT_EQ(static_cast<CheckedObject&>(ref1).someFunction(), 10);
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         const CheckedRef<CheckedObject> ref2 = ref1;
         EXPECT_EQ(ref2.ptr(), &checkedObject);
         EXPECT_EQ(ref2->someFunction(), 10);
         EXPECT_EQ(static_cast<const CheckedObject&>(ref2).someFunction(), 10);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         CheckedRef<CheckedObject> ref3 = ref1;
         EXPECT_EQ(ref3.ptr(), &checkedObject);
         EXPECT_EQ(static_cast<CheckedObject&>(ref3).someFunction(), 10);
-        EXPECT_EQ(checkedObject.ptrCount(), 3);
-        EXPECT_EQ(anotherObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 3u);
+        EXPECT_EQ(anotherObject.ptrCount(), 0u);
 
         ref1 = anotherObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
         EXPECT_EQ(ref1.ptr(), &anotherObject);
         EXPECT_EQ(ref1->someFunction(), 20);
         EXPECT_EQ(static_cast<CheckedObject&>(ref1).someFunction(), 20);
@@ -201,8 +201,8 @@
         EXPECT_EQ(ref3.ptr(), &checkedObject);
 
         CheckedRef<CheckedObject> ref4 = WTFMove(ref1);
-        EXPECT_EQ(checkedObject.ptrCount(), 2);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 2u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
         EXPECT_EQ(ref2.ptr(), &checkedObject);
         EXPECT_EQ(ref3.ptr(), &checkedObject);
         EXPECT_EQ(ref4.ptr(), &anotherObject);
@@ -210,8 +210,8 @@
         EXPECT_EQ(ref4->someFunction(), 20);
 
         ref1 = checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 3);
-        EXPECT_EQ(anotherObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 3u);
+        EXPECT_EQ(anotherObject.ptrCount(), 1u);
         EXPECT_EQ(ref1.ptr(), &checkedObject);
         EXPECT_EQ(ref1->someFunction(), 10);
         EXPECT_EQ(ref2.ptr(), &checkedObject);
@@ -223,36 +223,36 @@
 {
     {
         CheckedObject checkedObject;
-        EXPECT_EQ(checkedObject.ptrCount(), 0);
+        EXPECT_EQ(checkedObject.ptrCount(), 0u);
 
         HashSet<CheckedRef<CheckedObject>> set;
         {
             CheckedRef ref = checkedObject;
             EXPECT_EQ(ref.ptr(), &checkedObject);
-            EXPECT_EQ(checkedObject.ptrCount(), 1);
+            EXPECT_EQ(checkedObject.ptrCount(), 1u);
 
             set.add(ref);
-            EXPECT_EQ(checkedObject.ptrCount(), 2);
+            EXPECT_EQ(checkedObject.ptrCount(), 2u);
         }
-        EXPECT_EQ(checkedObject.ptrCount(), 1);
+        EXPECT_EQ(checkedObject.ptrCount(), 1u);
     }
 
     {
         CheckedObject object1;
         DerivedCheckedObject object2;
-        EXPECT_EQ(object1.ptrCount(), 0);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 0u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
 
         HashSet<CheckedRef<CheckedObject>> set;
         set.add(object1);
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
         EXPECT_TRUE(set.contains(object1));
         EXPECT_FALSE(set.contains(object2));
 
         set.add(object1);
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 0);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 0u);
         EXPECT_TRUE(set.contains(object1));
         EXPECT_FALSE(set.contains(object2));
 
@@ -259,20 +259,20 @@
         {
             CheckedRef<DerivedCheckedObject> ref { object2 };
             set.add(ref);
-            EXPECT_EQ(object1.ptrCount(), 1);
-            EXPECT_EQ(object2.ptrCount(), 2);
+            EXPECT_EQ(object1.ptrCount(), 1u);
+            EXPECT_EQ(object2.ptrCount(), 2u);
             EXPECT_TRUE(set.contains(object1));
             EXPECT_TRUE(set.contains(object2));
         }
 
-        EXPECT_EQ(object1.ptrCount(), 1);
-        EXPECT_EQ(object2.ptrCount(), 1);
+        EXPECT_EQ(object1.ptrCount(), 1u);
+        EXPECT_EQ(object2.ptrCount(), 1u);
         EXPECT_TRUE(set.contains(object1));
         EXPECT_TRUE(set.contains(object2));
 
         set.remove(object1);
-        EXPECT_EQ(object1.ptrCount(), 0);
-        EXPECT_EQ(object2.ptrCount(), 1);
+        EXPECT_EQ(object1.ptrCount(), 0u);
+        EXPECT_EQ(object2.ptrCount(), 1u);
         EXPECT_FALSE(set.contains(object1));
         EXPECT_TRUE(set.contains(object2));
     }
@@ -280,7 +280,7 @@
     {
         Vector<std::unique_ptr<CheckedObject>> objects;
         objects.append(makeUniqueWithoutFastMallocCheck<CheckedObject>(0));
-        EXPECT_EQ(objects[0]->ptrCount(), 0);
+        EXPECT_EQ(objects[0]->ptrCount(), 0u);
 
         HashSet<CheckedRef<CheckedObject>> set;
         set.add(*objects[0].get());
@@ -295,7 +295,7 @@
         }
 
         for (auto& object : objects) {
-            EXPECT_EQ(object->ptrCount(), 1);
+            EXPECT_EQ(object->ptrCount(), 1u);
             EXPECT_TRUE(set.contains(*object));
         }
 
@@ -309,7 +309,7 @@
         auto setVector = WTF::copyToVector(set);
 
         for (auto& object : objects)
-            EXPECT_EQ(object->ptrCount(), 2);
+            EXPECT_EQ(object->ptrCount(), 2u);
     }
 }
 
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to