GTK: Add TRACE_EVENTs around gtk ui events.

chrome/browser/ui/gtk/browser_window_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/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <dlfcn.h>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/environment.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/nix/xdg_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 377 matching lines @@
 
   ConnectAccelerators();
 
   // Set the initial background color of widgets.
   SetBackgroundColor();
   HideUnsupportedWindowFeatures();
 }
 
 gboolean BrowserWindowGtk::OnCustomFrameExpose(GtkWidget* widget,
                                                GdkEventExpose* event) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::OnCustomFrameExpose");
+
   // Draw the default background.
   cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
   gdk_cairo_rectangle(cr, &event->area);
   cairo_clip(cr);
 
   if (UsingCustomPopupFrame()) {
     DrawPopupFrame(cr, widget, event);
   } else {
     DrawCustomFrame(cr, widget, event);
   }
@@ skipping 351 matching lines @@
 StatusBubble* BrowserWindowGtk::GetStatusBubble() {
   return status_bubble_.get();
 }
 
 void BrowserWindowGtk::ToolbarSizeChanged(bool is_animating) {
   // On Windows, this is used for a performance optimization.
   // http://code.google.com/p/chromium/issues/detail?id=12291
 }
 
 void BrowserWindowGtk::UpdateTitleBar() {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateTitleBar");
   string16 title = browser_->GetWindowTitleForCurrentTab();
   gtk_window_set_title(window_, UTF16ToUTF8(title).c_str());
   if (ShouldShowWindowIcon())
     titlebar_->UpdateTitleAndIcon();
 }
 
 void BrowserWindowGtk::BookmarkBarStateChanged(
     BookmarkBar::AnimateChangeType change_type) {
   MaybeShowBookmarkBar(change_type == BookmarkBar::ANIMATE_STATE_CHANGE);
 }
@@ skipping 134 matching lines @@
 }
 
 void BrowserWindowGtk::UpdateReloadStopState(bool is_loading, bool force) {
   toolbar_->GetReloadButton()->ChangeMode(
       is_loading ? ReloadButtonGtk::MODE_STOP : ReloadButtonGtk::MODE_RELOAD,
       force);
 }
 
 void BrowserWindowGtk::UpdateToolbar(TabContentsWrapper* contents,
                                      bool should_restore_state) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateToolbar");
   toolbar_->UpdateTabContents(contents->tab_contents(), should_restore_state);
 }
 
 void BrowserWindowGtk::FocusToolbar() {
   NOTIMPLEMENTED();
 }
 
 void BrowserWindowGtk::FocusAppMenu() {
   NOTIMPLEMENTED();
 }
@@ skipping 300 matching lines @@
     infobar_container_->ChangeTabContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
   contents_container_->DetachTab(contents);
 }
 
 void BrowserWindowGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
                                         TabContentsWrapper* new_contents,
                                         int index,
                                         bool user_gesture) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::ActiveTabChanged");
   if (old_contents && !old_contents->tab_contents()->is_being_destroyed())
     old_contents->view()->StoreFocus();
 
   // Update various elements that are interested in knowing the current
   // TabContents.
   infobar_container_->ChangeTabContents(new_contents->infobar_tab_helper());
   contents_container_->SetTab(new_contents);
   UpdateDevToolsForContents(new_contents->tab_contents());
 
   new_contents->tab_contents()->DidBecomeSelected();
@@ skipping 51 matching lines @@
   if (x) {
     // This is a views specific call that made its way into the interface. We
     // go through GetXPositionOfLocationIcon() since we need widget relativity.
     *x = 0;
     NOTREACHED();
   }
   return true;
 }
 
 void BrowserWindowGtk::MaybeShowBookmarkBar(bool animate) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::MaybeShowBookmarkBar");
   if (!IsBookmarkBarSupported())
     return;
 
   TabContentsWrapper* tab = GetDisplayedTab();
 
   if (tab)
     bookmark_bar_->SetPageNavigator(browser_.get());
 
   BookmarkBar::State state = browser_->bookmark_bar_state();
   if (contents_container_->HasPreview() && state == BookmarkBar::DETACHED)
     state = BookmarkBar::HIDDEN;
 
   toolbar_->UpdateForBookmarkBarVisibility(state == BookmarkBar::DETACHED);
   PlaceBookmarkBar(state == BookmarkBar::DETACHED);
   bookmark_bar_->SetBookmarkBarState(
       state,
       animate ? BookmarkBar::ANIMATE_STATE_CHANGE :
                 BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 }
 
 void BrowserWindowGtk::UpdateDevToolsForContents(TabContents* contents) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateDevToolsForContents");
   TabContentsWrapper* old_devtools = devtools_container_->tab();
   TabContentsWrapper* devtools_contents = contents ?
       DevToolsWindow::GetDevToolsContents(contents) : NULL;
   if (old_devtools == devtools_contents)
     return;
 
   if (old_devtools)
     devtools_container_->DetachTab(old_devtools);
 
   devtools_container_->SetTab(devtools_contents);
@@ skipping 637 matching lines @@
 }
 
 void BrowserWindowGtk::OnLocationIconSizeAllocate(GtkWidget* sender,
                                                   GtkAllocation* allocation) {
   // The position of the arrow may have changed, so we'll have to redraw it.
   InvalidateInfoBarBits();
 }
 
 gboolean BrowserWindowGtk::OnExposeDrawInfobarBits(GtkWidget* sender,
                                                    GdkEventExpose* expose) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::OnExposeDrawInfobarBits");
   // Maybe draw infobars
   infobar_container_->PaintInfobarBitsOn(sender, expose, NULL);
 
   return FALSE;
 }
 
 gboolean BrowserWindowGtk::OnBookmarkBarExpose(GtkWidget* sender,
                                                GdkEventExpose* expose) {
   if (browser_->bookmark_bar_state() == BookmarkBar::DETACHED)
     return FALSE;
 
   return OnExposeDrawInfobarBits(sender, expose);
 }
 
 void BrowserWindowGtk::OnBookmarkBarSizeAllocate(GtkWidget* sender,
                                                  GtkAllocation* allocation) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::OnBookmarkBarSizeAllocate");
   // The size of the bookmark bar affects how the infobar arrow is drawn on
   // the toolbar.
   if (infobar_container_->ContainsInfobars())
     InvalidateInfoBarBits();
 
   // Pass the new size to our infobar container.
   int arrow_size = InfoBar::kDefaultArrowTargetHeight;
   if (browser_->bookmark_bar_state() != BookmarkBar::DETACHED)
     arrow_size += allocation->height;
   infobar_container_->SetMaxTopArrowHeight(arrow_size);
@@ skipping 339 matching lines @@
   GdkScreen* screen = gtk_window_get_screen(window_);
   gint monitor_num = gdk_screen_get_monitor_at_window(screen,
       gtk_widget_get_window(GTK_WIDGET(window_)));
 
   GdkRectangle monitor_size;
   gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor_size);
   return bounds_.size() == gfx::Size(monitor_size.width, monitor_size.height);
 }
 
 void BrowserWindowGtk::PlaceBookmarkBar(bool is_floating) {
+  TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::PlaceBookmarkBar");
+
   GtkWidget* target_parent = NULL;
   if (!is_floating) {
     // Place the bookmark bar at the end of |window_vbox_|; this happens after
     // we have placed the render area at the end of |window_vbox_| so we will
     // be above the render area.
     target_parent = window_vbox_;
   } else {
     // Place the bookmark bar at the end of the render area; this happens after
     // the tab contents container has been placed there so we will be
     // above the webpage (in terms of y).
@@ skipping 41 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }