Stop using WebCore namespace in generated code

Source/build/scripts/make_css_property_names.py

 #!/usr/bin/env python
 
 import os.path
 import re
 import subprocess
 import sys
 
 from in_file import InFile
 import in_generator
 import license
 
 
 HEADER_TEMPLATE = """
 %(license)s
 
 #ifndef %(class_name)s_h
 #define %(class_name)s_h
 
 #include "core/css/CSSParserMode.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashTraits.h"
 #include <string.h>
 
 namespace WTF {
 class AtomicString;
 class String;
 }
 
-namespace WebCore {
+namespace blink {
 
 enum CSSPropertyID {
     CSSPropertyInvalid = 0,
 %(property_enums)s
 };
 
 const int firstCSSProperty = %(first_property_id)s;
 const int numCSSProperties = %(properties_count)s;
 const int lastCSSProperty = %(last_property_id)d;
 const size_t maxCSSPropertyNameLength = %(max_name_length)d;
 
 const char* getPropertyName(CSSPropertyID);
 const WTF::AtomicString& getPropertyNameAtomicString(CSSPropertyID);
 WTF::String getPropertyNameString(CSSPropertyID);
 WTF::String getJSPropertyName(CSSPropertyID);
 bool isInternalProperty(CSSPropertyID id);
 
 inline CSSPropertyID convertToCSSPropertyID(int value)
 {
     ASSERT((value >= firstCSSProperty && value <= lastCSSProperty) || value == CSSPropertyInvalid);
     return static_cast<CSSPropertyID>(value);
 }
 
-} // namespace WebCore
+} // namespace blink
 
 namespace WTF {
-template<> struct DefaultHash<WebCore::CSSPropertyID> { typedef IntHash<unsigned> Hash; };
-template<> struct HashTraits<WebCore::CSSPropertyID> : GenericHashTraits<WebCore::CSSPropertyID> {
+template<> struct DefaultHash<blink::CSSPropertyID> { typedef IntHash<unsigned> Hash; };
+template<> struct HashTraits<blink::CSSPropertyID> : GenericHashTraits<blink::CSSPropertyID> {
     static const bool emptyValueIsZero = true;
     static const bool needsDestruction = false;
-    static void constructDeletedValue(WebCore::CSSPropertyID& slot) { slot = static_cast<WebCore::CSSPropertyID>(WebCore::lastCSSProperty + 1); }
-    static bool isDeletedValue(WebCore::CSSPropertyID value) { return value == (WebCore::lastCSSProperty + 1); }
+    static void constructDeletedValue(blink::CSSPropertyID& slot) { slot = static_cast<blink::CSSPropertyID>(blink::lastCSSProperty + 1); }
+    static bool isDeletedValue(blink::CSSPropertyID value) { return value == (blink::lastCSSProperty + 1); }
 };
 }
 
 #endif // %(class_name)s_h
 """
 
 GPERF_TEMPLATE = """
 %%{
 %(license)s
 
 #include "config.h"
 #include "%(class_name)s.h"
 #include "core/css/HashTools.h"
 #include <string.h>
 
 #include "wtf/ASCIICType.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/WTFString.h"
 
-namespace WebCore {
+namespace blink {
 static const char propertyNameStringsPool[] = {
 %(property_name_strings)s
 };
 
 static const unsigned short propertyNameStringsOffsets[] = {
 %(property_name_offsets)s
 };
 
 %%}
 %%struct-type
@@ skipping 75 matching lines @@
 bool isInternalProperty(CSSPropertyID id)
 {
     switch (id) {
         %(internal_properties)s
             return true;
         default:
             return false;
     }
 }
 
-} // namespace WebCore
+} // namespace blink
 """
 
 
 class CSSPropertiesWriter(in_generator.Writer):
     class_name = "CSSPropertyNames"
     defaults = {
         'alias_for': None,
         'is_internal': False,
     }
 
@@ skipping 59 matching lines @@
         # FIXME: If we could depend on Python 2.7, we would use subprocess.check_output
         gperf_args = [self.gperf_path, '--key-positions=*', '-P', '-n']
         gperf_args.extend(['-m', '50'])  # Pick best of 50 attempts.
         gperf_args.append('-D')  # Allow duplicate hashes -> More compact code.
         gperf = subprocess.Popen(gperf_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
         return gperf.communicate(gperf_input)[0]
 
 
 if __name__ == "__main__":
     in_generator.Maker(CSSPropertiesWriter).main(sys.argv)