Changeset 295175 in webkit

Timestamp:

Jun 2, 2022, 11:45:05 PM (4 years ago)

Author:

Alan Coon

Message:

Apply patch. rdar://problem/92380002

Location:

branches/safari-613-branch

Files:

• Source/WTF/wtf/ThreadAssertions.h (modified) (4 diffs)
• Source/WTF/wtf/ThreadSafetyAnalysis.h (modified) (1 diff)
• Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h (modified) (1 diff)
• Tools/Scripts/webkitpy/style/checkers/cpp.py (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WTF/ThreadAssertionsTest.cpp (modified) (3 diffs)

branches/safari-613-branch/Source/WTF/wtf/ThreadAssertions.h

@@ -42 +42 @@
 //     template<typename> void doTaskCompileFailure() { doTaskImpl(); }
 // private:
-//     void doTaskImpl() WTF_REQUIRES_LOCK(m_ownerThread);
-//     int m_value WTF_GUARDED_BY_LOCK(m_ownerThread) { 0 };
+//     void doTaskImpl() WTF_REQUIRES_CAPABILITY(m_ownerThread);
+//     int m_value WTF_GUARDED_BY_CAPABILITY(m_ownerThread) { 0 };
 //     NO_UNIQUE_ADDRESS ThreadAssertion m_ownerThread;
 // };
-class WTF_CAPABILITY_LOCK ThreadAssertion {
+class WTF_CAPABILITY("is current") ThreadAssertion {
 public:
     ThreadAssertion() = default;
@@ -65 +65 @@
 };
 
-inline void assertIsCurrent(const ThreadAssertion& threadAssertion) WTF_ASSERTS_ACQUIRED_LOCK(threadAssertion)
+inline void assertIsCurrent(const ThreadAssertion& threadAssertion) WTF_ASSERTS_ACQUIRED_CAPABILITY(threadAssertion)
 {
     ASSERT_UNUSED(threadAssertion, Thread::current().uid() == threadAssertion.m_uid);
@@ -75 +75 @@
 // Example:
 // extern NamedAssertion& mainThread;
-// inline void assertIsMainThread() WTF_ASSERTS_ACQUIRED_LOCK(mainThread);
-// void myTask() WTF_REQUIRES_LOCK(mainThread) { printf("my task is running"); }
+// inline void assertIsMainThread() WTF_ASSERTS_ACQUIRED_CAPABILITY(mainThread);
+// void myTask() WTF_REQUIRES_CAPABILITY(mainThread) { printf("my task is running"); }
 // void runner() {
 //     assertIsMainThread();
@@ -84 +84 @@
 //     myTask();
 // }
-class WTF_CAPABILITY_LOCK NamedAssertion { };
+class WTF_CAPABILITY("is current") NamedAssertion { };
 
-// To be used with WTF_REQUIRES_LOCK(mainThread). Symbol is undefined.
+// To be used with WTF_REQUIRES_CAPABILITY(mainThread). Symbol is undefined.
 extern NamedAssertion& mainThread;
-inline void assertIsMainThread() WTF_ASSERTS_ACQUIRED_LOCK(mainThread) { ASSERT(isMainThread()); }
+inline void assertIsMainThread() WTF_ASSERTS_ACQUIRED_CAPABILITY(mainThread) { ASSERT(isMainThread()); }
 
-// To be used with WTF_REQUIRES_LOCK(mainRunLoop). Symbol is undefined.
+// To be used with WTF_REQUIRES_CAPABILITY(mainRunLoop). Symbol is undefined.
 extern NamedAssertion& mainRunLoop;
-inline void assertIsMainRunLoop() WTF_ASSERTS_ACQUIRED_LOCK(mainRunLoop) { ASSERT(isMainRunLoop()); }
+inline void assertIsMainRunLoop() WTF_ASSERTS_ACQUIRED_CAPABILITY(mainRunLoop) { ASSERT(isMainRunLoop()); }
 
 }

branches/safari-613-branch/Source/WTF/wtf/ThreadSafetyAnalysis.h

@@ -36 +36 @@
 #endif
 
-#define WTF_ACQUIRES_LOCK_IF(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_capability(__VA_ARGS__))
-#define WTF_ACQUIRES_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(acquire_capability(__VA_ARGS__))
-#define WTF_ACQUIRES_SHARED_LOCK_IF(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_shared_capability(__VA_ARGS__))
-#define WTF_ACQUIRES_SHARED_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(acquire_shared_capability(__VA_ARGS__))
-#define WTF_ASSERTS_ACQUIRED_LOCK(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(assert_capability(x))
-#define WTF_ASSERTS_ACQUIRED_SHARED_LOCK(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(assert_shared_capability(x))
-#define WTF_CAPABILITY_LOCK WTF_THREAD_ANNOTATION_ATTRIBUTE(capability("mutex"))
+#define WTF_ACQUIRES_CAPABILITY_IF(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_capability(__VA_ARGS__))
+#define WTF_ACQUIRES_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(acquire_capability(__VA_ARGS__))
+#define WTF_ACQUIRES_SHARED_CAPABILITY_IF(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_shared_capability(__VA_ARGS__))
+#define WTF_ACQUIRES_SHARED_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(acquire_shared_capability(__VA_ARGS__))
+#define WTF_ASSERTS_ACQUIRED_CAPABILITY(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(assert_capability(x))
+#define WTF_ASSERTS_ACQUIRED_SHARED_CAPABILITY(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(assert_shared_capability(x))
+#define WTF_CAPABILITY(name) WTF_THREAD_ANNOTATION_ATTRIBUTE(capability(name))
 #define WTF_CAPABILITY_SCOPED_LOCK WTF_THREAD_ANNOTATION_ATTRIBUTE(scoped_lockable)
-#define WTF_EXCLUDES_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(locks_excluded(__VA_ARGS__))
-#define WTF_GUARDED_BY_LOCK(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(guarded_by(x))
+#define WTF_EXCLUDES_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(locks_excluded(__VA_ARGS__))
+#define WTF_GUARDED_BY_CAPABILITY(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(guarded_by(x))
 #define WTF_IGNORES_THREAD_SAFETY_ANALYSIS WTF_THREAD_ANNOTATION_ATTRIBUTE(no_thread_safety_analysis)
-#define WTF_POINTEE_GUARDED_BY_LOCK(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(pt_guarded_by(x))
-#define WTF_RELEASES_LOCK_GENERIC(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_generic_capability(__VA_ARGS__))
-#define WTF_RELEASES_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_capability(__VA_ARGS__))
-#define WTF_RELEASES_SHARED_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_shared_capability(__VA_ARGS__))
-#define WTF_REQUIRES_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(requires_capability(__VA_ARGS__))
-#define WTF_REQUIRES_SHARED_LOCK(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(requires_shared_capability(__VA_ARGS__))
-#define WTF_RETURNS_LOCK(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(lock_returned(x))
+#define WTF_POINTEE_GUARDED_BY_CAPABILITY(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(pt_guarded_by(x))
+#define WTF_RELEASES_GENERIC_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_generic_capability(__VA_ARGS__))
+#define WTF_RELEASES_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_capability(__VA_ARGS__))
+#define WTF_RELEASES_SHARED_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(release_shared_capability(__VA_ARGS__))
+#define WTF_REQUIRES_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(requires_capability(__VA_ARGS__))
+#define WTF_REQUIRES_SHARED_CAPABILITY(...) WTF_THREAD_ANNOTATION_ATTRIBUTE(requires_shared_capability(__VA_ARGS__))
+#define WTF_RETURNS_CAPABILITY(x) WTF_THREAD_ANNOTATION_ATTRIBUTE(lock_returned(x))
+
+// Using WTF_CAPABILITY_LOCK is a common use-case. Introduce terms containing "LOCK" for maximum readability.
+#define WTF_ACQUIRES_LOCK_IF(...) WTF_ACQUIRES_CAPABILITY_IF(__VA_ARGS__)
+#define WTF_ACQUIRES_LOCK(...)  WTF_ACQUIRES_CAPABILITY(__VA_ARGS__)
+#define WTF_ACQUIRES_SHARED_LOCK_IF(...) WTF_ACQUIRES_SHARED_CAPABILITY_IF(__VA_ARGS__)
+#define WTF_ACQUIRES_SHARED_LOCK(...) WTF_ACQUIRES_SHARED_CAPABILITY(__VA_ARGS__)
+#define WTF_ASSERTS_ACQUIRED_LOCK(x) WTF_ASSERTS_ACQUIRED_CAPABILITY(x)
+#define WTF_ASSERTS_ACQUIRED_SHARED_LOCK(x) WTF_ASSERTS_ACQUIRED_SHARED_CAPABILITY(x)
+#define WTF_CAPABILITY_LOCK WTF_CAPABILITY("lock")
+#define WTF_EXCLUDES_LOCK(...) WTF_EXCLUDES_CAPABILITY(__VA_ARGS__)
+#define WTF_GUARDED_BY_LOCK(x) WTF_GUARDED_BY_CAPABILITY(x)
+#define WTF_POINTEE_GUARDED_BY_LOCK(x) WTF_POINTEE_GUARDED_BY_CAPABILITY(x)
+#define WTF_RELEASES_GENERIC_LOCK(...) WTF_RELEASES_GENERIC_CAPABILITY(__VA_ARGS__)
+#define WTF_RELEASES_LOCK(...) WTF_RELEASES_CAPABILITY(__VA_ARGS__)
+#define WTF_RELEASES_SHARED_LOCK(...) WTF_RELEASES_SHARED_CAPABILITY(__VA_ARGS__)
+#define WTF_REQUIRES_LOCK(...) WTF_REQUIRES_CAPABILITY(__VA_ARGS__)
+#define WTF_REQUIRES_SHARED_LOCK(...) WTF_REQUIRES_SHARED_CAPABILITY(__VA_ARGS__)
+#define WTF_RETURNS_LOCK(x) WTF_RETURNS_CAPABILITY(x)

branches/safari-613-branch/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h

@@ -143 +143 @@
     Lock m_remoteDisplayListsLock;
     bool m_canRegisterRemoteDisplayLists WTF_GUARDED_BY_LOCK(m_remoteDisplayListsLock) { false };
-    HashMap<QualifiedRenderingResourceIdentifier, Ref<RemoteDisplayListRecorder>> m_remoteDisplayLists WTF_GUARDED_BY_LOCK(m_remoteDisplayListsLock);
+    HashMap<QualifiedRenderingResourceIdentifier, Ref<RemoteDisplayListRecorder>> m_remoteDisplayLists WTF_GUARDED_BY_CAPABILITY(m_remoteDisplayListsLock);
 };
 

branches/safari-613-branch/Tools/Scripts/webkitpy/style/checkers/cpp.py

@@ -4164 +4164 @@
                 and not modified_identifier == "LOG_CHANNEL"
                 and not modified_identifier == "WTF_GUARDED_BY_LOCK"
+                and not modified_identifier == "WTF_GUARDED_BY_CAPABILITY"
                 and not modified_identifier.find('chrono_literals') >= 0):
                 error(line_number, 'readability/naming/underscores', 4, identifier + " is incorrectly named. Don't use underscores in your identifier names.")

branches/safari-613-branch/Tools/TestWebKitAPI/Tests/WTF/ThreadAssertionsTest.cpp

@@ -47 +47 @@
     template<typename T> void accessVariableCompileFailure(T n) { m_value = n; }
 private:
-    int doTaskImpl(int n) WTF_REQUIRES_LOCK(m_ownerThread) { return n + 1; }
-    int m_value WTF_GUARDED_BY_LOCK(m_ownerThread) { 0 };
+    int doTaskImpl(int n) WTF_REQUIRES_CAPABILITY(m_ownerThread) { return n + 1; }
+    int m_value WTF_GUARDED_BY_CAPABILITY(m_ownerThread) { 0 };
     NO_UNIQUE_ADDRESS ThreadAssertion m_ownerThread;
 };
@@ -65 +65 @@
 }
 
-static int testMainThreadFunction() WTF_REQUIRES_LOCK(mainThread) { return 11; }
+static int testMainThreadFunction() WTF_REQUIRES_CAPABILITY(mainThread) { return 11; }
 
 TEST(WTF_ThreadAssertions, TestMainThreadNamedAssertion)
@@ -76 +76 @@
 }
 
-static int testMainRunLoopFunction() WTF_REQUIRES_LOCK(mainRunLoop) { return 12; }
+static int testMainRunLoopFunction() WTF_REQUIRES_CAPABILITY(mainRunLoop) { return 12; }
 
 TEST(WTF_ThreadAssertions, TestMainRunLoopNamedAssertion)