Add GDB printers for several more vocabulary types in Chrome

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/")
   import gdb_chrome
+  end
 
 This module relies on the WebKit gdb module already existing in
 your Python path.
+
+Use
+  (gdb) p /r any_variable
+to print |any_variable| without using any printers.
 """
 
+import datetime
 import gdb
 import webkit
 
+# When debugging this module, set the below variable to True, and then use
+#   (gdb) python del sys.modules['gdb_chrome']
+#   (gdb) python import gdb_chrome
+# to reload.
+_DEBUGGING = False
+
+
+pp_set = gdb.printing.RegexpCollectionPrettyPrinter("chromium")
+
+
 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 String16Printer(webkit.StringPrinter):
-    def to_string(self):
-        return webkit.ustring_to_string(self.val['_M_dataplus']['_M_p'])
 
-class GURLPrinter(webkit.StringPrinter):
-    def to_string(self):
-        return self.val['spec_']
-
-class FilePathPrinter(object):
+class Printer(object):
     def __init__(self, val):
         self.val = val
 
+
+class StringPrinter(Printer):
+    def display_hint(self):
+        return 'string'
+
+
+class String16Printer(StringPrinter):
+    def to_string(self):
+        return webkit.ustring_to_string(self.val['_M_dataplus']['_M_p'])
+pp_set.add_printer('string16',
+                   '^string16|std::basic_string<(unsigned short|char16).*>$',
+                   String16Printer);
+
+
+class GURLPrinter(StringPrinter):
+    def to_string(self):
+        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 ScopedRefPtrPrinter(object):
+
+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 ScopedRefPtrPrinter(SmartPtrPrinter):
+    typename = 'scoped_refptr'
+    def ptr(self):
+        return self.val['ptr_']
+pp_set.add_printer('scoped_refptr', '^scoped_refptr<.*>$', ScopedRefPtrPrinter)
+
+
+class LinkedPtrPrinter(SmartPtrPrinter):
+    typename = 'linked_ptr'
+    def ptr(self):
+        return self.val['value_']
+pp_set.add_printer('linked_ptr', '^linked_ptr<.*>$', LinkedPtrPrinter)
+
+
+class WeakPtrPrinter(SmartPtrPrinter):
+    typename = 'base::WeakPtr'
+    def ptr(self):
+        flag = ScopedRefPtrPrinter(self.val['ref_']['flag_']).ptr()
+        if flag and flag.dereference()['is_valid_']:

[Jeffrey Yasskin, 2013/03/22 00:17:29]

Oh, one thing I wanted to ask: I could write this as either
flag.dereference()['is_valid_] or just flag['is_valid']. (Of all the things
gdb-python could have made implicit, they chose the difference between '.' and
'->'?!?) I think I slightly prefer the implicit form, but I can definitely see
an argument for being explicit. What do you think?

[tony, 2013/03/22 16:48:43]

I would probably use the implicit flag['is_valid'], but either is OK with me.

+            return self.val['ptr_']
+        return gdb.Value(0).cast(self.val['ptr_'].type)
+pp_set.add_printer('base::WeakPtr', '^base::WeakPtr<.*>$', WeakPtrPrinter)
+
+
+class CallbackPrinter(Printer):
+    """Callbacks provide no usable information so reduce the space they take."""
+    def to_string(self):
+        return '...'
+pp_set.add_printer('base::Callback', '^base::Callback<.*>$', CallbackPrinter)
+
+
+class LockPrinter(Printer):
+    def to_string(self):
+        try:
+            if self.val['owned_by_thread_']:
+                return 'Locked by thread %s' % self.val['owning_thread_id_']
+            else:
+                return 'Unlocked'
+        except gdb.error:
+            return 'Unknown state'
+pp_set.add_printer('base::Lock', '^base::Lock$', LockPrinter)
+
+
+class TimeDeltaPrinter(object):
     def __init__(self, val):
-        self.val = val
+        self._timedelta = datetime.timedelta(microseconds=int(val['delta_']))
+
+    def timedelta(self):
+        return self._timedelta
 
     def to_string(self):
-        return 'scoped_refptr' + typed_ptr(self.val['ptr_'])
+        return str(self._timedelta)
+pp_set.add_printer('base::TimeDelta', '^base::TimeDelta$', TimeDeltaPrinter)
+
+
+class TimeTicksPrinter(TimeDeltaPrinter):
+    def __init__(self, val):
+        self._timedelta = datetime.timedelta(microseconds=int(val['ticks_']))
+pp_set.add_printer('base::TimeTicks', '^base::TimeTicks$', TimeTicksPrinter)
+
+
+class TimePrinter(object):
+    def __init__(self, val):
+        timet_offset = gdb.parse_and_eval(
+            'base::Time::kTimeTToMicrosecondsOffset')

[tony, 2013/03/22 00:05:05]

Cute.

+        self._datetime = (datetime.datetime.fromtimestamp(0) +
+                          datetime.timedelta(microseconds=
+                                             int(val['us_'] - timet_offset)))

[tony, 2013/03/22 00:05:05]

Does this subtraction work?  It looks like val['us_'] is a string?

[Jeffrey Yasskin, 2013/03/22 00:17:29]

Yeah, 'val' is a base::Time, and val['us_'] means val.us_. Since 'us_' is an
int64 (http://cs/#chrome/src/base/time.h&l=478), gdb wraps it into something
that can subtract. I need to do the explicit int()  conversion on the result
because timedelta checks for an exact type, not just a duck type. Whee.

[tony, 2013/03/22 16:48:43]

I see. Thanks for explaining!

+
+    def datetime(self):
+        return self._datetime
+
+    def to_string(self):
+        return str(self._datetime)
+pp_set.add_printer('base::Time', '^base::Time$', TimePrinter)
+
+
+class NotificationRegistrarPrinter(Printer):
+    def to_string(self):
+        try:
+            registrations = self.val['registered_']
+            vector_finish = registrations['_M_impl']['_M_finish']
+            vector_start = registrations['_M_impl']['_M_start']
+            if vector_start == vector_finish:
+                return 'Not watching notifications'
+            if vector_start.dereference().type.sizeof == 0:
+                # Incomplete type: b/8242773
+                return 'Watching some notifications'
+            return ('Watching %s notifications; '
+                    'print %s->registered_ for details') % (
+                        int(vector_finish - vector_start),
+                        typed_ptr(self.val.address))
+        except gdb.error:
+            return 'NotificationRegistrar'
+pp_set.add_printer('content::NotificationRegistrar',
+                   '^content::NotificationRegistrar$',
+                   NotificationRegistrarPrinter)
+
 
 class SiteInstanceImplPrinter(object):
     def __init__(self, val):
         self.val = val.cast(val.dynamic_type)
 
     def to_string(self):
         return 'SiteInstanceImpl@%s for %s' % (
             self.val.address, self.val['site_'])
 
     def children(self):
         yield ('id_', self.val['id_'])
         yield ('has_site_', self.val['has_site_'])
         if self.val['browsing_instance_']['ptr_']:
             yield ('browsing_instance_', self.val['browsing_instance_']['ptr_'])
         if self.val['process_']:
             yield ('process_', typed_ptr(self.val['process_']))
         if self.val['render_process_host_factory_']:
             yield ('render_process_host_factory_',
                    self.val['render_process_host_factory_'])
+pp_set.add_printer('content::SiteInstanceImpl', '^content::SiteInstanceImpl$',
+                   SiteInstanceImplPrinter)
+
 
 class RenderProcessHostImplPrinter(object):
     def __init__(self, val):
         self.val = val.cast(val.dynamic_type)
 
     def to_string(self):
         pid = ''
-        child_process_launcher_ptr = (
-            self.val['child_process_launcher_']['impl_']['data_']['ptr'])
-        if child_process_launcher_ptr:
-            context = (child_process_launcher_ptr.dereference()
-                       ['context_']['ptr_'])
-            if context:
-                pid = ' PID %s' % str(context.dereference()
-                                      ['process_']['process_'])
+        try:
+            child_process_launcher_ptr = (
+                self.val['child_process_launcher_']['impl_']['data_']['ptr'])
+            if child_process_launcher_ptr:
+                context = (child_process_launcher_ptr.dereference()
+                           ['context_']['ptr_'])
+                if context:
+                    pid = ' PID %s' % str(context.dereference()
+                                          ['process_']['process_'])
+        except gdb.error:
+            # The definition of the Context type may not be available.
+            # b/8242773
+            pass
         return 'RenderProcessHostImpl@%s%s' % (self.val.address, pid)
 
     def children(self):
         yield ('id_', self.val['id_'])
         yield ('render_widget_hosts_',
                self.val['render_widget_hosts_']['data_'])
         yield ('fast_shutdown_started_', self.val['fast_shutdown_started_'])
         yield ('deleting_soon_', self.val['deleting_soon_'])
         yield ('pending_views_', self.val['pending_views_'])
         yield ('visible_widgets_', self.val['visible_widgets_'])
         yield ('backgrounded_', self.val['backgrounded_'])
         yield ('widget_helper_', self.val['widget_helper_'])
         yield ('is_initialized_', self.val['is_initialized_'])
         yield ('browser_context_', typed_ptr(self.val['browser_context_']))
         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 = gdb.printing.RegexpCollectionPrettyPrinter("chromium")
-
-pp_set.add_printer('FilePath', '^FilePath$', FilePathPrinter)
-pp_set.add_printer('GURL', '^GURL$', GURLPrinter)
 pp_set.add_printer('content::RenderProcessHostImpl',
                    '^content::RenderProcessHostImpl$',
                    RenderProcessHostImplPrinter)
-pp_set.add_printer('content::SiteInstanceImpl', '^content::SiteInstanceImpl$',
-                   SiteInstanceImplPrinter)
-pp_set.add_printer('scoped_refptr', '^scoped_refptr<.*>$', ScopedRefPtrPrinter)
-pp_set.add_printer('string16', '^string16$', String16Printer);
 
-gdb.printing.register_pretty_printer(gdb, pp_set)
+
+gdb.printing.register_pretty_printer(gdb, pp_set, replace=_DEBUGGING)