Improvements to GDB debug printers.

tools/gdb/gdb_chrome.py

 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """GDB support for Chrome types.
 
 Add this to your gdb by amending your ~/.gdbinit as follows:
   python
   import sys
   sys.path.insert(0, "/path/to/tools/gdb/")
@@ skipping 89 matching lines @@
         return self.val['spec_']
 pp_set.add_printer('GURL', '^GURL$', GURLPrinter)
 
 
 class FilePathPrinter(StringPrinter):
     def to_string(self):
         return self.val['path_']['_M_dataplus']['_M_p']
 pp_set.add_printer('FilePath', '^FilePath$', FilePathPrinter)
 
 
-class SizePrinter(Printer):
-    def to_string(self):
-        return '%sx%s' % (self.val['width_'], self.val['height_'])
-pp_set.add_printer('gfx::Size', '^gfx::(Size|SizeF|SizeBase<.*>)$', SizePrinter)
-
-
-class PointPrinter(Printer):
-    def to_string(self):
-        return '%s,%s' % (self.val['x_'], self.val['y_'])
-pp_set.add_printer('gfx::Point', '^gfx::(Point|PointF|PointBase<.*>)$',
-                   PointPrinter)
-
-
-class RectPrinter(Printer):
-    def to_string(self):
-        return '%s %s' % (self.val['origin_'], self.val['size_'])
-pp_set.add_printer('gfx::Rect', '^gfx::(Rect|RectF|RectBase<.*>)$',
-                   RectPrinter)
-
-
 class SmartPtrPrinter(Printer):
     def to_string(self):
         return '%s%s' % (self.typename, typed_ptr(self.ptr()))
 
 
 class ScopedPtrPrinter(SmartPtrPrinter):
     typename = 'scoped_ptr'
     def ptr(self):
         return self.val['impl_']['data_']['ptr']
 pp_set.add_printer('scoped_ptr', '^scoped_ptr<.*>$', ScopedPtrPrinter)
@@ skipping 99 matching lines @@
 
 class ManualConstructorPrinter(object):
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         return self.val['space_'].cast(self.val.type.template_argument(0))
 pp_set.add_printer('base::ManualConstructor', '^base::ManualConstructor<.*>$', ManualConstructorPrinter)
 
 
-class FlatMapPrinter(object):
+class FlatTreePrinter(object):
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         # It would be nice to match the output of std::map which is a little
         # nicer than printing the vector of pairs. But iterating over it in
         # Python is much more complicated and this output is reasonable.
         # (Without this printer, a flat_map will output 7 lines of internal
         # template goop before the vector contents.)
-        return 'base::flat_map with ' + str(self.val['impl_']['body_'])
-pp_set.add_printer('base::flat_map', '^base::flat_map<.*>$', FlatMapPrinter)
+        return 'base::flat_tree with ' + str(self.val['impl_']['body_'])
+pp_set.add_printer('base::flat_map', '^base::flat_map<.*>$', FlatTreePrinter)
+pp_set.add_printer('base::flat_set', '^base::flat_set<.*>$', FlatTreePrinter)
+pp_set.add_printer('base::flat_tree', '^base::internal::flat_tree<.*>$',
+                   FlatTreePrinter)
 
 
 class ValuePrinter(object):
     def __init__(self, val):
         self.val = val
 
     def get_type(self):
         return self.val['type_']
 
     def to_string(self):
@@ skipping 12 matching lines @@
         if typestr == 'STRING':
             valuestr = self.val['string_value_']
         if typestr == 'BINARY':
             valuestr = self.val['binary_value_']
         if typestr == 'DICTIONARY':
             valuestr = self.val['dict_']
         if typestr == 'LIST':
             valuestr = self.val['list_']
 
         return "base::Value of type %s = %s" % (typestr, str(valuestr))
-pp_set.add_printer('base::Value', '^base::(List|Dictionary|)Value$', ValuePrinter)
+pp_set.add_printer('base::Value', '^base::Value$', ValuePrinter)
+pp_set.add_printer('base::ListValue', '^base::ListValue$', ValuePrinter)
+pp_set.add_printer('base::DictionaryValue', '^base::DictionaryValue$',
+                   ValuePrinter)
 
 
 class IpcMessagePrinter(Printer):
     def header(self):
         return self.val['header_'].cast(
             gdb.lookup_type('IPC::Message::Header').pointer())
 
     def to_string(self):
         message_type = self.header()['type']
         return '%s of kind %s line %s' % (
@@ skipping 87 matching lines @@
         yield ('sudden_termination_allowed_',
                self.val['sudden_termination_allowed_'])
         yield ('ignore_input_events_', self.val['ignore_input_events_'])
         yield ('is_guest_', self.val['is_guest_'])
 pp_set.add_printer('content::RenderProcessHostImpl',
                    '^content::RenderProcessHostImpl$',
                    RenderProcessHostImplPrinter)
 
 
 gdb.printing.register_pretty_printer(gdb, pp_set, replace=_DEBUGGING)