GTK: Add TRACE_EVENTs around gtk ui events.

chrome/browser/ui/gtk/tabs/tab_strip_gtk.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/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 934 matching lines @@
 
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabStripModelObserver implementation:
 
 void TabStripGtk::TabInsertedAt(TabContentsWrapper* contents,
                                 int index,
                                 bool foreground) {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::TabInsertedAt");
+
   DCHECK(contents);
   DCHECK(index == TabStripModel::kNoTab || model_->ContainsIndex(index));
 
   StopAnimation();
 
   bool contains_tab = false;
   TabGtk* tab = NULL;
   // First see if this Tab is one that was dragged out of this TabStrip and is
   // now being dragged back in. In this case, the DraggedTabController actually
   // has the Tab already constructed and we can just insert it into our list
@@ skipping 53 matching lines @@
   // Have to do this _after_ calling StartRemoveTabAnimation, so that any
   // previous remove is completed fully and index is valid in sync with the
   // model index.
   GetTabAt(index)->set_closing(true);
 }
 
 void TabStripGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
                                    TabContentsWrapper* new_contents,
                                    int index,
                                    bool user_gesture) {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::ActiveTabChanged");
   ReStack();
 }
 
 void TabStripGtk::TabSelectionChanged(TabStripModel* tab_strip_model,
                                       const TabStripSelectionModel& old_model) {
   // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
   // a different size to the selected ones.
   bool tiny_tabs = current_unselected_width_ != current_selected_width_;
   if (!IsAnimating() && (!needs_resize_layout_ || tiny_tabs))
     Layout();
@@ skipping 550 matching lines @@
   GdkScreen* screen = gdk_screen_get_default();
   GdkDisplay* display = gdk_screen_get_display(screen);
   gint x, y;
   gdk_display_get_pointer(display, NULL, &x, &y, NULL);
   gfx::Point cursor_point(x, y);
 
   return bds.Contains(cursor_point);
 }
 
 void TabStripGtk::ReStack() {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::ReStack");
+
   if (!gtk_widget_get_realized(tabstrip_.get())) {
     // If the window isn't realized yet, we can't stack them yet. It will be
     // done by the OnMap signal handler.
     return;
   }
   int tab_count = GetTabCount();
   TabGtk* active_tab = NULL;
   for (int i = tab_count - 1; i >= 0; --i) {
     TabGtk* tab = GetTabAt(i);
     if (tab->IsActive())
@@ skipping 176 matching lines @@
   CreateContainer();
   drop_arrow = GetDropArrowImage(point_down);
 }
 
 TabStripGtk::DropInfo::~DropInfo() {
   DestroyContainer();
 }
 
 gboolean TabStripGtk::DropInfo::OnExposeEvent(GtkWidget* widget,
                                               GdkEventExpose* event) {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::DropInfo::OnExposeEvent");
+
   if (ui::IsScreenComposited()) {
     SetContainerTransparency();
   } else {
     SetContainerShapeMask();
   }
 
   gdk_pixbuf_render_to_drawable(drop_arrow,
                                 container->window,
                                 0, 0, 0,
                                 0, 0,
@@ skipping 164 matching lines @@
 
   if (layout)
     Layout();
 }
 
 void TabStripGtk::OnMap(GtkWidget* widget) {
   ReStack();
 }
 
 gboolean TabStripGtk::OnExpose(GtkWidget* widget, GdkEventExpose* event) {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::OnExpose");
+
   if (gdk_region_empty(event->region))
     return TRUE;
 
   // If we're only repainting favicons, optimize the paint path and only draw
   // the favicons.
   GdkRectangle* rects;
   gint num_rects;
   gdk_region_get_rectangles(event->region, &rects, &num_rects);
   qsort(rects, num_rects, sizeof(GdkRectangle), CompareGdkRectangles);
   std::vector<int> tabs_to_repaint;
@@ skipping 59 matching lines @@
   // Paint the selected tab last, so it overlaps all the others.
   if (selected_tab) {
     gtk_container_propagate_expose(GTK_CONTAINER(tabstrip_.get()),
                                    selected_tab->widget(), event);
   }
 
   return TRUE;
 }
 
 void TabStripGtk::OnSizeAllocate(GtkWidget* widget, GtkAllocation* allocation) {
+  TRACE_EVENT0("ui::gtk", "TabStripGtk::OnSizeAllocate");
+
   gfx::Rect bounds = gfx::Rect(allocation->x, allocation->y,
       allocation->width, allocation->height);
 
   // Nothing to do if the bounds are the same.  If we don't catch this, we'll
   // get an infinite loop of size-allocate signals.
   if (bounds_ == bounds)
     return;
 
   SetBounds(bounds);
 
@@ skipping 146 matching lines @@
 }
 
 void TabStripGtk::SetNewTabButtonBackground() {
   SkColor color = theme_service_->GetColor(
       ThemeService::COLOR_BUTTON_BACKGROUND);
   SkBitmap* background = theme_service_->GetBitmapNamed(
       IDR_THEME_WINDOW_CONTROL_BACKGROUND);
   SkBitmap* mask = theme_service_->GetBitmapNamed(IDR_NEWTAB_BUTTON_MASK);
   newtab_button_->SetBackground(color, background, mask);
 }