Add a fast path for tab strip expose.

chrome/browser/gtk/tabs/tab_strip_gtk.cc

 // Copyright (c) 2009 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/gtk/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
 #include "app/gtk_dnd_util.h"
 #include "app/gfx/canvas_paint.h"
@@ skipping 53 matching lines @@
 }
 
 // widget->allocation is not guaranteed to be set.  After window creation,
 // we pick up the normal bounds by connecting to the configure-event signal.
 gfx::Rect GetInitialWidgetBounds(GtkWidget* widget) {
   GtkRequisition request;
   gtk_widget_size_request(widget, &request);
   return gfx::Rect(0, 0, request.width, request.height);
 }
 
+// Sort rectangles based on their x position.  We don't care about y position
+// so we don't bother breaking ties.
+int CompareGdkRectangles(const void* p1, const void* p2) {
+  int p1_x = static_cast<const GdkRectangle*>(p1)->x;
+  int p2_x = static_cast<const GdkRectangle*>(p2)->x;
+  if (p1_x < p2_x)
+    return -1;
+  else if (p1_x == p2_x)
+    return 0;
+  return 1;
+}
+
+bool GdkRectMatchesTabFavIconBounds(const GdkRectangle& gdk_rect, TabGtk* tab) {
+  gfx::Rect favicon_bounds = tab->favicon_bounds();
+  return gdk_rect.x == favicon_bounds.x() + tab->x() &&
+      gdk_rect.y == favicon_bounds.y() + tab->y() &&
+      gdk_rect.width == favicon_bounds.width() &&
+      gdk_rect.height == favicon_bounds.height();
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TabAnimation
 //
 //  A base class for all TabStrip animations.
 //
 class TabStripGtk::TabAnimation : public AnimationDelegate {
  public:
@@ skipping 903 matching lines @@
   }
 }
 
 void TabStripGtk::TabChangedAt(TabContents* contents, int index,
                                bool loading_only) {
   // Index is in terms of the model. Need to make sure we adjust that index in
   // case we have an animation going.
   TabGtk* tab = GetTabAt(index);
   tab->UpdateData(contents, loading_only);
   tab->UpdateFromModel();
-  gtk_widget_queue_draw(tabstrip_.get());
 }
 
 void TabStripGtk::TabPinnedStateChanged(TabContents* contents, int index) {
   GetTabAt(index)->set_pinned(model_->IsTabPinned(index));
   StartPinnedTabAnimation(index);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabGtk::TabDelegate implementation:
 
@@ skipping 745 matching lines @@
   if (layout)
     Layout();
 }
 
 // static
 gboolean TabStripGtk::OnExpose(GtkWidget* widget, GdkEventExpose* event,
                                TabStripGtk* tabstrip) {
   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;
+  if (tabstrip->CanPaintOnlyFavIcons(rects, num_rects, &tabs_to_repaint)) {
+    tabstrip->PaintOnlyFavIcons(event, tabs_to_repaint);
+    g_free(rects);
+    return TRUE;
+  }
+  g_free(rects);
+
   // TODO(jhawkins): Ideally we'd like to only draw what's needed in the damage
   // rect, but the tab widgets overlap each other, and painting on one widget
   // will cause an expose-event to be sent to the widgets underneath.  The
   // underlying widget does not need to be redrawn as we control the order of
   // expose-events.  Currently we hack it to redraw the entire tabstrip.  We
   // could change the damage rect to just contain the tabs + the new tab button.
   event->area.x = 0;
   event->area.y = 0;
   event->area.width = tabstrip->bounds_.width();
   event->area.height = tabstrip->bounds_.height();
@@ skipping 167 matching lines @@
 }
 
 void TabStripGtk::SetTabBounds(TabGtk* tab, const gfx::Rect& bounds) {
   gfx::Rect bds = bounds;
   bds.set_x(gtk_util::MirroredLeftPointForRect(tabstrip_.get(), bounds));
   tab->SetBounds(bds);
   gtk_fixed_move(GTK_FIXED(tabstrip_.get()), tab->widget(),
                  bds.x(), bds.y());
 }
 
+bool TabStripGtk::CanPaintOnlyFavIcons(const GdkRectangle* rects,
+    int num_rects, std::vector<int>* tabs_to_paint) {
+  // |rects| are sorted so we just need to scan from left to right and compare
+  // it to the tab favicon positions from left to right.
+  int t = 0;
+  for (int r = 0; r < num_rects; ++r) {
+    while (t < GetTabCount()) {
+      TabGtk* tab = GetTabAt(t);
+      if (GdkRectMatchesTabFavIconBounds(rects[r], tab)) {
+        tabs_to_paint->push_back(t);
+        ++t;
+        break;
+      }
+      ++t;
+    }
+  }
+  return static_cast<int>(tabs_to_paint->size()) == num_rects;
+}
+
+void TabStripGtk::PaintOnlyFavIcons(GdkEventExpose* event,
+                                    const std::vector<int>& tabs_to_paint) {
+  for (size_t i = 0; i < tabs_to_paint.size(); ++i)
+    GetTabAt(tabs_to_paint[i])->PaintFavIconArea(event);
+}
+
 CustomDrawButton* TabStripGtk::MakeNewTabButton() {
   CustomDrawButton* button = new CustomDrawButton(IDR_NEWTAB_BUTTON,
       IDR_NEWTAB_BUTTON_P, IDR_NEWTAB_BUTTON_H, 0);
 
   // Let the middle mouse button initiate clicks as well.
   gtk_util::SetButtonTriggersNavigation(button->widget());
   g_signal_connect(G_OBJECT(button->widget()), "clicked",
                    G_CALLBACK(OnNewTabClicked), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }