Changeset 132169 in webkit

Timestamp:

Oct 22, 2012 5:58:14 PM (12 years ago)

Author:

andersca@apple.com

Message:

Handle ArgumentCoder template specializations that take the ArgumentEncoder as a reference
​https://bugs.webkit.org/show_bug.cgi?id=100056

Reviewed by Andreas Kling.

Use template magic to make it possible to have ArgumentCoder specializations where the encode
function takes the ArgumentEncoder object as a reference instead of as a pointer. Also, add an
operator<< to ArgumentEncoder and change the string related ArgumentCoder specializations over to taking
the encoder as a reference and using stream operators.

• Platform/CoreIPC/ArgumentCoders.cpp:

(CoreIPC::::encode):

• Platform/CoreIPC/ArgumentCoders.h:
• Platform/CoreIPC/ArgumentEncoder.h:

(ArgumentEncoder):
(UsesDeprecatedEncodeFunction):
(NoType):
(CoreIPC::ArgumentEncoder::encode):
(CoreIPC::ArgumentEncoder::operator<<):

Location:

trunk/Source/WebKit2

Files:

• ChangeLog (modified) (1 diff)
• Platform/CoreIPC/ArgumentCoders.cpp (modified) (4 diffs)
• Platform/CoreIPC/ArgumentCoders.h (modified) (1 diff)
• Platform/CoreIPC/ArgumentEncoder.h (modified) (1 diff)

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2012-10-22  Anders Carlsson  <andersca@apple.com>
+
+        Handle ArgumentCoder template specializations that take the ArgumentEncoder as a reference
+        https://bugs.webkit.org/show_bug.cgi?id=100056
+
+        Reviewed by Andreas Kling.
+
+        Use template magic to make it possible to have ArgumentCoder specializations where the encode
+        function takes the ArgumentEncoder object as a reference instead of as a pointer. Also, add an
+        operator<< to ArgumentEncoder and change the string related ArgumentCoder specializations over to taking
+        the encoder as a reference and using stream operators.
+
+        * Platform/CoreIPC/ArgumentCoders.cpp:
+        (CoreIPC::::encode):
+        * Platform/CoreIPC/ArgumentCoders.h:
+        * Platform/CoreIPC/ArgumentEncoder.h:
+        (ArgumentEncoder):
+        (UsesDeprecatedEncodeFunction):
+        (NoType):
+        (CoreIPC::ArgumentEncoder::encode):
+        (CoreIPC::ArgumentEncoder::operator<<):
+
 2012-10-22  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebKit2/Platform/CoreIPC/ArgumentCoders.cpp

@@ -27 +27 @@
 #include "ArgumentCoders.h"
 
+#include "DataReference.h"
 #include <wtf/text/CString.h>
 #include <wtf/text/WTFString.h>
@@ -32 +33 @@
 namespace CoreIPC {
 
-void ArgumentCoder<AtomicString>::encode(ArgumentEncoder* encoder, const AtomicString& atomicString)
+void ArgumentCoder<AtomicString>::encode(ArgumentEncoder& encoder, const AtomicString& atomicString)
 {
-    encoder->encode(atomicString.string());
+    encoder << atomicString.string();
 }
 
@@ -47 +48 @@
 }
 
-void ArgumentCoder<CString>::encode(ArgumentEncoder* encoder, const CString& string)
+void ArgumentCoder<CString>::encode(ArgumentEncoder& encoder, const CString& string)
 {
     // Special case the null string.
     if (string.isNull()) {
-        encoder->encode(std::numeric_limits<uint32_t>::max());
+        encoder << std::numeric_limits<uint32_t>::max();
         return;
     }
 
     uint32_t length = string.length();
-    encoder->encode(length);
-    encoder->encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
+    encoder << length << CoreIPC::DataReference(reinterpret_cast<const uint8_t*>(string.data()), length);
 }
 
@@ -88 +88 @@
 
 
-void ArgumentCoder<String>::encode(ArgumentEncoder* encoder, const String& string)
+void ArgumentCoder<String>::encode(ArgumentEncoder& encoder, const String& string)
 {
     // Special case the null string.
     if (string.isNull()) {
-        encoder->encode(std::numeric_limits<uint32_t>::max());
+        encoder << std::numeric_limits<uint32_t>::max();
         return;
     }
 
     uint32_t length = string.length();
-    encoder->encode(length);
     bool is8Bit = string.is8Bit();
-    encoder->encode(is8Bit);
+
+    encoder << length << is8Bit;
+
     if (is8Bit)
-        encoder->encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar), __alignof(LChar));
+        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar), __alignof(LChar));
     else
-        encoder->encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar), __alignof(UChar));
+        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar), __alignof(UChar));
 }
 

trunk/Source/WebKit2/Platform/CoreIPC/ArgumentCoders.h

@@ -198 +198 @@
 
 template<> struct ArgumentCoder<AtomicString> {
-    static void encode(ArgumentEncoder*, const AtomicString&);
+    static void encode(ArgumentEncoder&, const AtomicString&);
     static bool decode(ArgumentDecoder*, AtomicString&);
 };
 
 template<> struct ArgumentCoder<CString> {
-    static void encode(ArgumentEncoder*, const CString&);
+    static void encode(ArgumentEncoder&, const CString&);
     static bool decode(ArgumentDecoder*, CString&);
 };
 
 template<> struct ArgumentCoder<String> {
-    static void encode(ArgumentEncoder*, const String&);
+    static void encode(ArgumentEncoder&, const String&);
     static bool decode(ArgumentDecoder*, String&);
 };

trunk/Source/WebKit2/Platform/CoreIPC/ArgumentEncoder.h

@@ -61 +61 @@
         encode(static_cast<uint64_t>(t));
     }
+
+    template<bool B, typename T = void>
+    struct EnableIf { };
+
+    template<typename T>
+    struct EnableIf<true, T> { typedef T Type; };
     
-    // Generic type encode function.
-    template<typename T> void encode(const T& t)
+    template<typename T> class UsesDeprecatedEncodeFunction {
+        typedef char YesType;
+        struct NoType {
+            char padding[8];
+        };
+
+        static YesType checkEncode(void (*)(ArgumentEncoder*, const T&));
+        static NoType checkEncode(...);
+
+    public:
+        static const bool value = sizeof(checkEncode(ArgumentCoder<T>::encode)) == sizeof(YesType);
+    };
+
+    // FIXME: This is the function that gets chosen if the argument coder takes the ArgumentEncoder as a pointer.
+    // This is the deprecated form - get rid of it.
+    template<typename T> void encode(const T& t, typename EnableIf<UsesDeprecatedEncodeFunction<T>::value>::Type* = 0)
     {
         ArgumentCoder<T>::encode(this, t);
+    }
+
+    template<typename T> void encode(const T& t, typename EnableIf<!UsesDeprecatedEncodeFunction<T>::value>::Type* = 0)
+    {
+        ArgumentCoder<T>::encode(*this, t);
+    }
+
+    template<typename T> ArgumentEncoder& operator<<(const T& t)
+    {
+        encode(t);
+        return *this;
     }