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.
+    # TODO (kphanee): Add cases for testing the DEFINE_TYPE_CASTS usecases also.

[Dirk Pranke, 2014/01/27 19:38:51]

NIt: s/TODO/FIXME, don't use a username.

[r.kasibhatla, 2014/02/03 15:29:15]

Done.

     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.'

[aarya, 2014/01/27 19:45:56]

nit: do we want to add DEFINE_TYPE_CASTS in message here.

[r.kasibhatla, 2014/02/03 15:29:15]

This usecase is specifically for the error when we already have the toFoo
defined but we are not using it.

Though, for the 2nd usecase, when toFoo is not yet defined, I agree that we
should encourage to define using DEFINE_TYPE_CASTS. But
not sure what exact message would look nice.
Would something like this sounds nice - 
"static_cast of class objects is not allowed. Define cast macro
DEFINE_TYPE_CASTS(Foo) in Foo.h and use it."

[inferno, 2014/02/03 15:44:23]

Yes, this new message is fine.

-                                      '  [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
@@ skipping 4398 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)