Revert of Use labels to display views tab titles.

chrome/browser/ui/views/tabs/tab.cc

 // Copyright (c) 2012 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/views/tabs/tab.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 17 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
+#include "ui/gfx/font.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
-#include "ui/views/controls/label.h"
 #include "ui/views/rect_based_targeting_utils.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 #if defined(USE_ASH)
 #include "ui/aura/env.h"
 #endif
 
 namespace {
@@ skipping 312 matching lines @@
 // Tab, statics:
 
 // static
 const char Tab::kViewClassName[] = "Tab";
 
 // static
 Tab::TabImage Tab::tab_alpha_ = {0};
 Tab::TabImage Tab::tab_active_ = {0};
 Tab::TabImage Tab::tab_inactive_ = {0};
 // static
+gfx::Font* Tab::font_ = NULL;
+// static
+int Tab::font_height_ = 0;
+// static
 Tab::ImageCache* Tab::image_cache_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, public:
 
 Tab::Tab(TabController* controller)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       favicon_hiding_offset_(0),
       loading_animation_frame_(0),
       immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
       animating_media_state_(TAB_MEDIA_STATE_NONE),
-      close_button_(NULL),
-      title_(new views::Label()),
       tab_activated_with_last_gesture_begin_(false),
       hover_controller_(this),
       showing_icon_(false),
       showing_media_indicator_(false),
       showing_close_button_(false),
       close_button_color_(0) {
   DCHECK(controller);
   InitTabResources();
 
   // So we get don't get enter/exit on children and don't prematurely stop the
   // hover.
   set_notify_enter_exit_on_child(true);
 
   set_id(VIEW_ID_TAB);
 
-  title_->set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
-  title_->SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
-  title_->SetElideBehavior(gfx::FADE_TAIL);
-
   // Add the Close Button.
   close_button_ = new TabCloseButton(this);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   close_button_->SetImage(views::CustomButton::STATE_NORMAL,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1));
   close_button_->SetImage(views::CustomButton::STATE_HOVERED,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1_H));
   close_button_->SetImage(views::CustomButton::STATE_PRESSED,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1_P));
   close_button_->SetAccessibleName(
@@ skipping 22 matching lines @@
   return controller_->IsTabSelected(this);
 }
 
 void Tab::SetData(const TabRendererData& data) {
   if (data_.Equals(data))
     return;
 
   TabRendererData old(data_);
   data_ = data;
 
-  base::string16 title = data_.title;
-  if (title.empty()) {
-    title = data_.loading ?
-        l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) :
-        CoreTabHelper::GetDefaultTitle();
-  } else {
-    Browser::FormatTitleForDisplay(&title);
-  }
-  title_->SetText(title);
-
   if (data_.IsCrashed()) {
     if (!should_display_crashed_favicon_ && !IsPerformingCrashAnimation()) {
       data_.media_state = TAB_MEDIA_STATE_NONE;
 #if defined(OS_CHROMEOS)
       // On Chrome OS, we reload killed tabs automatically when the user
       // switches to them.  Don't display animations for these unless they're
       // selected (i.e. in the foreground) -- we won't reload these
       // automatically since we don't want to get into a crash loop.
       if (IsSelected() ||
           data_.crashed_status != base::TERMINATION_STATUS_PROCESS_WAS_KILLED)
@@ skipping 216 matching lines @@
 
 void Tab::Layout() {
   gfx::Rect lb = GetContentsBounds();
   if (lb.IsEmpty())
     return;
   lb.Inset(kLeftPadding, kTopPadding, kRightPadding, kBottomPadding);
 
   // The height of the content of the Tab is the largest of the favicon,
   // the title text and the close button graphic.
   const int kTabIconSize = gfx::kFaviconSize;
-  const int font_height = title_->font_list().GetHeight();
-  int content_height = std::max(kTabIconSize, font_height);
+  int content_height = std::max(kTabIconSize, font_height_);
   close_button_->SetBorder(views::Border::NullBorder());
   gfx::Size close_button_size(close_button_->GetPreferredSize());
   content_height = std::max(content_height, close_button_size.height());
 
   // Size the Favicon.
   showing_icon_ = ShouldShowIcon();
   if (showing_icon_) {
     // Use the size of the favicon as apps use a bigger favicon size.
     int favicon_top = kTopPadding + content_height / 2 - kTabIconSize / 2;
     int favicon_left = lb.x();
@@ skipping 51 matching lines @@
         std::max(lb.x(), right - media_indicator_bounds_.width()));
     MaybeAdjustLeftForMiniTab(&media_indicator_bounds_);
   } else {
     media_indicator_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   }
 
   const int title_text_offset = is_host_desktop_type_ash ?
       kTitleTextOffsetYAsh : kTitleTextOffsetY;
   int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
   int title_top = kTopPadding + title_text_offset +
-      (content_height - font_height) / 2;
-  gfx::Rect title_bounds(title_left, title_top, 0, 0);
+      (content_height - font_height_) / 2;
   // Size the Title text to fill the remaining space.
   if (!data().mini || width() >= kMiniTabRendererAsNormalTabWidth) {
     // If the user has big fonts, the title will appear rendered too far down
     // on the y-axis if we use the regular top padding, so we need to adjust it
     // so that the text appears centered.
     gfx::Size minimum_size = GetMinimumUnselectedSize();
-    int text_height = title_top + font_height + kBottomPadding;
+    int text_height = title_top + font_height_ + kBottomPadding;
     if (text_height > minimum_size.height())
       title_top -= (text_height - minimum_size.height()) / 2;
 
     int title_width;
     if (showing_media_indicator_) {
       title_width = media_indicator_bounds_.x() - kTitleCloseButtonSpacing -
           title_left;
     } else if (close_button_->visible()) {
       // The close button has an empty border with some padding (see details
       // above where the close-button's bounds is set). Allow the title to
       // overlap the empty padding.
       title_width = close_button_->x() + close_button_->GetInsets().left() -
           kTitleCloseButtonSpacing - title_left;
     } else {
       title_width = lb.width() - title_left;
     }
     title_width = std::max(title_width, 0);
-    title_bounds.SetRect(title_left, title_top, title_width, font_height);
+    title_bounds_.SetRect(title_left, title_top, title_width, font_height_);
+  } else {
+    title_bounds_.SetRect(title_left, title_top, 0, 0);
   }
 
-  title_bounds.set_x(GetMirroredXForRect(title_bounds));
-  title_->SetBoundsRect(title_bounds);
+  // Certain UI elements within the Tab (the favicon, etc.) are not represented
+  // as child Views (which is the preferred method).  Instead, these UI elements
+  // are drawn directly on the canvas from within Tab::OnPaint(). The Tab's
+  // child Views (for example, the Tab's close button which is a views::Button
+  // instance) are automatically mirrored by the mirroring infrastructure in
+  // views. The elements Tab draws directly on the canvas need to be manually
+  // mirrored if the View's layout is right-to-left.
+  title_bounds_.set_x(GetMirroredXForRect(title_bounds_));
 }
 
 void Tab::OnThemeChanged() {
   LoadTabImages();
 }
 
 const char* Tab::GetClassName() const {
   return kViewClassName;
 }
 
@@ skipping 24 matching lines @@
 }
 
 bool Tab::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
   // Note: Anything that affects the tooltip text should be accounted for when
   // calling TooltipTextChanged() from Tab::DataChanged().
   *tooltip = chrome::AssembleTabTooltipText(data_.title, data_.media_state);
   return !tooltip->empty();
 }
 
 bool Tab::GetTooltipTextOrigin(const gfx::Point& p, gfx::Point* origin) const {
-  origin->set_x(title_->x() + 10);
+  origin->set_x(title_bounds_.x() + 10);
   origin->set_y(-views::TooltipManager::GetTooltipHeight() - 4);
   return true;
 }
 
 bool Tab::OnMousePressed(const ui::MouseEvent& event) {
   controller_->OnMouseEventInTab(this, event);
 
   // Allow a right click from touch to drag, which corresponds to a long click.
   if (event.IsOnlyLeftMouseButton() ||
       (event.IsOnlyRightMouseButton() && event.flags() & ui::EF_FROM_TOUCH)) {
@@ skipping 122 matching lines @@
 }
 
 void Tab::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TAB;
   state->name = data_.title;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private
 
+const gfx::Rect& Tab::GetTitleBounds() const {
+  return title_bounds_;
+}
+
+const gfx::Rect& Tab::GetIconBounds() const {
+  return favicon_bounds_;
+}
+
 void Tab::MaybeAdjustLeftForMiniTab(gfx::Rect* bounds) const {
   if (!data().mini || width() >= kMiniTabRendererAsNormalTabWidth)
     return;
   const int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth();
   const int ideal_delta = width() - GetMiniWidth();
   const int ideal_x = (GetMiniWidth() - bounds->width()) / 2;
   bounds->set_x(bounds->x() + static_cast<int>(
       (1 - static_cast<float>(ideal_delta) / static_cast<float>(mini_delta)) *
       (ideal_x - bounds->x())));
 }
@@ skipping 17 matching lines @@
   const bool show_media_indicator = ShouldShowMediaIndicator();
   const bool show_close_button = ShouldShowCloseBox();
   if (show_icon != showing_icon_ ||
       show_media_indicator != showing_media_indicator_ ||
       show_close_button != showing_close_button_) {
     Layout();
   }
 
   PaintTabBackground(canvas);
 
-  const SkColor title_color = GetThemeProvider()->GetColor(IsSelected() ?
-      ThemeProperties::COLOR_TAB_TEXT :
-      ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
-  if (!data().mini || width() > kMiniTabRendererAsNormalTabWidth) {
-    title_->SetEnabledColor(title_color);
-    title_->Paint(canvas, views::CullSet());
-  }
+  SkColor title_color = GetThemeProvider()->
+      GetColor(IsSelected() ?
+          ThemeProperties::COLOR_TAB_TEXT :
+          ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
+
+  if (!data().mini || width() > kMiniTabRendererAsNormalTabWidth)
+    PaintTitle(canvas, title_color);
 
   if (show_icon)
     PaintIcon(canvas);
 
   if (show_media_indicator)
     PaintMediaIndicator(canvas);
 
   // If the close button color has changed, generate a new one.
   if (!close_button_color_ || title_color != close_button_color_) {
     close_button_color_ = title_color;
@@ skipping 276 matching lines @@
      height() - kDropShadowHeight);
 
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawImageInt(*tab_image->image_l, 0, 0);
   canvas->TileImageInt(*tab_image->image_c, tab_image->l_width, 0,
       width() - tab_image->l_width - tab_image->r_width, height());
   canvas->DrawImageInt(*tab_image->image_r, width() - tab_image->r_width, 0);
 }
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
-  gfx::Rect bounds = favicon_bounds_;
+  gfx::Rect bounds = GetIconBounds();
   if (bounds.IsEmpty())
     return;
 
   bounds.set_x(GetMirroredXForRect(bounds));
 
   if (data().network_state != TabRendererData::NETWORK_STATE_NONE) {
     // Paint network activity (aka throbber) animation frame.
     ui::ThemeProvider* tp = GetThemeProvider();
     gfx::ImageSkia frames(*tp->GetImageSkiaNamed(
         (data().network_state == TabRendererData::NETWORK_STATE_WAITING) ?
         IDR_THROBBER_WAITING : IDR_THROBBER));
 
     int icon_size = frames.height();
     int image_offset = loading_animation_frame_ * icon_size;
     DrawIconCenter(canvas, frames, image_offset,
                    icon_size, icon_size,
                    bounds, false, SkPaint());
   } else if (should_display_crashed_favicon_) {
     // Paint crash favicon.
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia crashed_favicon(*rb.GetImageSkiaNamed(IDR_SAD_FAVICON));
     bounds.set_y(bounds.y() + favicon_hiding_offset_);
     DrawIconCenter(canvas, crashed_favicon, 0,
-                   crashed_favicon.width(),
-                   crashed_favicon.height(),
-                   bounds, true, SkPaint());
+                    crashed_favicon.width(),
+                    crashed_favicon.height(),
+                    bounds, true, SkPaint());
   } else if (!data().favicon.isNull()) {
     // Paint the normal favicon.
     DrawIconCenter(canvas, data().favicon, 0,
                    data().favicon.width(),
                    data().favicon.height(),
                    bounds, true, SkPaint());
   }
 }
 
 void Tab::PaintMediaIndicator(gfx::Canvas* canvas) {
@@ skipping 11 matching lines @@
   paint.setAlpha(opaqueness * SK_AlphaOPAQUE);
 
   const gfx::ImageSkia& media_indicator_image =
       *(chrome::GetTabMediaIndicatorImage(animating_media_state_).
             ToImageSkia());
   DrawIconAtLocation(canvas, media_indicator_image, 0,
                      bounds.x(), bounds.y(), media_indicator_image.width(),
                      media_indicator_image.height(), true, paint);
 }
 
+void Tab::PaintTitle(gfx::Canvas* canvas, SkColor title_color) {
+  // Paint the Title.
+  base::string16 title = data().title;
+  if (title.empty()) {
+    title = data().loading ?
+        l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) :
+        CoreTabHelper::GetDefaultTitle();
+  } else {
+    Browser::FormatTitleForDisplay(&title);
+  }
+
+  canvas->DrawFadedString(title, gfx::FontList(*font_), title_color,
+                          GetTitleBounds(), 0);
+}
+
 void Tab::AdvanceLoadingAnimation(TabRendererData::NetworkState old_state,
                                   TabRendererData::NetworkState state) {
   static bool initialized = false;
   static int loading_animation_frame_count = 0;
   static int waiting_animation_frame_count = 0;
   static int waiting_to_loading_frame_count_ratio = 0;
   if (!initialized) {
     initialized = true;
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia loading_animation(*rb.GetImageSkiaNamed(IDR_THROBBER));
@@ skipping 122 matching lines @@
 }
 
 void Tab::StartMediaIndicatorAnimation() {
   media_indicator_animation_ =
       chrome::CreateTabMediaIndicatorFadeAnimation(data_.media_state);
   media_indicator_animation_->set_delegate(this);
   media_indicator_animation_->Start();
 }
 
 void Tab::ScheduleIconPaint() {
-  gfx::Rect bounds = favicon_bounds_;
+  gfx::Rect bounds = GetIconBounds();
   if (bounds.IsEmpty())
     return;
 
-  // Extends the area to the bottom when sad_favicon is animating.
+  // Extends the area to the bottom when sad_favicon is
+  // animating.
   if (IsPerformingCrashAnimation())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // The main bar is as wide as the normal tab's horizontal top line.
   // This top line of the tab extends a few pixels left and right of the
   // center image due to pixels in the rounded corner images.
@@ skipping 23 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private static:
 
 // static
 void Tab::InitTabResources() {
   static bool initialized = false;
   if (initialized)
     return;
 
   initialized = true;
+
+  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+  font_ = new gfx::Font(rb.GetFont(ui::ResourceBundle::BaseFont));
+  font_height_ = font_->GetHeight();
+
   image_cache_ = new ImageCache();
 
   // Load the tab images once now, and maybe again later if the theme changes.
   LoadTabImages();
 }
 
 // static
 void Tab::LoadTabImages() {
   // We're not letting people override tab images just yet.
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
@@ skipping 34 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }