replace COMPILE_ASSERT with static_assert in ppapi/

ppapi/proxy/ppapi_message_utils.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.
 
 #ifndef PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_
 #define PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_
 
 #include "base/basictypes.h"
 #include "base/pickle.h"
 #include "base/tuple.h"
@@ skipping 49 matching lines @@
 };
 template <class A, class B, class C, class D, class E>
 struct TupleTypeMatch5<Tuple<A, B, C, D, E>, A, B, C, D, E> {
   static const bool kValue = true;
 };
 
 }  // namespace internal
 
 template <class MsgClass, class A>
 bool UnpackMessage(const IPC::Message& msg, A* a) {
-  COMPILE_ASSERT(
+  static_assert(
       (internal::TupleTypeMatch1<typename MsgClass::Param, A>::kValue),
-      tuple_types_dont_match);
+      "tuple types should match");
 
   PickleIterator iter(msg);
   return IPC::ReadParam(&msg, &iter, a);
 }
 
 template <class MsgClass, class A, class B>
 bool UnpackMessage(const IPC::Message& msg, A* a, B* b) {
-  COMPILE_ASSERT(
+  static_assert(
       (internal::TupleTypeMatch2<typename MsgClass::Param, A, B>::kValue),
-      tuple_types_dont_match);
+      "tuple types should match");
 
   PickleIterator iter(msg);
   return IPC::ReadParam(&msg, &iter, a) && IPC::ReadParam(&msg, &iter, b);
 }
 
 template <class MsgClass, class A, class B, class C>
 bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c) {
-  COMPILE_ASSERT(
+  static_assert(
       (internal::TupleTypeMatch3<typename MsgClass::Param, A, B, C>::kValue),
-      tuple_types_dont_match);
+      "tuple types should match");
 
   PickleIterator iter(msg);
   return IPC::ReadParam(&msg, &iter, a) &&
          IPC::ReadParam(&msg, &iter, b) &&
          IPC::ReadParam(&msg, &iter, c);
 }
 
 template <class MsgClass, class A, class B, class C, class D>
 bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c, D* d) {
-  COMPILE_ASSERT(
+  static_assert(
       (internal::TupleTypeMatch4<typename MsgClass::Param, A, B, C, D>::kValue),
-      tuple_types_dont_match);
+      "tuple types should match");
 
   PickleIterator iter(msg);
   return IPC::ReadParam(&msg, &iter, a) &&
          IPC::ReadParam(&msg, &iter, b) &&
          IPC::ReadParam(&msg, &iter, c) &&
          IPC::ReadParam(&msg, &iter, d);
 }
 
 template <class MsgClass, class A, class B, class C, class D, class E>
 bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c, D* d, E* e) {
-  COMPILE_ASSERT(
+  static_assert(
       (internal::TupleTypeMatch5<
            typename MsgClass::Param, A, B, C, D, E>::kValue),
-      tuple_types_dont_match);
+      "tuple types should match");
 
   PickleIterator iter(msg);
   return IPC::ReadParam(&msg, &iter, a) &&
          IPC::ReadParam(&msg, &iter, b) &&
          IPC::ReadParam(&msg, &iter, c) &&
          IPC::ReadParam(&msg, &iter, d) &&
          IPC::ReadParam(&msg, &iter, e);
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_