Add code style check error for using static_cast instead of toFoo function.

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 292 matching lines @@
                              '+runtime/leaky_pattern')
         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', io=codecs):
         basic_error_rules = ('-',
                              '+build/include_what_you_use')
         unit_test_config = {cpp_style.INCLUDE_IO_INJECTION_KEY: io}
         return self.perform_lint(code, filename, basic_error_rules, unit_test_config)
 
+    def perform_avoid_static_cast_of_objects(self, code, filename='foo.cpp', io=codecs):
+        basic_error_rules = ('-',
+                             '+runtime/casting')
+        unit_test_config = {cpp_style.INCLUDE_IO_INJECTION_KEY: io}
+        return self.perform_lint(code, filename, basic_error_rules, unit_test_config)
+
     # 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:
             if re.search(expected_message_re, message):
                 return
 
@@ skipping 434 matching lines @@
     def test_runtime_rtti(self):
         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)
 
-    # Test for static_cast readability.
-    def test_static_cast_readability(self):
-        self.assert_lint(
-            'Text* x = static_cast<Text*>(foo);',
-            'Consider using toText helper function in WebCore/dom/Text.h '
-            'instead of static_cast<Text*>'
-            '  [readability/check] [4]')
+    # Tests for static_cast readability.
+    def test_static_cast_on_objects_with_toFoo(self):
+        mock_header_contents = ['inline Foo* toFoo(Bar* bar)']
+        message = self.perform_avoid_static_cast_of_objects(
+            'Foo* x = static_cast<Foo*>(bar);',
+            filename='casting.cpp',
+            io=MockIo(mock_header_contents))
+        self.assertEqual(message, 'static_cast of class objects is not allowed. Use toFoo defined in Foo.h.'
+                                  '  [runtime/casting] [4]')
+
+    def test_static_cast_on_objects_without_toFoo(self):
+        mock_header_contents = ['inline FooBar* toFooBar(Bar* bar)']
+        message = self.perform_avoid_static_cast_of_objects(
+            'Foo* x = static_cast<Foo*>(bar);',
+            filename='casting.cpp',
+            io=MockIo(mock_header_contents))
+        self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.'
+                                  '  [runtime/casting] [4]')
 
     # 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'
     #              '  [readability/function] [3]')
     #   self.assert_lint('virtual void A(int*) const;', message)
     #   self.assert_lint('virtual void B(void (*fn)(int*));', message)
@@ skipping 4367 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)