Add thread affinity and ASSERT() for same-thread restriction to WTF::Function

third_party/WebKit/Source/platform/Task.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 
 #include "public/platform/WebTaskRunner.h"
 #include "wtf/Allocator.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace blink {
 
-class Task : public WebTaskRunner::Task {
-    USING_FAST_MALLOC(Task);
-    WTF_MAKE_NONCOPYABLE(Task);
+// Please use WTF::Closure and WTF::CrossThreadClosure directly, instead of

[haraken, 2016/03/02 09:27:35]

Nit: I might prefer renaming WTF::Closure to WTF::SameThreadClosure in a follow
up CL. In general, it looks better to be explicit about same-thread or
cross-thread in method names.

[hiroshige, 2016/03/03 02:21:07]

Should we also rename bind() to sameThreadBind()?

tzik@, what do you think?
I prefer to rename Closure to SameThreadClosure to make it a more strong signal
for developers and users of postTask() functions.
But Closure/CrossThreadClosure might be more compatible with your planned names
of base::Callback family.

[haraken, 2016/03/03 02:38:06]

I'd prefer having sameThreadBind & sameThreadCallback as well to give a better
signal to developers, but it's up to tzik@ and other chromium folks :)

[tzik, 2016/03/03 04:49:30]

It's up to you. :p
Since bind() in Blink is mostly used for cross-thread unlike to Chromium, it
seems plausible to state the thread-safety explicitly to prevent devs to find
bind() first.

But in Chromium, I want to use base::Bind() for thread-unsafe case rather than
introducing base::SameThreadBind(). I believe everything is assumed to be
thread-unsafe by default in Chromium, and thread-safe stuff is explicitly
annotated.
Since a half of base::Bind() usage are for same-thread tasks, I want to use a
short name for it.

[hiroshige, 2016/03/04 02:02:46]

Thanks for suggestions!
I renamed WTF::Closure to WTF::SameThreadClosure, as
postTask(PassOwnPtr<SameThreadClosure>) or so is clearer.
And use of WTF::Closure is relatively rare in Blink; most of developers uses
bind()+postTask() etc., without declaring interfaces using WTF::Closure. And
having limited number of functions that receives PassOwnPtr<Closure> is also
good. So assigning longer names both for same/cross-thread Closure is good in
Blink case.

I'll leave WTF::bind() as-is in this CL.

+// wrapping them by blink::SameThreadTask/CrossThreadTask here.
+
+// TODO(hiroshige): Make these classes internal to
+// Source/platform/WebTaskRunner.cpp.
+class SameThreadTask : public WebTaskRunner::Task {
+    USING_FAST_MALLOC(SameThreadTask);
+    WTF_MAKE_NONCOPYABLE(SameThreadTask);
 public:
-    explicit Task(PassOwnPtr<Closure> closure)
+    explicit SameThreadTask(PassOwnPtr<Closure> closure)
         : m_closure(std::move(closure))
     {
     }
 
     void run() override
     {
         (*m_closure)();
     }
 
 private:
     OwnPtr<Closure> m_closure;
 };
 
+class CrossThreadTask : public WebTaskRunner::Task {
+    USING_FAST_MALLOC(CrossThreadTask);
+    WTF_MAKE_NONCOPYABLE(CrossThreadTask);
+public:
+    explicit CrossThreadTask(PassOwnPtr<CrossThreadClosure> closure)
+        : m_closure(std::move(closure))
+    {
+    }
+
+    void run() override
+    {
+        (*m_closure)();
+    }
+
+private:
+    OwnPtr<CrossThreadClosure> m_closure;
+};
+
 } // namespace blink
 
 #endif // Task_h