Plumb network stack information about existence of cached copy

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 222 matching lines @@
 
 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \
   IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 3, 0, (type1, type2, type3), ())
 
 #define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \
   IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 4, 0, (type1, type2, type3, type4), ())
 
 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \
   IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 5, 0, (type1, type2, type3, type4, type5), ())
 
+#define IPC_MESSAGE_CONTROL6(msg_class, type1, type2, type3, type4, type5, type6) \
+  IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 6, 0, (type1, type2, type3, type4, type5, type6), ())
+
 #define IPC_MESSAGE_ROUTED0(msg_class) \
   IPC_MESSAGE_DECL(EMPTY, ROUTED, msg_class, 0, 0, (), ())
 
 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \
   IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 1, 0, (type1), ())
 
 #define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \
   IPC_MESSAGE_DECL(ASYNC, ROUTED, msg_class, 2, 0, (type1, type2), ())
 
 #define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \
@@ skipping 289 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 276 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_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_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_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
@@ skipping 130 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