Implemented direct message passing for local targets; this fixes a deadlock

with PostMessage() in case the message queue is full.
Some notes:
* for synchronous replies, we don't use this mechanism yet, but it could be
  extended to do that as well.
* the code looks so complicated because we need a way to access the looper's
  queue without locking it (to prevent deadlocks); like Dano's solution, I've
  abused BTokenSpace to store a BDirectMessageTarget with a BHandler.
* we also need to decouple the lifetime of a looper's queue from its target,
  as we cannot lock the looper, and therefore, can't guarantee it stays valid
  as long as we're accessing it outside of BLooper.
* init_clipboard() now needs to be done after the global constructors have
  been called - since sending messages now needs gDefaultTokens to be initialized.
  Since this is done per image, it shouldn't cause any troubles, though.
* some minor cleanup, removed unused _msg_cache_cleanup_() and friends.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@19968 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/app/DirectMessageTarget.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2007, Haiku, Inc.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Axel Dörfler, [email protected]
+ */
+#ifndef _DIRECT_MESSAGE_TARGET_H
+#define _DIRECT_MESSAGE_TARGET_H
+
+
+#include <MessageQueue.h>
+
+
+namespace BPrivate {
+
+class BDirectMessageTarget {
+	public:
+		BDirectMessageTarget();
+		~BDirectMessageTarget();
+
+		bool AddMessage(BMessage* message);
+
+		void Close();
+		void Acquire();
+		void Release();
+
+		BMessageQueue* Queue() { return &fQueue; }
+
+	private:
+		int32			fReferenceCount;
+		BMessageQueue	fQueue;
+		bool			fClosed;
+};
+
+}	// namespace BPrivate
+
+#endif	// _DIRECT_MESSAGE_TARGET_H

headers/private/app/MessagePrivate.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2005, Haiku Inc. All rights reserved.
+ * Copyright 2005-2007, Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -200,10 +200,10 @@ class BMessage::Private {
 		}
 
 		status_t
-		SendMessage(port_id port, int32 token, bigtime_t timeout,
-			bool replyRequired, BMessenger &replyTo) const
+		SendMessage(port_id port, team_id portOwner, int32 token,
+			bigtime_t timeout, bool replyRequired, BMessenger &replyTo) const
 		{
-			return fMessage->_SendMessage(port, token,
+			return fMessage->_SendMessage(port, portOwner, token,
 				timeout, replyRequired, replyTo);
 		}
 

headers/private/app/TokenSpace.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2001-2006, Haiku.
+ * Copyright 2001-2007, Haiku.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -10,13 +10,13 @@
 #define _TOKEN_SPACE_H
 
 
-#include <map>
-#include <stack>
-
 #include <BeBuild.h>
 #include <Locker.h>
 #include <SupportDefs.h>
 
+#include <map>
+#include <stack>
+
 
 // token types as specified in targets
 #define B_PREFERRED_TOKEN	-2		/* A little bird told me about this one */
@@ -30,6 +30,9 @@
 
 namespace BPrivate {
 
+class BDirectMessageTarget;
+
+
 class BTokenSpace : public BLocker {
 	public:
 		BTokenSpace();
@@ -40,12 +43,16 @@ class BTokenSpace : public BLocker {
 
 		bool		RemoveToken(int32 token);
 		bool		CheckToken(int32 token, int16 type) const;
-		status_t	GetToken(int32 token, int16 type, void** object) const;
+		status_t	GetToken(int32 token, int16 type, void** _object) const;
+
+		status_t	SetHandlerTarget(int32 token, BDirectMessageTarget* target);
+		status_t	AcquireHandlerTarget(int32 token, BDirectMessageTarget** _target);
 
 	private:
 		struct token_info {
 			int16	type;
 			void*	object;
+			BDirectMessageTarget* target;
 		};
 		typedef std::map<int32, token_info> TokenMap;