src/chrome/browser/ui/gtk/tabs/tab_renderer_gtk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/gtk/tabs/tab_renderer_gtk.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/debug/trace_event.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/defaults.h"
  14 #include "chrome/browser/extensions/tab_helper.h"
  15 #include "chrome/browser/favicon/favicon_tab_helper.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/themes/theme_properties.h"
  18 #include "chrome/browser/ui/browser.h"
  19 #include "chrome/browser/ui/gtk/bookmarks/bookmark_utils_gtk.h"
  20 #include "chrome/browser/ui/gtk/custom_button.h"
  21 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
  22 #include "chrome/browser/ui/gtk/gtk_util.h"
  23 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  24 #include "chrome/browser/ui/tabs/tab_utils.h"
  25 #include "content/public/browser/notification_source.h"
  26 #include "content/public/browser/web_contents.h"
  27 #include "grit/generated_resources.h"
  28 #include "grit/theme_resources.h"
  29 #include "grit/ui_resources.h"
  30 #include "skia/ext/image_operations.h"
  31 #include "ui/base/gtk/gtk_screen_util.h"
  32 #include "ui/base/l10n/l10n_util.h"
  33 #include "ui/base/resource/resource_bundle.h"
  34 #include "ui/gfx/animation/slide_animation.h"
  35 #include "ui/gfx/animation/throb_animation.h"
  36 #include "ui/gfx/canvas_skia_paint.h"
  37 #include "ui/gfx/favicon_size.h"
  38 #include "ui/gfx/gtk_compat.h"
  39 #include "ui/gfx/gtk_util.h"
  40 #include "ui/gfx/image/cairo_cached_surface.h"
  41 #include "ui/gfx/image/image.h"
  42 #include "ui/gfx/pango_util.h"
  43 #include "ui/gfx/platform_font_pango.h"
  44 #include "ui/gfx/skbitmap_operations.h"
  45
  46 using content::WebContents;
  47
  48 namespace {
  49
  50 const int kFontPixelSize = 12;
  51 const int kLeftPadding = 16;
  52 const int kTopPadding = 6;
  53 const int kRightPadding = 15;
  54 const int kBottomPadding = 5;
  55 const int kFaviconTitleSpacing = 4;
  56 const int kTitleCloseButtonSpacing = 5;
  57 const int kStandardTitleWidth = 175;
  58 const int kDropShadowOffset = 2;
  59 const int kInactiveTabBackgroundOffsetY = 15;
  60
  61 // When a non-mini-tab becomes a mini-tab the width of the tab animates. If
  62 // the width of a mini-tab is >= kMiniTabRendererAsNormalTabWidth then the tab
  63 // is rendered as a normal tab. This is done to avoid having the title
  64 // immediately disappear when transitioning a tab from normal to mini-tab.
  65 const int kMiniTabRendererAsNormalTabWidth =
  66     browser_defaults::kMiniTabWidth + 30;
  67
  68 // The tab images are designed to overlap the toolbar by 1 pixel. For now we
  69 // don't actually overlap the toolbar, so this is used to know how many pixels
  70 // at the bottom of the tab images are to be ignored.
  71 const int kToolbarOverlap = 1;
  72
  73 // How long the hover state takes.
  74 const int kHoverDurationMs = 90;
  75
  76 // How opaque to make the hover state (out of 1).
  77 const double kHoverOpacity = 0.33;
  78
  79 // Opacity for non-active selected tabs.
  80 const double kSelectedTabOpacity = 0.45;
  81
  82 // Selected (but not active) tabs have their throb value scaled down by this.
  83 const double kSelectedTabThrobScale = 0.5;
  84
  85 // Max opacity for the mini-tab title change animation.
  86 const double kMiniTitleChangeThrobOpacity = 0.75;
  87
  88 // Duration for when the title of an inactive mini-tab changes.
  89 const int kMiniTitleChangeThrobDuration = 1000;
  90
  91 // The horizontal offset used to position the close button in the tab.
  92 const int kCloseButtonHorzFuzz = 4;
  93
  94 // Gets the bounds of |widget| relative to |parent|.
  95 gfx::Rect GetWidgetBoundsRelativeToParent(GtkWidget* parent,
  96                                           GtkWidget* widget) {
  97   gfx::Rect bounds = ui::GetWidgetScreenBounds(widget);
  98   bounds.Offset(-ui::GetWidgetScreenOffset(parent));
  99   return bounds;
 100 }
 101
 102 // Returns a GdkPixbuf after resizing the SkBitmap as necessary to the
 103 // specified desired width and height. Caller must g_object_unref the returned
 104 // pixbuf when no longer used.
 105 GdkPixbuf* GetResizedGdkPixbufFromSkBitmap(const SkBitmap& bitmap,
 106                                            int dest_w,
 107                                            int dest_h) {
 108   float float_dest_w = static_cast<float>(dest_w);
 109   float float_dest_h = static_cast<float>(dest_h);
 110   int bitmap_w = bitmap.width();
 111   int bitmap_h = bitmap.height();
 112
 113   // Scale proportionately.
 114   float scale = std::min(float_dest_w / bitmap_w,
 115                          float_dest_h / bitmap_h);
 116   int final_dest_w = static_cast<int>(bitmap_w * scale);
 117   int final_dest_h = static_cast<int>(bitmap_h * scale);
 118
 119   GdkPixbuf* pixbuf;
 120   if (final_dest_w == bitmap_w && final_dest_h == bitmap_h) {
 121     pixbuf = gfx::GdkPixbufFromSkBitmap(bitmap);
 122   } else {
 123     SkBitmap resized_icon = skia::ImageOperations::Resize(
 124         bitmap,
 125         skia::ImageOperations::RESIZE_BETTER,
 126         final_dest_w, final_dest_h);
 127     pixbuf = gfx::GdkPixbufFromSkBitmap(resized_icon);
 128   }
 129   return pixbuf;
 130 }
 131
 132 }  // namespace
 133
 134 TabRendererGtk::LoadingAnimation::Data::Data(
 135     GtkThemeService* theme_service) {
 136   // The loading animation image is a strip of states. Each state must be
 137   // square, so the height must divide the width evenly.
 138   SkBitmap loading_animation_frames =
 139       theme_service->GetImageNamed(IDR_THROBBER).AsBitmap();
 140   DCHECK(!loading_animation_frames.isNull());
 141   DCHECK_EQ(loading_animation_frames.width() %
 142             loading_animation_frames.height(), 0);
 143   loading_animation_frame_count =
 144       loading_animation_frames.width() /
 145       loading_animation_frames.height();
 146
 147   SkBitmap waiting_animation_frames =
 148       theme_service->GetImageNamed(IDR_THROBBER_WAITING).AsBitmap();
 149   DCHECK(!waiting_animation_frames.isNull());
 150   DCHECK_EQ(waiting_animation_frames.width() %
 151             waiting_animation_frames.height(), 0);
 152   waiting_animation_frame_count =
 153       waiting_animation_frames.width() /
 154       waiting_animation_frames.height();
 155
 156   waiting_to_loading_frame_count_ratio =
 157       waiting_animation_frame_count /
 158       loading_animation_frame_count;
 159   // TODO(beng): eventually remove this when we have a proper themeing system.
 160   //             themes not supporting IDR_THROBBER_WAITING are causing this
 161   //             value to be 0 which causes DIV0 crashes. The value of 5
 162   //             matches the current bitmaps in our source.
 163   if (waiting_to_loading_frame_count_ratio == 0)
 164     waiting_to_loading_frame_count_ratio = 5;
 165 }
 166
 167 TabRendererGtk::LoadingAnimation::Data::Data(
 168     int loading, int waiting, int waiting_to_loading)
 169     : loading_animation_frame_count(loading),
 170       waiting_animation_frame_count(waiting),
 171       waiting_to_loading_frame_count_ratio(waiting_to_loading) {
 172 }
 173
 174 bool TabRendererGtk::initialized_ = false;
 175 int TabRendererGtk::tab_active_l_width_ = 0;
 176 int TabRendererGtk::tab_active_l_height_ = 0;
 177 int TabRendererGtk::tab_inactive_l_height_ = 0;
 178 gfx::Font* TabRendererGtk::title_font_ = NULL;
 179 int TabRendererGtk::title_font_height_ = 0;
 180 int TabRendererGtk::close_button_width_ = 0;
 181 int TabRendererGtk::close_button_height_ = 0;
 182
 183 ////////////////////////////////////////////////////////////////////////////////
 184 // TabRendererGtk::LoadingAnimation, public:
 185 //
 186 TabRendererGtk::LoadingAnimation::LoadingAnimation(
 187     GtkThemeService* theme_service)
 188     : data_(new Data(theme_service)),
 189       theme_service_(theme_service),
 190       animation_state_(ANIMATION_NONE),
 191       animation_frame_(0) {
 192   registrar_.Add(this,
 193                  chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
 194                  content::Source<ThemeService>(theme_service_));
 195 }
 196
 197 TabRendererGtk::LoadingAnimation::LoadingAnimation(
 198     const LoadingAnimation::Data& data)
 199     : data_(new Data(data)),
 200       theme_service_(NULL),
 201       animation_state_(ANIMATION_NONE),
 202       animation_frame_(0) {
 203 }
 204
 205 TabRendererGtk::LoadingAnimation::~LoadingAnimation() {}
 206
 207 bool TabRendererGtk::LoadingAnimation::ValidateLoadingAnimation(
 208     AnimationState animation_state) {
 209   bool has_changed = false;
 210   if (animation_state_ != animation_state) {
 211     // The waiting animation is the reverse of the loading animation, but at a
 212     // different rate - the following reverses and scales the animation_frame_
 213     // so that the frame is at an equivalent position when going from one
 214     // animation to the other.
 215     if (animation_state_ == ANIMATION_WAITING &&
 216         animation_state == ANIMATION_LOADING) {
 217       animation_frame_ = data_->loading_animation_frame_count -
 218           (animation_frame_ / data_->waiting_to_loading_frame_count_ratio);
 219     }
 220     animation_state_ = animation_state;
 221     has_changed = true;
 222   }
 223
 224   if (animation_state_ != ANIMATION_NONE) {
 225     animation_frame_ = (animation_frame_ + 1) %
 226                        ((animation_state_ == ANIMATION_WAITING) ?
 227                          data_->waiting_animation_frame_count :
 228                          data_->loading_animation_frame_count);
 229     has_changed = true;
 230   } else {
 231     animation_frame_ = 0;
 232   }
 233   return has_changed;
 234 }
 235
 236 void TabRendererGtk::LoadingAnimation::Observe(
 237     int type,
 238     const content::NotificationSource& source,
 239     const content::NotificationDetails& details) {
 240   DCHECK(type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED);
 241   data_.reset(new Data(theme_service_));
 242 }
 243
 244 TabRendererGtk::TabData::TabData()
 245     : is_default_favicon(false),
 246       loading(false),
 247       crashed(false),
 248       incognito(false),
 249       show_icon(true),
 250       mini(false),
 251       blocked(false),
 252       animating_mini_change(false),
 253       app(false),
 254       media_state(TAB_MEDIA_STATE_NONE),
 255       previous_media_state(TAB_MEDIA_STATE_NONE) {
 256 }
 257
 258 TabRendererGtk::TabData::~TabData() {}
 259
 260 ////////////////////////////////////////////////////////////////////////////////
 261 // FaviconCrashAnimation
 262 //
 263 //  A custom animation subclass to manage the favicon crash animation.
 264 class TabRendererGtk::FaviconCrashAnimation : public gfx::LinearAnimation,
 265                                               public gfx::AnimationDelegate {
 266  public:
 267   explicit FaviconCrashAnimation(TabRendererGtk* target)
 268       : gfx::LinearAnimation(1000, 25, this),
 269         target_(target) {
 270   }
 271   virtual ~FaviconCrashAnimation() {}
 272
 273   // gfx::Animation overrides:
 274   virtual void AnimateToState(double state) OVERRIDE {
 275     const double kHidingOffset = 27;
 276
 277     if (state < .5) {
 278       target_->SetFaviconHidingOffset(
 279           static_cast<int>(floor(kHidingOffset * 2.0 * state)));
 280     } else {
 281       target_->DisplayCrashedFavicon();
 282       target_->SetFaviconHidingOffset(
 283           static_cast<int>(
 284               floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
 285     }
 286   }
 287
 288   // gfx::AnimationDelegate overrides:
 289   virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE {
 290     target_->SetFaviconHidingOffset(0);
 291   }
 292
 293  private:
 294   TabRendererGtk* target_;
 295
 296   DISALLOW_COPY_AND_ASSIGN(FaviconCrashAnimation);
 297 };
 298
 299 ////////////////////////////////////////////////////////////////////////////////
 300 // TabRendererGtk, public:
 301
 302 TabRendererGtk::TabRendererGtk(GtkThemeService* theme_service)
 303     : showing_icon_(false),
 304       showing_media_indicator_(false),
 305       showing_close_button_(false),
 306       favicon_hiding_offset_(0),
 307       should_display_crashed_favicon_(false),
 308       animating_media_state_(TAB_MEDIA_STATE_NONE),
 309       loading_animation_(theme_service),
 310       background_offset_x_(0),
 311       background_offset_y_(kInactiveTabBackgroundOffsetY),
 312       theme_service_(theme_service),
 313       close_button_color_(0),
 314       is_active_(false),
 315       selected_title_color_(SK_ColorBLACK),
 316       unselected_title_color_(SkColorSetRGB(64, 64, 64)) {
 317   InitResources();
 318
 319   theme_service_->InitThemesFor(this);
 320   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
 321                  content::Source<ThemeService>(theme_service_));
 322
 323   tab_.Own(gtk_fixed_new());
 324   gtk_widget_set_app_paintable(tab_.get(), TRUE);
 325   g_signal_connect(tab_.get(), "expose-event",
 326                    G_CALLBACK(OnExposeEventThunk), this);
 327   g_signal_connect(tab_.get(), "size-allocate",
 328                    G_CALLBACK(OnSizeAllocateThunk), this);
 329   close_button_.reset(MakeCloseButton());
 330   gtk_widget_show(tab_.get());
 331
 332   hover_animation_.reset(new gfx::SlideAnimation(this));
 333   hover_animation_->SetSlideDuration(kHoverDurationMs);
 334 }
 335
 336 TabRendererGtk::~TabRendererGtk() {
 337   tab_.Destroy();
 338 }
 339
 340 void TabRendererGtk::Observe(int type,
 341                              const content::NotificationSource& source,
 342                              const content::NotificationDetails& details) {
 343   DCHECK(chrome::NOTIFICATION_BROWSER_THEME_CHANGED);
 344   selected_title_color_ =
 345       theme_service_->GetColor(ThemeProperties::COLOR_TAB_TEXT);
 346   unselected_title_color_ =
 347       theme_service_->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
 348 }
 349
 350 void TabRendererGtk::UpdateData(WebContents* contents,
 351                                 bool app,
 352                                 bool loading_only) {
 353   DCHECK(contents);
 354   FaviconTabHelper* favicon_tab_helper =
 355       FaviconTabHelper::FromWebContents(contents);
 356
 357   if (!loading_only) {
 358     data_.title = contents->GetTitle();
 359     data_.incognito = contents->GetBrowserContext()->IsOffTheRecord();
 360
 361     TabMediaState next_media_state;
 362     if (contents->IsCrashed()) {
 363       data_.crashed = true;
 364       next_media_state = TAB_MEDIA_STATE_NONE;
 365     } else {
 366       data_.crashed = false;
 367       next_media_state = chrome::GetTabMediaStateForContents(contents);
 368     }
 369     if (data_.media_state != next_media_state) {
 370       data_.previous_media_state = data_.media_state;
 371       data_.media_state = next_media_state;
 372     }
 373
 374     data_.favicon = favicon_tab_helper->GetFavicon().AsBitmap();
 375     data_.app = app;
 376
 377     // Make a cairo cached version of the favicon.
 378     if (!data_.favicon.isNull()) {
 379       // Instead of resizing the icon during each frame, create our resized
 380       // icon resource now, send it to the xserver and use that each frame
 381       // instead.
 382
 383       // For source images smaller than the favicon square, scale them as if
 384       // they were padded to fit the favicon square, so we don't blow up tiny
 385       // favicons into larger or nonproportional results.
 386       GdkPixbuf* pixbuf = GetResizedGdkPixbufFromSkBitmap(data_.favicon,
 387           gfx::kFaviconSize, gfx::kFaviconSize);
 388       data_.cairo_favicon.UsePixbuf(pixbuf);
 389       g_object_unref(pixbuf);
 390     } else {
 391       data_.cairo_favicon.Reset();
 392     }
 393
 394     // This is kind of a hacky way to determine whether our icon is the default
 395     // favicon. But the plumbing that would be necessary to do it right would
 396     // be a good bit of work and would sully code for other platforms which
 397     // don't care to custom-theme the favicon. Hopefully the default favicon
 398     // will eventually be chromium-themable and this code will go away.
 399     data_.is_default_favicon =
 400         (data_.favicon.pixelRef() ==
 401         ui::ResourceBundle::GetSharedInstance().GetImageNamed(
 402             IDR_DEFAULT_FAVICON).AsBitmap().pixelRef());
 403   }
 404
 405   // Loading state also involves whether we show the favicon, since that's where
 406   // we display the throbber.
 407   data_.loading = contents->IsLoading();
 408   data_.show_icon = favicon_tab_helper->ShouldDisplayFavicon();
 409 }
 410
 411 void TabRendererGtk::UpdateFromModel() {
 412   // Force a layout, since the tab may have grown a favicon.
 413   Layout();
 414   SchedulePaint();
 415
 416   if (data_.crashed) {
 417     if (!should_display_crashed_favicon_ && !IsPerformingCrashAnimation())
 418       StartCrashAnimation();
 419   } else {
 420     if (IsPerformingCrashAnimation())
 421       StopCrashAnimation();
 422     ResetCrashedFavicon();
 423   }
 424
 425   if (data_.media_state != data_.previous_media_state) {
 426     data_.previous_media_state = data_.media_state;
 427     if (data_.media_state != TAB_MEDIA_STATE_NONE)
 428       animating_media_state_ = data_.media_state;
 429     StartMediaIndicatorAnimation();
 430   }
 431 }
 432
 433 void TabRendererGtk::SetBlocked(bool blocked) {
 434   if (data_.blocked == blocked)
 435     return;
 436   data_.blocked = blocked;
 437   // TODO(zelidrag) bug 32399: Make tabs pulse on Linux as well.
 438 }
 439
 440 bool TabRendererGtk::is_blocked() const {
 441   return data_.blocked;
 442 }
 443
 444 bool TabRendererGtk::IsActive() const {
 445   return is_active_;
 446 }
 447
 448 bool TabRendererGtk::IsSelected() const {
 449   return true;
 450 }
 451
 452 bool TabRendererGtk::IsVisible() const {
 453   return gtk_widget_get_visible(tab_.get());
 454 }
 455
 456 void TabRendererGtk::SetVisible(bool visible) const {
 457   if (visible) {
 458     gtk_widget_show(tab_.get());
 459     if (data_.mini)
 460       gtk_widget_show(close_button_->widget());
 461   } else {
 462     gtk_widget_hide_all(tab_.get());
 463   }
 464 }
 465
 466 bool TabRendererGtk::ValidateLoadingAnimation(AnimationState animation_state) {
 467   return loading_animation_.ValidateLoadingAnimation(animation_state);
 468 }
 469
 470 void TabRendererGtk::PaintFaviconArea(GtkWidget* widget, cairo_t* cr) {
 471   DCHECK(ShouldShowIcon());
 472
 473   cairo_rectangle(cr,
 474                   x() + favicon_bounds_.x(),
 475                   y() + favicon_bounds_.y(),
 476                   favicon_bounds_.width(),
 477                   favicon_bounds_.height());
 478   cairo_clip(cr);
 479
 480   // The tab is rendered into a windowless widget whose offset is at the
 481   // coordinate event->area.  Translate by these offsets so we can render at
 482   // (0,0) to match Windows' rendering metrics.
 483   cairo_matrix_t cairo_matrix;
 484   cairo_matrix_init_translate(&cairo_matrix, x(), y());
 485   cairo_set_matrix(cr, &cairo_matrix);
 486
 487   // Which background should we be painting?
 488   int theme_id;
 489   int offset_y = 0;
 490   if (IsActive()) {
 491     theme_id = IDR_THEME_TOOLBAR;
 492   } else {
 493     theme_id = data_.incognito ? IDR_THEME_TAB_BACKGROUND_INCOGNITO :
 494                IDR_THEME_TAB_BACKGROUND;
 495
 496     if (!theme_service_->HasCustomImage(theme_id))
 497       offset_y = background_offset_y_;
 498   }
 499
 500   // Paint the background behind the favicon.
 501   const gfx::Image tab_bg = theme_service_->GetImageNamed(theme_id);
 502   tab_bg.ToCairo()->SetSource(cr, widget, -x(), -offset_y);
 503   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 504   cairo_rectangle(cr,
 505                   favicon_bounds_.x(), favicon_bounds_.y(),
 506                   favicon_bounds_.width(), favicon_bounds_.height());
 507   cairo_fill(cr);
 508
 509   if (!IsActive()) {
 510     double throb_value = GetThrobValue();
 511     if (throb_value > 0) {
 512       cairo_push_group(cr);
 513       gfx::Image active_bg =
 514           theme_service_->GetImageNamed(IDR_THEME_TOOLBAR);
 515       active_bg.ToCairo()->SetSource(cr, widget, -x(), 0);
 516       cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 517
 518       cairo_rectangle(cr,
 519                       favicon_bounds_.x(), favicon_bounds_.y(),
 520                       favicon_bounds_.width(), favicon_bounds_.height());
 521       cairo_fill(cr);
 522
 523       cairo_pop_group_to_source(cr);
 524       cairo_paint_with_alpha(cr, throb_value);
 525     }
 526   }
 527
 528   PaintIcon(widget, cr);
 529 }
 530
 531 void TabRendererGtk::MaybeAdjustLeftForMiniTab(gfx::Rect* icon_bounds) const {
 532   if (!(mini() || data_.animating_mini_change) ||
 533       bounds_.width() >= kMiniTabRendererAsNormalTabWidth)
 534     return;
 535   const int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth();
 536   const int ideal_delta = bounds_.width() - GetMiniWidth();
 537   const int ideal_x = (GetMiniWidth() - icon_bounds->width()) / 2;
 538   icon_bounds->set_x(icon_bounds->x() + static_cast<int>(
 539       (1 - static_cast<float>(ideal_delta) / static_cast<float>(mini_delta)) *
 540       (ideal_x - icon_bounds->x())));
 541 }
 542
 543 // static
 544 gfx::Size TabRendererGtk::GetMinimumUnselectedSize() {
 545   InitResources();
 546
 547   gfx::Size minimum_size;
 548   minimum_size.set_width(kLeftPadding + kRightPadding);
 549   // Since we use bitmap images, the real minimum height of the image is
 550   // defined most accurately by the height of the end cap images.
 551   minimum_size.set_height(tab_active_l_height_ - kToolbarOverlap);
 552   return minimum_size;
 553 }
 554
 555 // static
 556 gfx::Size TabRendererGtk::GetMinimumSelectedSize() {
 557   gfx::Size minimum_size = GetMinimumUnselectedSize();
 558   minimum_size.set_width(kLeftPadding + gfx::kFaviconSize + kRightPadding);
 559   return minimum_size;
 560 }
 561
 562 // static
 563 gfx::Size TabRendererGtk::GetStandardSize() {
 564   gfx::Size standard_size = GetMinimumUnselectedSize();
 565   standard_size.Enlarge(kFaviconTitleSpacing + kStandardTitleWidth, 0);
 566   return standard_size;
 567 }
 568
 569 // static
 570 int TabRendererGtk::GetMiniWidth() {
 571   return browser_defaults::kMiniTabWidth;
 572 }
 573
 574 // static
 575 int TabRendererGtk::GetContentHeight() {
 576   // The height of the content of the Tab is the largest of the favicon,
 577   // the title text and the close button graphic.
 578   int content_height = std::max(gfx::kFaviconSize, title_font_height_);
 579   return std::max(content_height, close_button_height_);
 580 }
 581
 582 gfx::Rect TabRendererGtk::GetNonMirroredBounds(GtkWidget* parent) const {
 583   // The tabstrip widget is a windowless widget so the tab widget's allocation
 584   // is relative to the browser titlebar.  We need the bounds relative to the
 585   // tabstrip.
 586   gfx::Rect bounds = GetWidgetBoundsRelativeToParent(parent, widget());
 587   bounds.set_x(gtk_util::MirroredLeftPointForRect(parent, bounds));
 588   return bounds;
 589 }
 590
 591 gfx::Rect TabRendererGtk::GetRequisition() const {
 592   return gfx::Rect(requisition_.x(), requisition_.y(),
 593                    requisition_.width(), requisition_.height());
 594 }
 595
 596 void TabRendererGtk::StartMiniTabTitleAnimation() {
 597   if (!mini_title_animation_.get()) {
 598     mini_title_animation_.reset(new gfx::ThrobAnimation(this));
 599     mini_title_animation_->SetThrobDuration(kMiniTitleChangeThrobDuration);
 600   }
 601
 602   if (!mini_title_animation_->is_animating())
 603     mini_title_animation_->StartThrobbing(-1);
 604 }
 605
 606 void TabRendererGtk::StopMiniTabTitleAnimation() {
 607   if (mini_title_animation_.get())
 608     mini_title_animation_->Stop();
 609 }
 610
 611 void TabRendererGtk::SetBounds(const gfx::Rect& bounds) {
 612   requisition_ = bounds;
 613   gtk_widget_set_size_request(tab_.get(), bounds.width(), bounds.height());
 614 }
 615
 616 ////////////////////////////////////////////////////////////////////////////////
 617 // TabRendererGtk, protected:
 618
 619 void TabRendererGtk::Raise() const {
 620   if (gtk_button_get_event_window(GTK_BUTTON(close_button_->widget())))
 621     gdk_window_raise(gtk_button_get_event_window(
 622         GTK_BUTTON(close_button_->widget())));
 623 }
 624
 625 base::string16 TabRendererGtk::GetTitle() const {
 626   return data_.title;
 627 }
 628
 629 ///////////////////////////////////////////////////////////////////////////////
 630 // TabRendererGtk, gfx::AnimationDelegate implementation:
 631
 632 void TabRendererGtk::AnimationProgressed(const gfx::Animation* animation) {
 633   gtk_widget_queue_draw(tab_.get());
 634 }
 635
 636 void TabRendererGtk::AnimationCanceled(const gfx::Animation* animation) {
 637   if (media_indicator_animation_ == animation)
 638     animating_media_state_ = data_.media_state;
 639   AnimationEnded(animation);
 640 }
 641
 642 void TabRendererGtk::AnimationEnded(const gfx::Animation* animation) {
 643   if (media_indicator_animation_ == animation)
 644     animating_media_state_ = data_.media_state;
 645   gtk_widget_queue_draw(tab_.get());
 646 }
 647
 648 ////////////////////////////////////////////////////////////////////////////////
 649 // TabRendererGtk, private:
 650
 651 void TabRendererGtk::StartCrashAnimation() {
 652   if (!crash_animation_.get())
 653     crash_animation_.reset(new FaviconCrashAnimation(this));
 654   crash_animation_->Stop();
 655   crash_animation_->Start();
 656 }
 657
 658 void TabRendererGtk::StopCrashAnimation() {
 659   if (!crash_animation_.get())
 660     return;
 661   crash_animation_->Stop();
 662 }
 663
 664 bool TabRendererGtk::IsPerformingCrashAnimation() const {
 665   return crash_animation_.get() && crash_animation_->is_animating();
 666 }
 667
 668 void TabRendererGtk::StartMediaIndicatorAnimation() {
 669   media_indicator_animation_ =
 670       chrome::CreateTabMediaIndicatorFadeAnimation(data_.media_state);
 671   media_indicator_animation_->set_delegate(this);
 672   media_indicator_animation_->Start();
 673 }
 674
 675 void TabRendererGtk::SetFaviconHidingOffset(int offset) {
 676   favicon_hiding_offset_ = offset;
 677   SchedulePaint();
 678 }
 679
 680 void TabRendererGtk::DisplayCrashedFavicon() {
 681   should_display_crashed_favicon_ = true;
 682 }
 683
 684 void TabRendererGtk::ResetCrashedFavicon() {
 685   should_display_crashed_favicon_ = false;
 686 }
 687
 688 void TabRendererGtk::Paint(GtkWidget* widget, cairo_t* cr) {
 689   // Don't paint if we're narrower than we can render correctly. (This should
 690   // only happen during animations).
 691   if (width() < GetMinimumUnselectedSize().width() && !mini())
 692     return;
 693
 694   // See if the model changes whether the icons should be painted.
 695   const bool show_icon = ShouldShowIcon();
 696   const bool show_media_indicator = ShouldShowMediaIndicator();
 697   const bool show_close_button = ShouldShowCloseBox();
 698   if (show_icon != showing_icon_ ||
 699       show_media_indicator != showing_media_indicator_ ||
 700       show_close_button != showing_close_button_)
 701     Layout();
 702
 703   PaintTabBackground(widget, cr);
 704
 705   if (!mini() || width() > kMiniTabRendererAsNormalTabWidth)
 706     PaintTitle(widget, cr);
 707
 708   if (show_icon)
 709     PaintIcon(widget, cr);
 710
 711   if (show_media_indicator)
 712     PaintMediaIndicator(widget, cr);
 713 }
 714
 715 cairo_surface_t* TabRendererGtk::PaintToSurface(GtkWidget* widget,
 716                                                 cairo_t* cr) {
 717   cairo_surface_t* target = cairo_get_target(cr);
 718   cairo_surface_t* out_surface = cairo_surface_create_similar(
 719       target,
 720       CAIRO_CONTENT_COLOR_ALPHA,
 721       width(), height());
 722
 723   cairo_t* out_cr = cairo_create(out_surface);
 724   Paint(widget, out_cr);
 725   cairo_destroy(out_cr);
 726
 727   return out_surface;
 728 }
 729
 730 void TabRendererGtk::SchedulePaint() {
 731   gtk_widget_queue_draw(tab_.get());
 732 }
 733
 734 gfx::Rect TabRendererGtk::GetLocalBounds() {
 735   return gfx::Rect(0, 0, bounds_.width(), bounds_.height());
 736 }
 737
 738 void TabRendererGtk::Layout() {
 739   gfx::Rect local_bounds = GetLocalBounds();
 740   if (local_bounds.IsEmpty())
 741     return;
 742   local_bounds.Inset(kLeftPadding, kTopPadding, kRightPadding, kBottomPadding);
 743
 744   // Figure out who is tallest.
 745   int content_height = GetContentHeight();
 746
 747   // Size the Favicon.
 748   showing_icon_ = ShouldShowIcon();
 749   if (showing_icon_) {
 750     int favicon_top = kTopPadding + (content_height - gfx::kFaviconSize) / 2;
 751     favicon_bounds_.SetRect(local_bounds.x(), favicon_top,
 752                             gfx::kFaviconSize, gfx::kFaviconSize);
 753     MaybeAdjustLeftForMiniTab(&favicon_bounds_);
 754   } else {
 755     favicon_bounds_.SetRect(local_bounds.x(), local_bounds.y(), 0, 0);
 756   }
 757
 758   // Size the Close button.
 759   showing_close_button_ = ShouldShowCloseBox();
 760   if (showing_close_button_) {
 761     int close_button_top = kTopPadding +
 762         (content_height - close_button_height_) / 2;
 763     int close_button_left =
 764         local_bounds.right() - close_button_width_ + kCloseButtonHorzFuzz;
 765     close_button_bounds_.SetRect(close_button_left,
 766                                  close_button_top,
 767                                  close_button_width_,
 768                                  close_button_height_);
 769
 770     // If the close button color has changed, generate a new one.
 771     if (theme_service_) {
 772       SkColor tab_text_color =
 773           theme_service_->GetColor(ThemeProperties::COLOR_TAB_TEXT);
 774       if (!close_button_color_ || tab_text_color != close_button_color_) {
 775         close_button_color_ = tab_text_color;
 776         ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 777         close_button_->SetBackground(close_button_color_,
 778             rb.GetImageNamed(IDR_CLOSE_1).AsBitmap(),
 779             rb.GetImageNamed(IDR_CLOSE_1_MASK).AsBitmap());
 780       }
 781     }
 782   } else {
 783     close_button_bounds_.SetRect(0, 0, 0, 0);
 784   }
 785
 786   showing_media_indicator_ = ShouldShowMediaIndicator();
 787   if (showing_media_indicator_) {
 788     const gfx::Image& media_indicator_image =
 789         chrome::GetTabMediaIndicatorImage(animating_media_state_);
 790     media_indicator_bounds_.set_width(media_indicator_image.Width());
 791     media_indicator_bounds_.set_height(media_indicator_image.Height());
 792     media_indicator_bounds_.set_y(
 793         kTopPadding + (content_height - media_indicator_bounds_.height()) / 2);
 794     const int right = showing_close_button_ ?
 795         close_button_bounds_.x() : local_bounds.right();
 796     media_indicator_bounds_.set_x(std::max(
 797         local_bounds.x(), right - media_indicator_bounds_.width()));
 798     MaybeAdjustLeftForMiniTab(&media_indicator_bounds_);
 799   } else {
 800     media_indicator_bounds_.SetRect(local_bounds.x(), local_bounds.y(), 0, 0);
 801   }
 802
 803   if (!mini() || width() >= kMiniTabRendererAsNormalTabWidth) {
 804     // Size the Title text to fill the remaining space.
 805     int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
 806     int title_top = kTopPadding;
 807
 808     // If the user has big fonts, the title will appear rendered too far down
 809     // on the y-axis if we use the regular top padding, so we need to adjust it
 810     // so that the text appears centered.
 811     gfx::Size minimum_size = GetMinimumUnselectedSize();
 812     int text_height = title_top + title_font_height_ + kBottomPadding;
 813     if (text_height > minimum_size.height())
 814       title_top -= (text_height - minimum_size.height()) / 2;
 815
 816     int title_width;
 817     if (showing_media_indicator_) {
 818       title_width = media_indicator_bounds_.x() - kTitleCloseButtonSpacing -
 819           title_left;
 820     } else if (close_button_bounds_.width() && close_button_bounds_.height()) {
 821       title_width = close_button_bounds_.x() - kTitleCloseButtonSpacing -
 822           title_left;
 823     } else {
 824       title_width = local_bounds.width() - title_left;
 825     }
 826     title_width = std::max(title_width, 0);
 827     title_bounds_.SetRect(title_left, title_top, title_width, content_height);
 828   }
 829
 830   favicon_bounds_.set_x(
 831       gtk_util::MirroredLeftPointForRect(tab_.get(), favicon_bounds_));
 832   media_indicator_bounds_.set_x(
 833       gtk_util::MirroredLeftPointForRect(tab_.get(), media_indicator_bounds_));
 834   close_button_bounds_.set_x(
 835       gtk_util::MirroredLeftPointForRect(tab_.get(), close_button_bounds_));
 836   title_bounds_.set_x(
 837       gtk_util::MirroredLeftPointForRect(tab_.get(), title_bounds_));
 838
 839   MoveCloseButtonWidget();
 840 }
 841
 842 void TabRendererGtk::MoveCloseButtonWidget() {
 843   if (!close_button_bounds_.IsEmpty()) {
 844     gtk_fixed_move(GTK_FIXED(tab_.get()), close_button_->widget(),
 845                    close_button_bounds_.x(), close_button_bounds_.y());
 846     gtk_widget_show(close_button_->widget());
 847   } else {
 848     gtk_widget_hide(close_button_->widget());
 849   }
 850 }
 851
 852 void TabRendererGtk::PaintTab(GtkWidget* widget, GdkEventExpose* event) {
 853   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
 854   gdk_cairo_rectangle(cr, &event->area);
 855   cairo_clip(cr);
 856
 857   // The tab is rendered into a windowless widget whose offset is at the
 858   // coordinate event->area.  Translate by these offsets so we can render at
 859   // (0,0) to match Windows' rendering metrics.
 860   cairo_matrix_t cairo_matrix;
 861   cairo_matrix_init_translate(&cairo_matrix, event->area.x, event->area.y);
 862   cairo_set_matrix(cr, &cairo_matrix);
 863
 864   // Save the original x offset so we can position background images properly.
 865   background_offset_x_ = event->area.x;
 866
 867   Paint(widget, cr);
 868   cairo_destroy(cr);
 869 }
 870
 871 void TabRendererGtk::PaintTitle(GtkWidget* widget, cairo_t* cr) {
 872   if (title_bounds_.IsEmpty())
 873     return;
 874
 875   // Paint the Title.
 876   base::string16 title = data_.title;
 877   if (title.empty()) {
 878     title = data_.loading ?
 879         l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) :
 880         CoreTabHelper::GetDefaultTitle();
 881   } else {
 882     Browser::FormatTitleForDisplay(&title);
 883   }
 884
 885   GtkAllocation allocation;
 886   gtk_widget_get_allocation(widget, &allocation);
 887   gfx::Rect bounds(allocation);
 888
 889   // Draw the text directly onto the Cairo context. This is necessary for
 890   // getting the draw order correct, and automatically applying transformations
 891   // such as scaling when a tab is detached.
 892   gfx::CanvasSkiaPaintCairo canvas(cr, bounds.size(), true);
 893
 894   SkColor title_color = IsSelected() ? selected_title_color_
 895                                      : unselected_title_color_;
 896
 897   // Disable subpixel rendering. This does not work because the canvas has a
 898   // transparent background.
 899   int flags = gfx::Canvas::NO_ELLIPSIS | gfx::Canvas::NO_SUBPIXEL_RENDERING;
 900   canvas.DrawFadeTruncatingStringRectWithFlags(
 901       title, gfx::Canvas::TruncateFadeTail, gfx::FontList(*title_font_),
 902       title_color, title_bounds_, flags);
 903 }
 904
 905 void TabRendererGtk::PaintIcon(GtkWidget* widget, cairo_t* cr) {
 906   if (loading_animation_.animation_state() != ANIMATION_NONE) {
 907     PaintLoadingAnimation(widget, cr);
 908     return;
 909   }
 910
 911   gfx::CairoCachedSurface* to_display = NULL;
 912   if (should_display_crashed_favicon_) {
 913     to_display = theme_service_->GetImageNamed(IDR_SAD_FAVICON).ToCairo();
 914   } else if (!data_.favicon.isNull()) {
 915     if (data_.is_default_favicon && theme_service_->UsingNativeTheme()) {
 916       to_display = GtkThemeService::GetDefaultFavicon(true).ToCairo();
 917     } else if (data_.cairo_favicon.valid()) {
 918       to_display = &data_.cairo_favicon;
 919     }
 920   }
 921
 922   if (to_display) {
 923     to_display->SetSource(cr, widget, favicon_bounds_.x(),
 924                           favicon_bounds_.y() + favicon_hiding_offset_);
 925     cairo_paint(cr);
 926   }
 927 }
 928
 929 void TabRendererGtk::PaintMediaIndicator(GtkWidget* widget, cairo_t* cr) {
 930   if (media_indicator_bounds_.IsEmpty() || !media_indicator_animation_)
 931     return;
 932
 933   double opaqueness = media_indicator_animation_->GetCurrentValue();
 934   if (data_.media_state == TAB_MEDIA_STATE_NONE)
 935     opaqueness = 1.0 - opaqueness;  // Fading out, not in.
 936
 937   const gfx::Image& media_indicator_image =
 938       chrome::GetTabMediaIndicatorImage(animating_media_state_);
 939   media_indicator_image.ToCairo()->SetSource(
 940       cr, widget, media_indicator_bounds_.x(), media_indicator_bounds_.y());
 941   cairo_paint_with_alpha(cr, opaqueness);
 942 }
 943
 944 void TabRendererGtk::PaintTabBackground(GtkWidget* widget, cairo_t* cr) {
 945   if (IsActive()) {
 946     PaintActiveTabBackground(widget, cr);
 947   } else {
 948     PaintInactiveTabBackground(widget, cr);
 949
 950     double throb_value = GetThrobValue();
 951     if (throb_value > 0) {
 952       cairo_push_group(cr);
 953       PaintActiveTabBackground(widget, cr);
 954       cairo_pop_group_to_source(cr);
 955       cairo_paint_with_alpha(cr, throb_value);
 956     }
 957   }
 958 }
 959
 960 void TabRendererGtk::DrawTabBackground(
 961     cairo_t* cr,
 962     GtkWidget* widget,
 963     const gfx::Image& tab_bg,
 964     int offset_x,
 965     int offset_y) {
 966   tab_bg.ToCairo()->SetSource(cr, widget, -offset_x, -offset_y);
 967   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 968
 969   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 970
 971   // Draw left edge
 972   gfx::Image& tab_l_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_LEFT);
 973   tab_l_mask.ToCairo()->MaskSource(cr, widget, 0, 0);
 974
 975   // Draw center
 976   cairo_rectangle(cr,
 977                   tab_active_l_width_, kDropShadowOffset,
 978                   width() - (2 * tab_active_l_width_),
 979                   tab_inactive_l_height_);
 980   cairo_fill(cr);
 981
 982   // Draw right edge
 983   gfx::Image& tab_r_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_RIGHT);
 984   tab_r_mask.ToCairo()->MaskSource(cr, widget,
 985                                     width() - tab_active_l_width_, 0);
 986 }
 987
 988 void TabRendererGtk::DrawTabShadow(cairo_t* cr,
 989                                    GtkWidget* widget,
 990                                    int left_idr,
 991                                    int center_idr,
 992                                    int right_idr) {
 993   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 994   gfx::Image& active_image_l = rb.GetNativeImageNamed(left_idr);
 995   gfx::Image& active_image_c = rb.GetNativeImageNamed(center_idr);
 996   gfx::Image& active_image_r = rb.GetNativeImageNamed(right_idr);
 997
 998   // Draw left drop shadow
 999   active_image_l.ToCairo()->SetSource(cr, widget, 0, 0);
1000   cairo_paint(cr);
1001
1002   // Draw the center shadow
1003   active_image_c.ToCairo()->SetSource(cr, widget, 0, 0);
1004   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
1005   cairo_rectangle(cr, tab_active_l_width_, 0,
1006                   width() - (2 * tab_active_l_width_),
1007                   height());
1008   cairo_fill(cr);
1009
1010   // Draw right drop shadow
1011   active_image_r.ToCairo()->SetSource(
1012       cr, widget, width() - active_image_r.ToCairo()->Width(), 0);
1013   cairo_paint(cr);
1014 }
1015
1016 void TabRendererGtk::PaintInactiveTabBackground(GtkWidget* widget,
1017                                                 cairo_t* cr) {
1018   int theme_id = data_.incognito ?
1019       IDR_THEME_TAB_BACKGROUND_INCOGNITO : IDR_THEME_TAB_BACKGROUND;
1020
1021   gfx::Image tab_bg = theme_service_->GetImageNamed(theme_id);
1022
1023   // If the theme is providing a custom background image, then its top edge
1024   // should be at the top of the tab. Otherwise, we assume that the background
1025   // image is a composited foreground + frame image.
1026   int offset_y = theme_service_->HasCustomImage(theme_id) ?
1027       0 : background_offset_y_;
1028
1029   DrawTabBackground(cr, widget, tab_bg, background_offset_x_, offset_y);
1030
1031   DrawTabShadow(cr, widget, IDR_TAB_INACTIVE_LEFT, IDR_TAB_INACTIVE_CENTER,
1032                 IDR_TAB_INACTIVE_RIGHT);
1033 }
1034
1035 void TabRendererGtk::PaintActiveTabBackground(GtkWidget* widget,
1036                                               cairo_t* cr) {
1037   gfx::Image tab_bg = theme_service_->GetImageNamed(IDR_THEME_TOOLBAR);
1038
1039   DrawTabBackground(cr, widget, tab_bg, background_offset_x_, 0);
1040   DrawTabShadow(cr, widget, IDR_TAB_ACTIVE_LEFT, IDR_TAB_ACTIVE_CENTER,
1041                 IDR_TAB_ACTIVE_RIGHT);
1042 }
1043
1044 void TabRendererGtk::PaintLoadingAnimation(GtkWidget* widget,
1045                                            cairo_t* cr) {
1046   int id = loading_animation_.animation_state() == ANIMATION_WAITING ?
1047            IDR_THROBBER_WAITING : IDR_THROBBER;
1048   gfx::Image throbber = theme_service_->GetImageNamed(id);
1049
1050   const int image_size = throbber.ToCairo()->Height();
1051   const int image_offset = loading_animation_.animation_frame() * image_size;
1052   DCHECK(image_size == favicon_bounds_.height());
1053   DCHECK(image_size == favicon_bounds_.width());
1054
1055   throbber.ToCairo()->SetSource(cr, widget, favicon_bounds_.x() - image_offset,
1056                                  favicon_bounds_.y());
1057   cairo_rectangle(cr, favicon_bounds_.x(), favicon_bounds_.y(),
1058                   image_size, image_size);
1059   cairo_fill(cr);
1060 }
1061
1062 int TabRendererGtk::IconCapacity() const {
1063   if (height() < GetMinimumUnselectedSize().height())
1064     return 0;
1065   const int available_width =
1066       std::max(0, width() - kLeftPadding - kRightPadding);
1067   const int kPaddingBetweenIcons = 2;
1068   if (available_width >= gfx::kFaviconSize &&
1069       available_width < (gfx::kFaviconSize + kPaddingBetweenIcons)) {
1070     return 1;
1071   }
1072   return available_width / (gfx::kFaviconSize + kPaddingBetweenIcons);
1073 }
1074
1075 bool TabRendererGtk::ShouldShowIcon() const {
1076   return chrome::ShouldTabShowFavicon(
1077       IconCapacity(), mini(), IsActive(), data_.show_icon,
1078       animating_media_state_);
1079 }
1080
1081 bool TabRendererGtk::ShouldShowMediaIndicator() const {
1082   return chrome::ShouldTabShowMediaIndicator(
1083       IconCapacity(), mini(), IsActive(), data_.show_icon,
1084       animating_media_state_);
1085 }
1086
1087 bool TabRendererGtk::ShouldShowCloseBox() const {
1088   return chrome::ShouldTabShowCloseButton(IconCapacity(), mini(), IsActive());
1089 }
1090
1091 CustomDrawButton* TabRendererGtk::MakeCloseButton() {
1092   CustomDrawButton* button = CustomDrawButton::CloseButtonBar(theme_service_);
1093   button->ForceChromeTheme();
1094
1095   g_signal_connect(button->widget(), "clicked",
1096                    G_CALLBACK(OnCloseButtonClickedThunk), this);
1097   g_signal_connect(button->widget(), "button-release-event",
1098                    G_CALLBACK(OnCloseButtonMouseReleaseThunk), this);
1099   g_signal_connect(button->widget(), "enter-notify-event",
1100                    G_CALLBACK(OnEnterNotifyEventThunk), this);
1101   g_signal_connect(button->widget(), "leave-notify-event",
1102                    G_CALLBACK(OnLeaveNotifyEventThunk), this);
1103   gtk_widget_set_can_focus(button->widget(), FALSE);
1104   gtk_fixed_put(GTK_FIXED(tab_.get()), button->widget(), 0, 0);
1105
1106   return button;
1107 }
1108
1109 double TabRendererGtk::GetThrobValue() {
1110   bool is_selected = IsSelected();
1111   double min = is_selected ? kSelectedTabOpacity : 0;
1112   double scale = is_selected ? kSelectedTabThrobScale : 1;
1113
1114   if (mini_title_animation_.get() && mini_title_animation_->is_animating()) {
1115     return mini_title_animation_->GetCurrentValue() *
1116         kMiniTitleChangeThrobOpacity * scale + min;
1117   }
1118
1119   if (hover_animation_.get())
1120     return kHoverOpacity * hover_animation_->GetCurrentValue() * scale + min;
1121
1122   return is_selected ? kSelectedTabOpacity : 0;
1123 }
1124
1125 void TabRendererGtk::CloseButtonClicked() {
1126   // Nothing to do.
1127 }
1128
1129 void TabRendererGtk::OnCloseButtonClicked(GtkWidget* widget) {
1130   CloseButtonClicked();
1131 }
1132
1133 gboolean TabRendererGtk::OnCloseButtonMouseRelease(GtkWidget* widget,
1134                                                    GdkEventButton* event) {
1135   if (event->button == 2) {
1136     CloseButtonClicked();
1137     return TRUE;
1138   }
1139
1140   return FALSE;
1141 }
1142
1143 gboolean TabRendererGtk::OnExposeEvent(GtkWidget* widget,
1144                                        GdkEventExpose* event) {
1145   TRACE_EVENT0("ui::gtk", "TabRendererGtk::OnExposeEvent");
1146
1147   PaintTab(widget, event);
1148   gtk_container_propagate_expose(GTK_CONTAINER(tab_.get()),
1149                                  close_button_->widget(), event);
1150   return TRUE;
1151 }
1152
1153 void TabRendererGtk::OnSizeAllocate(GtkWidget* widget,
1154                                     GtkAllocation* allocation) {
1155   gfx::Rect bounds = gfx::Rect(allocation->x, allocation->y,
1156                                allocation->width, allocation->height);
1157
1158   // Nothing to do if the bounds are the same.  If we don't catch this, we'll
1159   // get an infinite loop of size-allocate signals.
1160   if (bounds_ == bounds)
1161     return;
1162
1163   bounds_ = bounds;
1164   Layout();
1165 }
1166
1167 gboolean TabRendererGtk::OnEnterNotifyEvent(GtkWidget* widget,
1168                                             GdkEventCrossing* event) {
1169   hover_animation_->SetTweenType(gfx::Tween::EASE_OUT);
1170   hover_animation_->Show();
1171   return FALSE;
1172 }
1173
1174 gboolean TabRendererGtk::OnLeaveNotifyEvent(GtkWidget* widget,
1175                                             GdkEventCrossing* event) {
1176   hover_animation_->SetTweenType(gfx::Tween::EASE_IN);
1177   hover_animation_->Hide();
1178   return FALSE;
1179 }
1180
1181 // static
1182 void TabRendererGtk::InitResources() {
1183   if (initialized_)
1184     return;
1185
1186   // Grab the pixel sizes of our masking images.
1187   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
1188   GdkPixbuf* tab_active_l = rb.GetNativeImageNamed(
1189       IDR_TAB_ACTIVE_LEFT).ToGdkPixbuf();
1190   tab_active_l_width_ = gdk_pixbuf_get_width(tab_active_l);
1191   tab_active_l_height_ = gdk_pixbuf_get_height(tab_active_l);
1192
1193   GdkPixbuf* tab_inactive_l = rb.GetNativeImageNamed(
1194       IDR_TAB_INACTIVE_LEFT).ToGdkPixbuf();
1195   tab_inactive_l_height_ = gdk_pixbuf_get_height(tab_inactive_l);
1196
1197   GdkPixbuf* tab_close = rb.GetNativeImageNamed(IDR_CLOSE_1).ToGdkPixbuf();
1198   close_button_width_ = gdk_pixbuf_get_width(tab_close);
1199   close_button_height_ = gdk_pixbuf_get_height(tab_close);
1200
1201   const gfx::Font& base_font = rb.GetFont(ui::ResourceBundle::BaseFont);
1202   title_font_ = new gfx::Font(base_font.GetFontName(), kFontPixelSize);
1203   title_font_height_ = title_font_->GetHeight();
1204
1205   initialized_ = true;
1206 }