Changes between Version 3 and Version 4 of ThreadCommunication

Timestamp:

Apr 14, 2011 10:20:03 AM (13 years ago)

Author:

levin@chromium.org

Comment:

--

ThreadCommunication

@@ -12 +12 @@
 '''Use cases'''
 
-1. An object exist on one thread. It wants to create an object on another thread and then have a number of calls happen between these two objects.
-This one is a superset of other potential cases including fire and forget.[[BR]]
+1. An object exist on one thread. It wants to create an object on another thread and be able to call methods on it.
+This is a superset of other potential cases including fire and forget.[[BR]]
 
+2. An object wants to be able to allow another thread to be able to call its methods.[[BR]]
 
-Issue: Should this use case be broken up into several?[[BR]]
+3. A function wants to call a method on another thread and wait until it is done. Allowing callbacks resulting from that to run in the web worker thread.
+This does look suspiciously like a nested message loop with a filter which many people regard as evil. The only reason to allow this capability is for synchronous calls from javascript to call to the main thread to get some work done and act like a synchronous call but there may be callbacks (e.g. when doing a sync xhr call.) Theoretically, the javascript engine could roll up its state into a closure and we could avoid the nested message loop but that capability doesn't exist in the engines that we deal with and would be very expensive to add to them.[[BR]]
 
-
-2. A web worker thread wants to call a function on another thread and wait until it is done. Allowing callbacks resulting from that to run in the web worker thread.
-This does look suspiciously like a nested message loop with a filter which many people regard as evil. The only reason to allow this capability is for synchronous calls from javascript to call to the main thread to get some work done and act like a synchronous call but there may be callbacks (e.g. when doing a sync xhr call.) Theoretically, the javascript engine could roll up its state into a closure and we could avoid the nested message loop but that capability doesn't exist in the engines that we deal with and would be very expensive to add to them.[[BR]]
+The framework should track the dependencies to check for possible deadlocks.[[BR]]
 
 
@@ -34 +34 @@
 '''Proposed code samples for use cases'''
 
-TBD: Here is where some code will go to show what these use cases look like.
+Case 1: Create an object on another thread:[[BR]]
+
+{{{
+    // Creates a proxy and initializes a target object on a given message loop.
+    RefPtr<TypeName::Proxy> proxy = TypeName::createProxy(otherMessageLoop, constructorArg1, constructorArg2, ...);
+
+    // Calls method on the object on the other message loop. This does not need to wait for some signal that the object has been created.
+    proxy->invoke(&TypeName::method, arg1, arg2, ...);
+}}}
+
+Case 2: Allow an object on another thread to do callbacks:[[BR]]
+
+{{{
+    // getProxy is a method in the current object which returns its proxy. The proxy may be used with invoke like these examples.
+    proxy->invoke(&TypeName::method, arg1, getProxy(), arg3, ...);
+}}}
 
 
+Case 3: A thread wants to call a function on another thread and wait until it is done.
+
+TBD