Update gdb and lldb webkit macros after blink rename

third_party/WebKit/Tools/gdb/webkit.py

 # Copyright (C) 2010, Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 92 matching lines @@
 
 class LCharStringPrinter(StringPrinter):
     "Print a LChar*; we must guess at the length"
     def to_string(self):
         return lstring_to_string(self.val)
 
 
 class WTFAtomicStringPrinter(StringPrinter):
     "Print a WTF::AtomicString"
     def to_string(self):
-        return self.val['m_string']
+        return self.val['string_']
 
 
 class WTFCStringPrinter(StringPrinter):
     "Print a WTF::CString"
     def to_string(self):
         # The CString holds a buffer, which is a refptr to a WTF::CStringBuffer.
-        buf_ptr = self.val['m_buffer']['m_ptr']
+        buf_ptr = self.val['buffer_']['ptr_']
         if not buf_ptr:
             return 0
         data = (buf_ptr + 1).cast(gdb.lookup_type('char').pointer())
-        length = self.val['m_buffer']['m_ptr']['m_length']
+        length = self.val['buffer_']['ptr_']['length_']
         return ''.join([chr((data + i).dereference()) for i in range(length)])
 
 
 class WTFStringImplPrinter(StringPrinter):
     "Print a WTF::StringImpl"
     def get_length(self):
-        return self.val['m_length']
+        return self.val['length_']
 
     def to_string(self):
         chars_start = self.val.address + 1
         if self.is_8bit():
             return lstring_to_string(chars_start.cast(gdb.lookup_type('char').pointer()),
                                      self.get_length())
         return ustring_to_string(chars_start.cast(gdb.lookup_type('UChar').pointer()),
                                  self.get_length())
 
     def is_8bit(self):
-        return self.val['m_is8Bit']
+        return self.val['is8_bit_']
 
 
 class WTFStringPrinter(StringPrinter):
     "Print a WTF::String"
     def stringimpl_ptr(self):
-        return self.val['m_impl']['m_ptr']
+        return self.val['impl_']['ptr_']
 
     def get_length(self):
         if not self.stringimpl_ptr():
             return 0
         return WTFStringImplPrinter(self.stringimpl_ptr().dereference()).get_length()
 
     def to_string(self):
         if not self.stringimpl_ptr():
             return '(null)'
         return self.stringimpl_ptr().dereference()
 
 
 
 class blinkKURLPrinter(StringPrinter):
     "Print a blink::KURL"
     def to_string(self):
-        return WTFStringPrinter(self.val['m_string']).to_string()
+        return WTFStringPrinter(self.val['string_']).to_string()
 
 
 class blinkLayoutUnitPrinter:
     "Print a blink::LayoutUnit"
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
-        return "%.14gpx" % (self.val['m_value'] / 64.0)
+        return "%.14gpx" % (self.val['value_'] / 64.0)
 
 
 class blinkLayoutSizePrinter:
     "Print a blink::LayoutSize"
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
-        return 'LayoutSize(%s, %s)' % (blinkLayoutUnitPrinter(self.val['m_width']).to_string(), blinkLayoutUnitPrinter(self.val['m_height']).to_string())
+        return 'LayoutSize(%s, %s)' % (
+            blinkLayoutUnitPrinter(self.val['width_']).to_string(),
+            blinkLayoutUnitPrinter(self.val['height_']).to_string())
 
 
 class blinkLayoutPointPrinter:
     "Print a blink::LayoutPoint"
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
-        return 'LayoutPoint(%s, %s)' % (blinkLayoutUnitPrinter(self.val['m_x']).to_string(), blinkLayoutUnitPrinter(self.val['m_y']).to_string())
+        return 'LayoutPoint(%s, %s)' % (
+            blinkLayoutUnitPrinter(self.val['x_']).to_string(),
+            blinkLayoutUnitPrinter(self.val['y_']).to_string())
 
 
 class blinkQualifiedNamePrinter(StringPrinter):
     "Print a blink::QualifiedName"
 
     def __init__(self, val):
         super(blinkQualifiedNamePrinter, self).__init__(val)
         self.prefix_length = 0
         self.length = 0
-        if self.val['m_impl']:
+        if self.val['impl_']:
             self.prefix_printer = WTFStringPrinter(
-                self.val['m_impl']['m_ptr']['m_prefix']['m_string'])
+                self.val['impl_']['ptr_']['prefix_']['string_'])
             self.local_name_printer = WTFStringPrinter(
-                self.val['m_impl']['m_ptr']['m_localName']['m_string'])
+                self.val['impl_']['ptr_']['local_name_']['string_'])
             self.prefix_length = self.prefix_printer.get_length()
             if self.prefix_length > 0:
                 self.length = (self.prefix_length + 1 +
                     self.local_name_printer.get_length())
             else:
                 self.length = self.local_name_printer.get_length()
 
     def get_length(self):
         return self.length
 
@@ skipping 16 matching lines @@
     def to_string(self):
         return "(%gpx, %g%%)" % (self.val['pixels'], self.val['percent'])
 
 
 class BlinkLengthPrinter:
     """Print a blink::Length."""
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
-        ltype = self.val['m_type']
-        if self.val['m_isFloat']:
-            val = self.val['m_floatValue']
+        ltype = self.val['type_']
+        if self.val['is_float_']:
+            val = self.val['float_value_']
         else:
-            val = int(self.val['m_intValue'])
+            val = int(self.val['int_value_'])
 
         quirk = ''
-        if self.val['m_quirk']:
+        if self.val['quirk_']:
             quirk = ', quirk=true'
 
         if ltype == 0:
             return 'Length(Auto)'
         if ltype == 1:
             return 'Length(%g%%, Percent%s)' % (val, quirk)
         if ltype == 2:
             return 'Length(%g, Fixed%s)' % (val, quirk)
         if ltype == 3:
             return 'Length(Intrinsic)'
@@ skipping 74 matching lines @@
             return ('[%d]' % count, element)
 
         # Python version < 3 compatibility:
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
-        start = self.val['m_buffer']
-        return self.Iterator(start, start + self.val['m_size'])
+        start = self.val['buffer_']
+        return self.Iterator(start, start + self.val['size_'])
 
     def to_string(self):
         return ('%s of length %d, capacity %d'
-                % ('WTF::Vector', self.val['m_size'], self.val['m_capacity']))
+                % ('WTF::Vector', self.val['size_'], self.val['capacity_']))
 
     def display_hint(self):
         return 'array'
 
 
 # Copied from //tools/gdb/gdb_chrome.py
 def typed_ptr(ptr):
     """Prints a pointer along with its exact type.
 
     By default, gdb would print just the address, which takes more
     steps to interpret.
     """
     # Returning this as a cast expression surrounded by parentheses
     # makes it easier to cut+paste inside of gdb.
     return '((%s)%s)' % (ptr.dynamic_type, ptr)
 
 
 class WTFRefOrOwnPtrPrinter:
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         type_without_param = re.sub(r'<.*>', '', self.val.type.name)
-        return '%s%s' % (type_without_param, typed_ptr(self.val['m_ptr']))
+        return '%s%s' % (type_without_param, typed_ptr(self.val['ptr_']))
 
 
 class BlinkDataRefPrinter:
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         return 'DataRef(%s)' % (
-            WTFRefOrOwnPtrPrinter(self.val['m_data']).to_string())
+            WTFRefOrOwnPtrPrinter(self.val['data_']).to_string())
 
 
 def add_pretty_printers():
     pretty_printers = (
         (re.compile("^WTF::Vector<.*>$"), WTFVectorPrinter),
         (re.compile("^WTF::AtomicString$"), WTFAtomicStringPrinter),
         (re.compile("^WTF::CString$"), WTFCStringPrinter),
         (re.compile("^WTF::String$"), WTFStringPrinter),
         (re.compile("^WTF::StringImpl$"), WTFStringImplPrinter),
         (re.compile("^blink::KURL$"), blinkKURLPrinter),
@@ skipping 51 matching lines @@
             val = gdb.Frame.read_var(frame, arg)
         except:
             print("No such variable, or invalid type")
             return
 
         target_type = str(val.type.target().strip_typedefs())
         if target_type == str(node_type):
             stack = []
             while val:
                 stack.append([val,
-                    val.cast(element_type.pointer()).dereference()['m_tagName']])
-                val = val.dereference()['m_parent']
+                              val.cast(element_type.pointer()).dereference()[
+                                  'tag_name_']])
+                val = val.dereference()['parent_']
 
             padding = ''
             while len(stack) > 0:
                 pair = stack.pop()
                 print(padding, pair[1], pair[0])
                 padding = padding + '  '
         else:
             print('Sorry: I don\'t know how to deal with %s yet.' % target_type)
 
 
 PrintPathToRootCommand()