Allow deleting autofill password suggestions on Shift+Delete

ipc/ipc_message_macros.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
@@ skipping 240 matching lines @@
 
 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \
   IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 3, 0, (type1, type2, type3), ())
 
 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \
   IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 4, 0, (type1, type2, type3, type4), ())
 
 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \
   IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 5, 0, (type1, type2, type3, type4, type5), ())
 
+#define IPC_MESSAGE_ROUTED6(msg_class, type1, type2, type3, type4, type5, type6) \
+  IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 6, 0, (type1, type2, type3, type4, type5, type6), ())
+
 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \
   IPC_MESSAGE_DECL(SYNC, CONTROL, msg_class, 0, 0, (), ())
 
 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \
   IPC_MESSAGE_DECL(SYNC, CONTROL, msg_class, 0, 1, (), (type1_out))
 
 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \
   IPC_MESSAGE_DECL(SYNC, CONTROL, msg_class, 0, 2, (), (type1_out, type2_out))
 
 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out) \
@@ skipping 271 matching lines @@
     Schema::Param p;                                                          \
     if (!Read(msg, &p))                                                       \
       return false;                                                           \
     *a = p.a;                                                                 \
     *b = p.b;                                                                 \
     *c = p.c;                                                                 \
     *d = p.d;                                                                 \
     *e = p.e;                                                                 \
     return true;                                                              \
   }
+#define IPC_ASYNC_MESSAGE_METHODS_6                                           \
+  IPC_ASYNC_MESSAGE_METHODS_GENERIC                                           \
+  template<class T, class S, typename TA, typename TB, typename TC,           \
+           typename TD, typename TE, typename TF>                             \
+  static bool Dispatch(const Message* msg, T* obj, S* sender,                 \
+                  void (T::*func)(const Message&, TA, TB, TC, TD, TE, TF)) {  \
+    Schema::Param p;                                                          \
+    if (Read(msg, &p)) {                                                      \
+      (obj->*func)(*msg, p.a, p.b, p.c, p.d, p.e, p.f);                       \
+      return true;                                                            \
+    }                                                                         \
+    return false;                                                             \
+  }                                                                           \
+  template<typename TA, typename TB, typename TC, typename TD, typename TE,    \
+           typename TF>                                                       \
+  static bool Read(const IPC::Message* msg, TA* a, TB* b, TC* c, TD* d,       \
+                   TE* e, TF* f) {                                            \
+    Schema::Param p;                                                          \
+    if (!Read(msg, &p))                                                       \
+      return false;                                                           \
+    *a = p.a;                                                                 \
+    *b = p.b;                                                                 \
+    *c = p.c;                                                                 \
+    *d = p.d;                                                                 \
+    *e = p.e;                                                                 \
+    *f = p.f;                                                                 \
+    return true;                                                              \
+  }
 
 // The following macros define the common set of methods provided by SYNC
 // message classes.
 #define IPC_SYNC_MESSAGE_METHODS_GENERIC                                      \
   template<class T, class S, class Method>                                    \
   static bool Dispatch(const Message* msg, T* obj, S* sender, Method func) {  \
     Schema::SendParam send_params;                                            \
     bool ok = ReadSendParam(msg, &send_params);                               \
     return Schema::DispatchWithSendParams(ok, send_params, msg, obj, sender,  \
                                           func);                              \
@@ skipping 30 matching lines @@
   template<typename TA, typename TB, typename TC, typename TD> \
   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d) { \
     Schema::WriteReplyParams(reply, a, b, c, d); \
   }
 #define IPC_SYNC_MESSAGE_METHODS_5 \
   IPC_SYNC_MESSAGE_METHODS_GENERIC \
   template<typename TA, typename TB, typename TC, typename TD, typename TE> \
   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e) { \
     Schema::WriteReplyParams(reply, a, b, c, d, e); \
   }
+#define IPC_SYNC_MESSAGE_METHODS_6 \
+  IPC_SYNC_MESSAGE_METHODS_GENERIC \
+  template<typename TA, typename TB, typename TC, typename TD, typename TE, typename TF> \
+  static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e, TF f) { \
+    Schema::WriteReplyParams(reply, a, b, c, d, e, f); \
+  }
 
 // Common message macro which dispatches into one of the 6 (sync x kind)
 // routines.  There is a way that these 6 cases can be lumped together,
 // but the  macros get very complicated in that case.
 // Note: intended be redefined to generate other information.
 #define IPC_MESSAGE_DECL(sync, kind, msg_class,                               \
                          in_cnt, out_cnt, in_list, out_list)                  \
   IPC_##sync##_##kind##_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   IPC_MESSAGE_EXTRA(sync, kind, msg_class, in_cnt, out_cnt, in_list, out_list)
 
@@ skipping 226 matching lines @@
 #endif // defined(IPC_MESSAGE_IMPL)
 
 // Handle variable sized argument lists.  These are usually invoked by token
 // pasting against the argument counts.
 #define IPC_TYPE_IN_0()
 #define IPC_TYPE_IN_1(t1)                   const t1& arg1
 #define IPC_TYPE_IN_2(t1, t2)               const t1& arg1, const t2& arg2
 #define IPC_TYPE_IN_3(t1, t2, t3)           const t1& arg1, const t2& arg2, const t3& arg3
 #define IPC_TYPE_IN_4(t1, t2, t3, t4)       const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4
 #define IPC_TYPE_IN_5(t1, t2, t3, t4, t5)   const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4, const t5& arg5
+#define IPC_TYPE_IN_6(t1, t2, t3, t4, t5, t6)   const t1& arg1, const t2& arg2, const t3& arg3, const t4& arg4, const t5& arg5, const t6& arg6
+
 
 #define IPC_TYPE_OUT_0()
 #define IPC_TYPE_OUT_1(t1)                  t1* arg6
 #define IPC_TYPE_OUT_2(t1, t2)              t1* arg6, t2* arg7
 #define IPC_TYPE_OUT_3(t1, t2, t3)          t1* arg6, t2* arg7, t3* arg8
 #define IPC_TYPE_OUT_4(t1, t2, t3, t4)      t1* arg6, t2* arg7, t3* arg8, t4* arg9
 
 #define IPC_TUPLE_IN_0()                    Tuple0
 #define IPC_TUPLE_IN_1(t1)                  Tuple1<t1>
 #define IPC_TUPLE_IN_2(t1, t2)              Tuple2<t1, t2>
 #define IPC_TUPLE_IN_3(t1, t2, t3)          Tuple3<t1, t2, t3>
 #define IPC_TUPLE_IN_4(t1, t2, t3, t4)      Tuple4<t1, t2, t3, t4>
 #define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5)  Tuple5<t1, t2, t3, t4, t5>
+#define IPC_TUPLE_IN_6(t1, t2, t3, t4, t5, t6)  Tuple6<t1, t2, t3, t4, t5, t6>
 
 #define IPC_TUPLE_OUT_0()                   Tuple0
 #define IPC_TUPLE_OUT_1(t1)                 Tuple1<t1&>
 #define IPC_TUPLE_OUT_2(t1, t2)             Tuple2<t1&, t2&>
 #define IPC_TUPLE_OUT_3(t1, t2, t3)         Tuple3<t1&, t2&, t3&>
 #define IPC_TUPLE_OUT_4(t1, t2, t3, t4)     Tuple4<t1&, t2&, t3&, t4&>
 
 #define IPC_NAME_IN_0()                     MakeTuple()
 #define IPC_NAME_IN_1(t1)                   MakeRefTuple(arg1)
 #define IPC_NAME_IN_2(t1, t2)               MakeRefTuple(arg1, arg2)
 #define IPC_NAME_IN_3(t1, t2, t3)           MakeRefTuple(arg1, arg2, arg3)
 #define IPC_NAME_IN_4(t1, t2, t3, t4)       MakeRefTuple(arg1, arg2, arg3, arg4)
 #define IPC_NAME_IN_5(t1, t2, t3, t4, t5)   MakeRefTuple(arg1, arg2, arg3, arg4, arg5)
+#define IPC_NAME_IN_6(t1, t2, t3, t4, t5, t6)   MakeRefTuple(arg1, arg2, arg3, arg4, arg5, arg6)
 
 #define IPC_NAME_OUT_0()                    MakeTuple()
 #define IPC_NAME_OUT_1(t1)                  MakeRefTuple(*arg6)
 #define IPC_NAME_OUT_2(t1, t2)              MakeRefTuple(*arg6, *arg7)
 #define IPC_NAME_OUT_3(t1, t2, t3)          MakeRefTuple(*arg6, *arg7, *arg8)
 #define IPC_NAME_OUT_4(t1, t2, t3, t4)      MakeRefTuple(*arg6, *arg7, *arg8, *arg9)
 
 // There are places where the syntax requires a comma if there are input args,
 // if there are input args and output args, or if there are input args or
 // output args.  These macros allow generation of the comma as needed; invoke
 // by token pasting against the argument counts.
 #define IPC_COMMA_0
 #define IPC_COMMA_1 ,
 #define IPC_COMMA_2 ,
 #define IPC_COMMA_3 ,
 #define IPC_COMMA_4 ,
 #define IPC_COMMA_5 ,
+#define IPC_COMMA_6 ,
 
 #define IPC_COMMA_AND_0(x)
 #define IPC_COMMA_AND_1(x) x
 #define IPC_COMMA_AND_2(x) x
 #define IPC_COMMA_AND_3(x) x
 #define IPC_COMMA_AND_4(x) x
 #define IPC_COMMA_AND_5(x) x
+#define IPC_COMMA_AND_6(x) x
 
 #define IPC_COMMA_OR_0(x) x
 #define IPC_COMMA_OR_1(x) ,
 #define IPC_COMMA_OR_2(x) ,
 #define IPC_COMMA_OR_3(x) ,
 #define IPC_COMMA_OR_4(x) ,
 #define IPC_COMMA_OR_5(x) ,
+#define IPC_COMMA_OR_6(x) ,
 
 // Message IDs
 // Note: we currently use __LINE__ to give unique IDs to messages within
 // a file.  They're globally unique since each file defines its own
 // IPC_MESSAGE_START.
 #define IPC_MESSAGE_ID() ((IPC_MESSAGE_START << 16) + __LINE__)
 #define IPC_MESSAGE_ID_CLASS(id) ((id) >> 16)
 #define IPC_MESSAGE_ID_LINE(id) ((id) & 0xffff)
 
 // Message crackers and handlers.
@@ skipping 99 matching lines @@
 // equivalent without the #ifdef, VS2013 contains a bug where it is
 // over-aggressive in optimizing out #includes.  Putting the #ifdef is a
 // workaround for this bug.  See http://goo.gl/eGt2Fb for more details.
 // This can be removed once VS2013 is fixed.
 #ifdef IPC_MESSAGE_START
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START
 #endif