[SCM] WebKit Debian packaging branch, webkit-1.3, updated. upstream/1.3.7-4207-g178b198

[andersca at apple.com]

The following commit has been merged in the webkit-1.3 branch:
commit 6c3564b45722794a7f4d2fb1bc11523c7b1ec1c2
Author: andersca at apple.com <andersca at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date:   Thu Jan 20 00:40:44 2011 +0000

    2011-01-19  Anders Carlsson  <andersca at apple.com>
    
            Reviewed by Dan Bernstein.
    
            Put the deprecated Connection member functions next to eachother
            https://bugs.webkit.org/show_bug.cgi?id=52767
    
            * Platform/CoreIPC/Connection.h:
            (CoreIPC::Connection::sendSync):
            (CoreIPC::Connection::send):
    
    
    git-svn-id: http://svn.webkit.org/repository/webkit/trunk@76181 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog
index db4255b..d737116 100644
--- a/Source/WebKit2/ChangeLog
+++ b/Source/WebKit2/ChangeLog
@@ -1,5 +1,16 @@
 2011-01-19  Anders Carlsson  <andersca at apple.com>
 
+        Reviewed by Dan Bernstein.
+
+        Put the deprecated Connection member functions next to eachother
+        https://bugs.webkit.org/show_bug.cgi?id=52767
+
+        * Platform/CoreIPC/Connection.h:
+        (CoreIPC::Connection::sendSync):
+        (CoreIPC::Connection::send):
+
+2011-01-19  Anders Carlsson  <andersca at apple.com>
+
         Reviewed by Sam Weinig.
 
         When resizing, the web process should repaint the page
diff --git a/Source/WebKit2/Platform/CoreIPC/Connection.h b/Source/WebKit2/Platform/CoreIPC/Connection.h
index b7e5b0f..c4ec478 100644
--- a/Source/WebKit2/Platform/CoreIPC/Connection.h
+++ b/Source/WebKit2/Platform/CoreIPC/Connection.h
@@ -115,23 +115,21 @@ public:
     void invalidate();
     void markCurrentlyDispatchedMessageAsInvalid();
 
-    // FIXME: This variant of send is deprecated, all clients should move to the overload that takes a message.
-    template<typename E, typename T> bool send(E messageID, uint64_t destinationID, const T& arguments);
-
-    template<typename T> bool send(const T& message, uint64_t destinationID);
-
     static const unsigned long long NoTimeout = 10000000000ULL;
-    // FIXME: This variant of sendSync is deprecated, all clients should move to the overload that takes a message.
-    template<typename E, typename T, typename U> bool sendSync(E messageID, uint64_t destinationID, const T& arguments, const U& reply, double timeout = NoTimeout);
 
+    template<typename T> bool send(const T& message, uint64_t destinationID);
     template<typename T> bool sendSync(const T& message, const typename T::Reply& reply, uint64_t destinationID, double timeout = NoTimeout);
     
-    template<typename E> PassOwnPtr<ArgumentDecoder> waitFor(E messageID, uint64_t destinationID, double timeout);
-
     PassOwnPtr<ArgumentEncoder> createSyncMessageArgumentEncoder(uint64_t destinationID, uint64_t& syncRequestID);
     bool sendMessage(MessageID, PassOwnPtr<ArgumentEncoder>);
     bool sendSyncReply(PassOwnPtr<ArgumentEncoder>);
 
+    // FIXME: These variants of senc, sendSync and waitFor are all deprecated.
+    // All clients should move to the overloads that take a message type.
+    template<typename E, typename T> bool send(E messageID, uint64_t destinationID, const T& arguments);
+    template<typename E, typename T, typename U> bool sendSync(E messageID, uint64_t destinationID, const T& arguments, const U& reply, double timeout = NoTimeout);
+    template<typename E> PassOwnPtr<ArgumentDecoder> waitFor(E messageID, uint64_t destinationID, double timeout);
+    
 private:
     template<typename T> class Message {
     public:
@@ -300,15 +298,6 @@ private:
 #endif
 };
 
-template<typename E, typename T>
-bool Connection::send(E messageID, uint64_t destinationID, const T& arguments)
-{
-    OwnPtr<ArgumentEncoder> argumentEncoder = ArgumentEncoder::create(destinationID);
-    argumentEncoder->encode(arguments);
-
-    return sendMessage(MessageID(messageID), argumentEncoder.release());
-}
-
 template<typename T> bool Connection::send(const T& message, uint64_t destinationID)
 {
     OwnPtr<ArgumentEncoder> argumentEncoder = ArgumentEncoder::create(destinationID);
@@ -317,6 +306,25 @@ template<typename T> bool Connection::send(const T& message, uint64_t destinatio
     return sendMessage(MessageID(T::messageID), argumentEncoder.release());
 }
 
+template<typename T> bool Connection::sendSync(const T& message, const typename T::Reply& reply, uint64_t destinationID, double timeout)
+{
+    uint64_t syncRequestID = 0;
+    OwnPtr<ArgumentEncoder> argumentEncoder = createSyncMessageArgumentEncoder(destinationID, syncRequestID);
+    
+    // Encode the rest of the input arguments.
+    argumentEncoder->encode(message);
+
+    // Now send the message and wait for a reply.
+    OwnPtr<ArgumentDecoder> replyDecoder = sendSyncMessage(MessageID(T::messageID, MessageID::SyncMessage), syncRequestID, argumentEncoder.release(), timeout);
+    if (!replyDecoder)
+        return false;
+
+    // Decode the reply.
+    return replyDecoder->decode(const_cast<typename T::Reply&>(reply));
+}
+
+// These three member functions are all deprecated.
+
 template<typename E, typename T, typename U>
 inline bool Connection::sendSync(E messageID, uint64_t destinationID, const T& arguments, const U& reply, double timeout)
 {
@@ -335,21 +343,13 @@ inline bool Connection::sendSync(E messageID, uint64_t destinationID, const T& a
     return replyDecoder->decode(const_cast<U&>(reply));
 }
 
-template<typename T> bool Connection::sendSync(const T& message, const typename T::Reply& reply, uint64_t destinationID, double timeout)
+template<typename E, typename T>
+bool Connection::send(E messageID, uint64_t destinationID, const T& arguments)
 {
-    uint64_t syncRequestID = 0;
-    OwnPtr<ArgumentEncoder> argumentEncoder = createSyncMessageArgumentEncoder(destinationID, syncRequestID);
-    
-    // Encode the rest of the input arguments.
-    argumentEncoder->encode(message);
-
-    // Now send the message and wait for a reply.
-    OwnPtr<ArgumentDecoder> replyDecoder = sendSyncMessage(MessageID(T::messageID, MessageID::SyncMessage), syncRequestID, argumentEncoder.release(), timeout);
-    if (!replyDecoder)
-        return false;
+    OwnPtr<ArgumentEncoder> argumentEncoder = ArgumentEncoder::create(destinationID);
+    argumentEncoder->encode(arguments);
 
-    // Decode the reply.
-    return replyDecoder->decode(const_cast<typename T::Reply&>(reply));
+    return sendMessage(MessageID(messageID), argumentEncoder.release());
 }
 
 template<typename E> inline PassOwnPtr<ArgumentDecoder> Connection::waitFor(E messageID, uint64_t destinationID, double timeout)

-- 
WebKit Debian packaging