Update the static_cast style check to check for DEFINE_TYPE_CASTS patterns as well.

Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2011 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 282 matching lines @@
         return self.perform_lint(code, 'test.cpp', basic_error_rules)
 
     # Only include what you use errors.
     def perform_include_what_you_use(self, code, filename='foo.h', fs=None):
         basic_error_rules = ('-',
                              '+build/include_what_you_use')
         return self.perform_lint(code, filename, basic_error_rules, fs)
 
     def perform_avoid_static_cast_of_objects(self, code, filename='foo.cpp', fs=None):
         basic_error_rules = ('-',
+                             '+security/casting',
                              '+runtime/casting')
         return self.perform_lint(code, filename, basic_error_rules, fs)
 
     # Perform lint and compare the error message with "expected_message".
     def assert_lint(self, code, expected_message, file_name='foo.cpp'):
         self.assertEqual(expected_message, self.perform_single_line_lint(code, file_name))
 
     def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'):
         messages = self.perform_single_line_lint(code, file_name)
         for message in messages:
@@ skipping 438 matching lines @@
         statement = 'int* x = dynamic_cast<int*>(&foo);'
         error_message = (
             'Do not use dynamic_cast<>.  If you need to cast within a class '
             'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '
             'RTTI.  [runtime/rtti] [5]')
         # dynamic_cast is disallowed in most files.
         self.assert_language_rules_check('foo.cpp', statement, error_message)
         self.assert_language_rules_check('foo.h', statement, error_message)
 
     # Tests for static_cast readability.
+    # FIXME: Add cases for testing the DEFINE_TYPE_CASTS usecases also.
     def test_static_cast_on_objects_with_toFoo(self):
         mock_header_contents = ['inline Foo* toFoo(Bar* bar)']
         fs = FileSystem()
         orig_read_text_file_fn = fs.read_text_file
 
         def mock_read_text_file_fn(path):
             return mock_header_contents
 
         try:
             fs.read_text_file = mock_read_text_file_fn
             message = self.perform_avoid_static_cast_of_objects(
                 'Foo* x = static_cast<Foo*>(bar);',
                 filename='casting.cpp',
                 fs=fs)
             self.assertEqual(message, 'static_cast of class objects is not allowed. Use toFoo defined in Foo.h.'
-                                      '  [runtime/casting] [4]')
+                                      '  [security/casting] [4]')
         finally:
             fs.read_text_file = orig_read_text_file_fn
 
     def test_static_cast_on_objects_without_toFoo(self):
         mock_header_contents = ['inline FooBar* toFooBar(Bar* bar)']
         fs = FileSystem()
         orig_read_text_file_fn = fs.read_text_file
 
         def mock_read_text_file_fn(path):
             return mock_header_contents
 
         try:
             fs.read_text_file = mock_read_text_file_fn
             message = self.perform_avoid_static_cast_of_objects(
                 'Foo* x = static_cast<Foo*>(bar);',
                 filename='casting.cpp',
                 fs=fs)
-            self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.'
+            self.assertEqual(message, 'static_cast of class objects is not allowed. Define cast macro DEFINE_TYPE_CASTS(Foo) in Foo.h and use it.'
                                       '  [runtime/casting] [4]')
         finally:
             fs.read_text_file = orig_read_text_file_fn
 
     # We cannot test this functionality because of difference of
     # function definitions.  Anyway, we may never enable this.
     #
     # # Test for unnamed arguments in a method.
     # def test_check_for_unnamed_params(self):
     #   message = ('All parameters should be named in a function'
@@ skipping 4380 matching lines @@
     def test_ne(self):
         """Test __ne__ inequality function."""
         checker1 = self._checker()
         checker2 = self._checker()
 
         # != calls __ne__.
         # By default, __ne__ always returns true on different objects.
         # Thus, just check the distinguishing case to verify that the
         # code defines __ne__.
         self.assertFalse(checker1 != checker2)