GTK: More profiling of the rendering path.

chrome/browser/ui/gtk/gtk_theme_service.cc

 
 // 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.
 
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 
 #include <gtk/gtk.h>
 
 #include <set>
@@ skipping 548 matching lines @@
   if (theme_thumb_inactive)
     *thumb_inactive_color = *theme_thumb_inactive;
 
   if (theme_trough_color)
     *track_color = *theme_trough_color;
 }
 
 CairoCachedSurface* GtkThemeService::GetSurfaceNamed(
     int id,
     GtkWidget* widget_on_display) {
-  return GetSurfaceNamedImpl(id,
-                             &per_display_surfaces_,
-                             GetPixbufNamed(id),
-                             widget_on_display);
+  return GetSurfaceNamedImpl(
+      id,
+      &per_display_surfaces_,
+      &GtkThemeService::GetPixbufNamed,
+      widget_on_display);
 }
 
 CairoCachedSurface* GtkThemeService::GetRTLEnabledSurfaceNamed(
     int id,
     GtkWidget* widget_on_display) {
   // We flip the sign of |id| when passing it to GetSurfaceNamedImpl() for the
   // same reason that ThemeService::GetPixbufImpl() does: so that if one
   // location calls this function with a resource ID, and another place calls
   // GetSurfaceNamed() with the same ID, they'll correctly get different
   // surfaces in RTL mode.
-  return GetSurfaceNamedImpl(-id,
-                             &per_display_surfaces_,
-                             GetRTLEnabledPixbufNamed(id),
-                             widget_on_display);
+  return GetSurfaceNamedImpl(
+      -id,
+      &per_display_surfaces_,
+      &GtkThemeService::GetRTLEnabledPixbufNamedWrapper,
+      widget_on_display);
 }
 
 CairoCachedSurface* GtkThemeService::GetUnthemedSurfaceNamed(
     int id,
     GtkWidget* widget_on_display) {
   return GetSurfaceNamedImpl(id,
       &per_display_unthemed_surfaces_,
-      ResourceBundle::GetSharedInstance().GetNativeImageNamed(id),
+      &GtkThemeService::GetUnthemedNativePixbuf,
       widget_on_display);
 }
 
+CairoCachedSurface* GtkThemeService::GetCairoIcon(
+    int id,
+    GtkWidget* widget_on_display) {
+  return GetSurfaceNamedImpl(id,
+                             &per_display_icon_surfaces_,
+                             &GtkThemeService::GetPixbufForIconId,
+                             widget_on_display);
+}
+
 // static
 GdkPixbuf* GtkThemeService::GetFolderIcon(bool native) {
   if (native) {
     if (!icon_widget_)
       icon_widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     // We never release our ref, so we will leak this on program shutdown.
     if (!default_folder_icon_) {
       default_folder_icon_ =
           gtk_widget_render_icon(icon_widget_, GTK_STOCK_DIRECTORY,
                                  GTK_ICON_SIZE_MENU, NULL);
@@ skipping 89 matching lines @@
   Browser* browser = BrowserList::GetLastActive();
   if (browser && browser->window()) {
     gtk_util::SetDefaultWindowIcon(browser->window()->GetNativeHandle());
   }
 }
 
 void GtkThemeService::FreePlatformCaches() {
   ThemeService::FreePlatformCaches();
   FreePerDisplaySurfaces(&per_display_surfaces_);
   FreePerDisplaySurfaces(&per_display_unthemed_surfaces_);
+  FreePerDisplaySurfaces(&per_display_icon_surfaces_);
   STLDeleteValues(&gtk_images_);
 }
 
 void GtkThemeService::OnStyleSet(GtkWidget* widget,
                                  GtkStyle* previous_style) {
   GdkPixbuf* default_folder_icon = default_folder_icon_;
   GdkPixbuf* default_bookmark_icon = default_bookmark_icon_;
   default_folder_icon_ = NULL;
   default_bookmark_icon_ = NULL;
 
@@ skipping 400 matching lines @@
   // since the icons tinted this way will only be displayed against
   // base[GTK_STATE_SELECTED].
   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
   const GdkColor color = style->text[GTK_STATE_SELECTED];
   color_utils::SkColorToHSL(GdkToSkColor(&color), tint);
 }
 
 CairoCachedSurface* GtkThemeService::GetSurfaceNamedImpl(
     int id,
     PerDisplaySurfaceMap* display_surface_map,
-    GdkPixbuf* pixbuf,
+    PixbufProvidingMethod provider,
     GtkWidget* widget_on_display) {
   GdkDisplay* display = gtk_widget_get_display(widget_on_display);
   CairoCachedSurfaceMap& surface_map = (*display_surface_map)[display];
 
   // Check to see if we already have the pixbuf in the cache.
   CairoCachedSurfaceMap::const_iterator found = surface_map.find(id);
   if (found != surface_map.end())
     return found->second;
 
   CairoCachedSurface* surface = new CairoCachedSurface;
-  surface->UsePixbuf(pixbuf);
+  surface->UsePixbuf((this->*provider)(id));
 
   surface_map[id] = surface;
 
   return surface;
 }
 
+// PixbufProvidingMethod that undoes the negative sign on |id|.
+GdkPixbuf* GtkThemeService::GetRTLEnabledPixbufNamedWrapper(int id) const {
+  return GetRTLEnabledPixbufNamed(-id);
+}
+
+// PixbufProvidingMethod that just calls ResourceBundle. We want to minimize
+// the calls to this method because it aquires an AutoLock and we don't want
+// this to happen all the time.
+GdkPixbuf* GtkThemeService::GetUnthemedNativePixbuf(int id) const {
+  return ResourceBundle::GetSharedInstance().GetNativeImageNamed(id);
+}
+
+// PixbufProvidingMethod that maps a GtkThemeService::CairoDefaultIcon to a
+// GdkPixbuf.
+GdkPixbuf* GtkThemeService::GetPixbufForIconId(int id) const {
+  switch (id) {
+    case GtkThemeService::NATIVE_FAVICON:
+      return GtkThemeService::GetDefaultFavicon(true);
+    case GtkThemeService::CHROME_FAVICON:
+      return GtkThemeService::GetDefaultFavicon(false);
+    case GtkThemeService::NATIVE_FOLDER:
+      return GtkThemeService::GetFolderIcon(true);
+    case GtkThemeService::CHROME_FOLDER:
+      return GtkThemeService::GetFolderIcon(false);
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
 void GtkThemeService::OnDestroyChromeButton(GtkWidget* button) {
   std::vector<GtkWidget*>::iterator it =
       find(chrome_buttons_.begin(), chrome_buttons_.end(), button);
   if (it != chrome_buttons_.end())
     chrome_buttons_.erase(it);
 }
 
 void GtkThemeService::OnDestroyChromeLinkButton(GtkWidget* button) {
   std::vector<GtkWidget*>::iterator it =
       find(link_buttons_.begin(), link_buttons_.end(), button);
@@ skipping 43 matching lines @@
   cairo_set_line_width(cr, 1.0);
   cairo_move_to(cr, start_x, widget->allocation.y);
   cairo_line_to(cr, start_x,
                 widget->allocation.y + widget->allocation.height);
   cairo_stroke(cr);
   cairo_destroy(cr);
   cairo_pattern_destroy(pattern);
 
   return TRUE;
 }