replace COMPILE_ASSERT with static_assert in content/

content/browser/renderer_host/websocket_host.cc

 // Copyright 2013 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.
 
 #include "content/browser/renderer_host/websocket_host.h"
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
@@ skipping 22 matching lines @@
 // Convert a content::WebSocketMessageType to a
 // net::WebSocketFrameHeader::OpCode
 net::WebSocketFrameHeader::OpCode MessageTypeToOpCode(
     WebSocketMessageType type) {
   DCHECK(type == WEB_SOCKET_MESSAGE_TYPE_CONTINUATION ||
          type == WEB_SOCKET_MESSAGE_TYPE_TEXT ||
          type == WEB_SOCKET_MESSAGE_TYPE_BINARY);
   typedef net::WebSocketFrameHeader::OpCode OpCode;
   // These compile asserts verify that the same underlying values are used for
   // both types, so we can simply cast between them.
-  COMPILE_ASSERT(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_CONTINUATION) ==
-                     net::WebSocketFrameHeader::kOpCodeContinuation,
-                 enum_values_must_match_for_opcode_continuation);
-  COMPILE_ASSERT(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_TEXT) ==
-                     net::WebSocketFrameHeader::kOpCodeText,
-                 enum_values_must_match_for_opcode_text);
-  COMPILE_ASSERT(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_BINARY) ==
-                     net::WebSocketFrameHeader::kOpCodeBinary,
-                 enum_values_must_match_for_opcode_binary);
+  static_assert(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_CONTINUATION) ==
+                    net::WebSocketFrameHeader::kOpCodeContinuation,
+                "enum values must match for opcode continuation");
+  static_assert(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_TEXT) ==
+                    net::WebSocketFrameHeader::kOpCodeText,
+                "enum values must match for opcode text");
+  static_assert(static_cast<OpCode>(WEB_SOCKET_MESSAGE_TYPE_BINARY) ==
+                    net::WebSocketFrameHeader::kOpCodeBinary,
+                "enum values must match for opcode binary");
   return static_cast<OpCode>(type);
 }
 
 WebSocketMessageType OpCodeToMessageType(
     net::WebSocketFrameHeader::OpCode opCode) {
   DCHECK(opCode == net::WebSocketFrameHeader::kOpCodeContinuation ||
          opCode == net::WebSocketFrameHeader::kOpCodeText ||
          opCode == net::WebSocketFrameHeader::kOpCodeBinary);
-  // This cast is guaranteed valid by the COMPILE_ASSERT() statements above.
+  // This cast is guaranteed valid by the static_assert() statements above.
   return static_cast<WebSocketMessageType>(opCode);
 }
 
 ChannelState StateCast(WebSocketDispatcherHost::WebSocketHostState host_state) {
   const WebSocketDispatcherHost::WebSocketHostState WEBSOCKET_HOST_ALIVE =
       WebSocketDispatcherHost::WEBSOCKET_HOST_ALIVE;
   const WebSocketDispatcherHost::WebSocketHostState WEBSOCKET_HOST_DELETED =
       WebSocketDispatcherHost::WEBSOCKET_HOST_DELETED;
 
   DCHECK(host_state == WEBSOCKET_HOST_ALIVE ||
          host_state == WEBSOCKET_HOST_DELETED);
   // These compile asserts verify that we can get away with using static_cast<>
   // for the conversion.
-  COMPILE_ASSERT(static_cast<ChannelState>(WEBSOCKET_HOST_ALIVE) ==
-                     net::WebSocketEventInterface::CHANNEL_ALIVE,
-                 enum_values_must_match_for_state_alive);
-  COMPILE_ASSERT(static_cast<ChannelState>(WEBSOCKET_HOST_DELETED) ==
-                     net::WebSocketEventInterface::CHANNEL_DELETED,
-                 enum_values_must_match_for_state_deleted);
+  static_assert(static_cast<ChannelState>(WEBSOCKET_HOST_ALIVE) ==
+                    net::WebSocketEventInterface::CHANNEL_ALIVE,
+                "enum values must match for state_alive");
+  static_assert(static_cast<ChannelState>(WEBSOCKET_HOST_DELETED) ==
+                    net::WebSocketEventInterface::CHANNEL_DELETED,
+                "enum values must match for state_deleted");
   return static_cast<ChannelState>(host_state);
 }
 
 // Implementation of net::WebSocketEventInterface. Receives events from our
 // WebSocketChannel object. Each event is translated to an IPC and sent to the
 // renderer or child process via WebSocketDispatcherHost.
 class WebSocketEventHandler : public net::WebSocketEventInterface {
  public:
   WebSocketEventHandler(WebSocketDispatcherHost* dispatcher,
                         int routing_id,
@@ skipping 293 matching lines @@
   DVLOG(3) << "WebSocketHost::OnDropChannel"
            << " routing_id=" << routing_id_ << " was_clean=" << was_clean
            << " code=" << code << " reason=\"" << reason << "\"";
 
   DCHECK(channel_);
   // TODO(yhirano): Handle |was_clean| appropriately.
   channel_->StartClosingHandshake(code, reason);
 }
 
 }  // namespace content