[SCM] WebKit Debian packaging branch, debian/experimental, updated. upstream/1.3.3-9427-gc2be6fc

andersca at apple.com andersca at apple.com
Wed Dec 22 14:20:41 UTC 2010


The following commit has been merged in the debian/experimental branch:
commit ad26f41c29f4f14f53ea677cdfef48ebaba640da
Author: andersca at apple.com <andersca at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date:   Wed Oct 6 22:15:38 2010 +0000

    More Arguments.h cleanup.
    
    Reviewed by Sam Weinig.
    
    * Platform/CoreIPC/Arguments.h:
    * Platform/CoreIPC/HandleMessage.h:
    Remove unnecessary typedefs, simplify.
    
    * Scripts/webkit2/messages.py:
    * UIProcess/WebContext.h:
    Fix clang++ build.
    
    git-svn-id: http://svn.webkit.org/repository/webkit/trunk@69240 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/WebKit2/ChangeLog b/WebKit2/ChangeLog
index 3019d92..8e63b36 100644
--- a/WebKit2/ChangeLog
+++ b/WebKit2/ChangeLog
@@ -2,6 +2,20 @@
 
         Reviewed by Sam Weinig.
 
+        More Arguments.h cleanup.
+
+        * Platform/CoreIPC/Arguments.h:
+        * Platform/CoreIPC/HandleMessage.h:
+        Remove unnecessary typedefs, simplify.
+
+        * Scripts/webkit2/messages.py:
+        * UIProcess/WebContext.h:
+        Fix clang++ build.
+
+2010-10-06  Anders Carlsson  <andersca at apple.com>
+
+        Reviewed by Sam Weinig.
+
         Start cleaning up Arguments.h
         https://bugs.webkit.org/show_bug.cgi?id=47304
 
diff --git a/WebKit2/Platform/CoreIPC/Arguments.h b/WebKit2/Platform/CoreIPC/Arguments.h
index ecc803d..43a5afc 100644
--- a/WebKit2/Platform/CoreIPC/Arguments.h
+++ b/WebKit2/Platform/CoreIPC/Arguments.h
@@ -89,21 +89,24 @@ template<typename T1> Arguments1<T1&> Out(T1& t1)
     return Arguments1<T1&>(t1);
 }
 
-template<typename T1, typename T2> class Arguments2 : Arguments1<T1> {
-public:
-    typedef T1 FirstArgumentType;
-    typedef T2 SecondArgumentType;
+template<typename T1, typename T2> struct Arguments2 : Arguments1<T1> {
+    typedef Arguments2<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type> ValueType;
+
+    Arguments2() 
+    {
+    }
 
     Arguments2(T1 t1, T2 t2) 
         : Arguments1<T1>(t1)
-        , m_value(t2)
+        , argument2(t2)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const 
     {
         Arguments1<T1>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument2);
     }
 
     static bool decode(ArgumentDecoder* decoder, Arguments2& result)
@@ -111,11 +114,10 @@ public:
         if (!Arguments1<T1>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument2);
     }
 
-private:
-    T2 m_value;
+    T2 argument2;
 };
 
 template<typename T1, typename T2> Arguments2<const T1&, const T2&> In(const T1& t1, const T2& t2)
@@ -128,22 +130,25 @@ template<typename T1, typename T2> Arguments2<T1&, T2&> Out(T1& t1, T2& t2)
     return Arguments2<T1&, T2&>(t1, t2);
 }
 
-template<typename T1, typename T2, typename T3> class Arguments3 : Arguments2<T1, T2> {
-public:
-    typedef T1 FirstArgumentType;
-    typedef T2 SecondArgumentType;
-    typedef T3 ThirdArgumentType;
+template<typename T1, typename T2, typename T3> struct Arguments3 : Arguments2<T1, T2> {
+    typedef Arguments3<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type> ValueType;
+
+    Arguments3()
+    {
+    }
 
     Arguments3(T1 t1, T2 t2, T3 t3) 
         : Arguments2<T1, T2>(t1, t2)
-        , m_value(t3)
+        , argument3(t3)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const 
     {
         Arguments2<T1, T2>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument3);
     }
 
     static bool decode(ArgumentDecoder* decoder, Arguments3& result)
@@ -151,11 +156,10 @@ public:
         if (!Arguments2<T1, T2>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument3);
     }
 
-private:
-    T3 m_value;
+    T3 argument3;
 };
 
 template<typename T1, typename T2, typename T3> Arguments3<const T1&, const T2&, const T3&> In(const T1& t1, const T2& t2, const T3 &t3)
@@ -168,23 +172,26 @@ template<typename T1, typename T2, typename T3> Arguments3<T1&, T2&, T3&> Out(T1
     return Arguments3<T1&, T2&, T3&>(t1, t2, t3);
 }
 
-template<typename T1, typename T2, typename T3, typename T4> class Arguments4 : Arguments3<T1, T2, T3> {
-public:
-    typedef T1 FirstArgumentType;
-    typedef T2 SecondArgumentType;
-    typedef T3 ThirdArgumentType;
-    typedef T4 FourthArgumentType;
-    
+template<typename T1, typename T2, typename T3, typename T4> struct Arguments4 : Arguments3<T1, T2, T3> {
+    typedef Arguments4<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type> ValueType;
+
+    Arguments4()
+    {
+    }
+
     Arguments4(T1 t1, T2 t2, T3 t3, T4 t4)
         : Arguments3<T1, T2, T3>(t1, t2, t3)
-        , m_value(t4)
+        , argument4(t4)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const
     {
         Arguments3<T1, T2, T3>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument4);
     }
     
     static bool decode(ArgumentDecoder* decoder, Arguments4& result)
@@ -192,11 +199,10 @@ public:
         if (!Arguments3<T1, T2, T3>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument4);
     }
 
-private:
-    T4 m_value;
+    T4 argument4;
 };
 
 template<typename T1, typename T2, typename T3, typename T4> Arguments4<const T1&, const T2&, const T3&, const T4&> In(const T1& t1, const T2& t2, const T3 &t3, const T4& t4)
@@ -209,18 +215,27 @@ template<typename T1, typename T2, typename T3, typename T4> Arguments4<T1&, T2&
     return Arguments4<T1&, T2&, T3&, T4&>(t1, t2, t3, t4);
 }
 
-template<typename T1, typename T2, typename T3, typename T4, typename T5> class Arguments5 : Arguments4<T1, T2, T3, T4> {
-public:
+template<typename T1, typename T2, typename T3, typename T4, typename T5> struct Arguments5 : Arguments4<T1, T2, T3, T4> {
+    typedef Arguments5<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type> ValueType;
+
+    Arguments5()
+    {
+    }
+
     Arguments5(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
         : Arguments4<T1, T2, T3, T4>(t1, t2, t3, t4)
-        , m_value(t5)
+        , argument5(t5)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const
     {
         Arguments4<T1, T2, T3, T4>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument5);
     }
     
     static bool decode(ArgumentDecoder* decoder, Arguments5& result)
@@ -228,11 +243,10 @@ public:
         if (!Arguments4<T1, T2, T3, T4>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument5);
     }
 
-private:
-    T5 m_value;
+    T5 argument5;
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5> Arguments5<const T1&, const T2&, const T3&, const T4&, const T5&> In(const T1& t1, const T2& t2, const T3 &t3, const T4& t4, const T5& t5)
@@ -245,25 +259,28 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5> Argume
     return Arguments5<T1&, T2&, T3&, T4&, T5&>(t1, t2, t3, t4, t5);
 }
 
-template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> class Arguments6 : Arguments5<T1, T2, T3, T4, T5> {
-public:
-    typedef T1 FirstArgumentType;
-    typedef T2 SecondArgumentType;
-    typedef T3 ThirdArgumentType;
-    typedef T4 FourthArgumentType;
-    typedef T5 FifthArgumentType;
-    typedef T6 SixthArgumentType;
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> struct Arguments6 : Arguments5<T1, T2, T3, T4, T5> {
+    typedef Arguments6<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type> ValueType;
+
+    Arguments6()
+    {
+    }
 
     Arguments6(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
         : Arguments5<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5)
-        , m_value(t6)
+        , argument6(t6)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const
     {
         Arguments5<T1, T2, T3, T4, T5>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument6);
     }
     
     static bool decode(ArgumentDecoder* decoder, Arguments6& result)
@@ -271,11 +288,10 @@ public:
         if (!Arguments5<T1, T2, T3, T4, T5>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument6);
     }
 
-private:
-    T6 m_value;
+    T6 argument6;
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> Arguments6<const T1&, const T2&, const T3&, const T4&, const T5&, const T6&> In(const T1& t1, const T2& t2, const T3 &t3, const T4& t4, const T5& t5, const T6& t6)
@@ -288,26 +304,29 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
     return Arguments6<T1&, T2&, T3&, T4&, T5&, T6&>(t1, t2, t3, t4, t5, t6);
 }
 
-template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> class Arguments7 : Arguments6<T1, T2, T3, T4, T5, T6> {
-public:
-    typedef T1 FirstArgumentType;
-    typedef T2 SecondArgumentType;
-    typedef T3 ThirdArgumentType;
-    typedef T4 FourthArgumentType;
-    typedef T5 FifthArgumentType;
-    typedef T6 SixthArgumentType;
-    typedef T7 SeventhArgumentType;
-    
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> struct Arguments7 : Arguments6<T1, T2, T3, T4, T5, T6> {
+    typedef Arguments7<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type,
+                       typename WTF::RemoveConst<typename WTF::RemoveReference<T7>::Type>::Type> ValueType;
+
+    Arguments7()
+    {
+    }
+
     Arguments7(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
         : Arguments6<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6)
-        , m_value(t7)
+        , argument7(t7)
     {
     }
 
     void encode(ArgumentEncoder* encoder) const
     {
         Arguments6<T1, T2, T3, T4, T5, T6>::encode(encoder);
-        encoder->encode(m_value);
+        encoder->encode(argument7);
     }
     
     static bool decode(ArgumentDecoder* decoder, Arguments7& result)
@@ -315,11 +334,10 @@ public:
         if (!Arguments6<T1, T2, T3, T4, T5, T6>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.m_value);
+        return decoder->decode(result.argument7);
     }
 
-private:
-    T7 m_value;
+    T7 argument7;
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> Arguments7<const T1&, const T2&, const T3&, const T4&, const T5&, const T6&, const T7&> In(const T1& t1, const T2& t2, const T3 &t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
diff --git a/WebKit2/Platform/CoreIPC/HandleMessage.h b/WebKit2/Platform/CoreIPC/HandleMessage.h
index 33627ac..69e0790 100644
--- a/WebKit2/Platform/CoreIPC/HandleMessage.h
+++ b/WebKit2/Platform/CoreIPC/HandleMessage.h
@@ -24,79 +24,37 @@ void handleMessage(ArgumentDecoder* argumentDecoder, C* object, void (C::*functi
 template<typename T, typename C, typename P1, typename P2>
 void handleMessage(ArgumentDecoder* argumentDecoder, C* object, void (C::*function)(P1, P2))
 {
-    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
-    if (!argumentDecoder->decode(firstArgument))
-        return;
-    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
-    if (!argumentDecoder->decode(secondArgument))
+    typename T::ValueType arguments;
+    if (!argumentDecoder->decode(arguments))
         return;
-    (object->*function)(firstArgument, secondArgument);
+    (object->*function)(arguments.argument1, arguments.argument2);
 }
 
 template<typename T, typename C, typename P1, typename P2, typename P3>
 void handleMessage(ArgumentDecoder* argumentDecoder, C* object, void (C::*function)(P1, P2, P3))
 {
-    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
-    if (!argumentDecoder->decode(firstArgument))
-        return;
-    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
-    if (!argumentDecoder->decode(secondArgument))
-        return;
-    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
-    if (!argumentDecoder->decode(thirdArgument))
+    typename T::ValueType arguments;
+    if (!argumentDecoder->decode(arguments))
         return;
-    (object->*function)(firstArgument, secondArgument, thirdArgument);
+    (object->*function)(arguments.argument1, arguments.argument2, arguments.argument3);
 }
 
 template<typename T, typename C, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
 void handleMessage(ArgumentDecoder* argumentDecoder, C* object, void (C::*function)(P1, P2, P3, P4, P5, P6))
 {
-    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
-    if (!argumentDecoder->decode(firstArgument))
-        return;
-    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
-    if (!argumentDecoder->decode(secondArgument))
-        return;
-    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
-    if (!argumentDecoder->decode(thirdArgument))
-        return;
-    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
-    if (!argumentDecoder->decode(fourthArgument))
-        return;
-    typename RemoveReference<typename T::FifthArgumentType>::Type fifthArgument;
-    if (!argumentDecoder->decode(fifthArgument))
-        return;
-    typename RemoveReference<typename T::SixthArgumentType>::Type sixthArgument;
-    if (!argumentDecoder->decode(sixthArgument))
+    typename T::ValueType arguments;
+    if (!argumentDecoder->decode(arguments))
         return;
-    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument, fifthArgument, sixthArgument);
+    (object->*function)(arguments.argument1, arguments.argument2, arguments.argument3, arguments.argument4, arguments.argument5, arguments.argument6);
 }
 
 template<typename T, typename C, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
 void handleMessage(ArgumentDecoder* argumentDecoder, C* object, void (C::*function)(P1, P2, P3, P4, P5, P6, P7))
 {
-    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
-    if (!argumentDecoder->decode(firstArgument))
-        return;
-    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
-    if (!argumentDecoder->decode(secondArgument))
-        return;
-    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
-    if (!argumentDecoder->decode(thirdArgument))
-        return;
-    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
-    if (!argumentDecoder->decode(fourthArgument))
-        return;
-    typename RemoveReference<typename T::FifthArgumentType>::Type fifthArgument;
-    if (!argumentDecoder->decode(fifthArgument))
-        return;
-    typename RemoveReference<typename T::SixthArgumentType>::Type sixthArgument;
-    if (!argumentDecoder->decode(sixthArgument))
-        return;
-    typename RemoveReference<typename T::SeventhArgumentType>::Type seventhArgument;
-    if (!argumentDecoder->decode(seventhArgument))
+    typename T::ValueType arguments;
+    if (!argumentDecoder->decode(arguments))
         return;
-    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument, fifthArgument, sixthArgument, seventhArgument);
+    (object->*function)(arguments.argument1, arguments.argument2, arguments.argument3, arguments.argument4, arguments.argument5, arguments.argument6, arguments.argument7);
 }
 
 template<typename T, typename C, typename P1>
@@ -144,24 +102,12 @@ void handleMessage(ArgumentDecoder* argumentDecoder, ArgumentEncoder* replyEncod
 template<typename T, typename C, typename P1, typename P2, typename P3, typename P4, typename R1>
 void handleMessage(ArgumentDecoder* argumentDecoder, ArgumentEncoder* replyEncoder, C* object, void (C::*function)(P1, P2, P3, P4, R1&))
 {
-    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
-    if (!argumentDecoder->decode(firstArgument))
-        return;
-
-    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
-    if (!argumentDecoder->decode(secondArgument))
+    typename T::ValueType arguments;
+    if (!argumentDecoder->decode(arguments))
         return;
     
-    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
-    if (!argumentDecoder->decode(thirdArgument))
-        return;
-
-    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
-    if (!argumentDecoder->decode(fourthArgument))
-        return;
-
     typename RemoveReference<typename T::Reply::FirstArgumentType>::Type firstReplyArgument;
-    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument, firstReplyArgument);
+    (object->*function)(arguments.argument1, arguments.argument2, arguments.argument3, arguments.argument4, firstReplyArgument);
     replyEncoder->encode(firstReplyArgument);
 }
 
diff --git a/WebKit2/Scripts/webkit2/messages.py b/WebKit2/Scripts/webkit2/messages.py
index 6f2d263..25d5434 100644
--- a/WebKit2/Scripts/webkit2/messages.py
+++ b/WebKit2/Scripts/webkit2/messages.py
@@ -200,7 +200,9 @@ def message_to_struct_declaration(message):
 
 def struct_or_class(namespace, type):
     structs = frozenset([
+        'WebKit::WebPageCreationParameters',
         'WebKit::WebPreferencesStore',
+        'WebKit::WebProcessCreationParameters',
     ])
 
     qualified_name = '%s::%s' % (namespace, type)
diff --git a/WebKit2/UIProcess/WebContext.h b/WebKit2/UIProcess/WebContext.h
index 369e333..435825e 100644
--- a/WebKit2/UIProcess/WebContext.h
+++ b/WebKit2/UIProcess/WebContext.h
@@ -48,7 +48,7 @@ namespace WebKit {
 class WebPageNamespace;
 class WebPageProxy;
 class WebPreferences;
-class WebProcessCreationParameters;
+struct WebProcessCreationParameters;
 
 class WebContext : public APIObject {
 public:

-- 
WebKit Debian packaging



More information about the Pkg-webkit-commits mailing list