TabStrip Cleanup

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

 // Copyright (c) 2010 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 "app/multi_animation.h"
 #include "app/resource_bundle.h"
@@ skipping 35 matching lines @@
 // When a non-mini-tab becomes a mini-tab the width of the tab animates. If
 // the width of a mini-tab is >= kMiniTabRendererAsNormalTabWidth then the tab
 // is rendered as a normal tab. This is done to avoid having the title
 // immediately disappear when transitioning a tab from normal to mini-tab.
 static const int kMiniTabRendererAsNormalTabWidth =
     browser_defaults::kMiniTabWidth + 30;
 
 // How opaque to make the hover state (out of 1).
 static const double kHoverOpacity = 0.33;
 
-Tab::TabImage Tab::tab_alpha = {0};
-Tab::TabImage Tab::tab_active = {0};
-Tab::TabImage Tab::tab_inactive = {0};
+Tab::TabImage Tab::tab_alpha_ = {0};
+Tab::TabImage Tab::tab_active_ = {0};
+Tab::TabImage Tab::tab_inactive_ = {0};
 
 // Durations for the various parts of the mini tab title animation.
 static const int kMiniTitleChangeAnimationDuration1MS = 1600;
 static const int kMiniTitleChangeAnimationStart1MS = 0;
 static const int kMiniTitleChangeAnimationEnd1MS = 1900;
 static const int kMiniTitleChangeAnimationDuration2MS = 0;
 static const int kMiniTitleChangeAnimationDuration3MS = 550;
 static const int kMiniTitleChangeAnimationStart3MS = 150;
 static const int kMiniTitleChangeAnimationEnd3MS = 800;
 
 // Offset from the right edge for the start of the mini title change animation.
 static const int kMiniTitleChangeInitialXOffset = 6;
 
 // Radius of the radial gradient used for mini title change animation.
 static const int kMiniTitleChangeGradientRadius = 20;
 
 // Colors of the gradient used during the mini title change animation.
 static const SkColor kMiniTitleChangeGradientColor1 = SK_ColorWHITE;
 static const SkColor kMiniTitleChangeGradientColor2 =
     SkColorSetARGB(0, 255, 255, 255);
 
 // Hit mask constants.
 static const SkScalar kTabCapWidth = 15;
 static const SkScalar kTabTopCurveWidth = 4;
 static const SkScalar kTabBottomCurveWidth = 3;
 
-namespace {
-
-void InitTabResources() {
-  static bool initialized = false;
-  if (initialized)
-    return;
-
-  initialized = true;
-  Tab::LoadTabImages();
-}
-
-}  // namespace
-
 // static
 const char Tab::kViewClassName[] = "browser/tabs/Tab";
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, public:
 
 Tab::Tab(TabController* controller)
     : BaseTab(controller),
       showing_icon_(false),
       showing_close_button_(false),
@@ skipping 22 matching lines @@
     mini_title_animation_->set_delegate(this);
   }
   mini_title_animation_->Start();
 }
 
 void Tab::StopMiniTabTitleAnimation() {
   if (mini_title_animation_.get())
     mini_title_animation_->Stop();
 }
 
-void Tab::PaintIcon(gfx::Canvas* canvas) {
-  BaseTab::PaintIcon(canvas, favicon_bounds_.x(), favicon_bounds_.y());
-}
-
 // static
 gfx::Size Tab::GetMinimumUnselectedSize() {
   InitTabResources();
 
   gfx::Size minimum_size;
   minimum_size.set_width(kLeftPadding + kRightPadding);
   // Since we use bitmap images, the real minimum height of the image is
   // defined most accurately by the height of the end cap images.
-  minimum_size.set_height(tab_active.image_l->height());
+  minimum_size.set_height(tab_active_.image_l->height());
   return minimum_size;
 }
 
 // static
 gfx::Size Tab::GetMinimumSelectedSize() {
   gfx::Size minimum_size = GetMinimumUnselectedSize();
   minimum_size.set_width(kLeftPadding + kFavIconSize + kRightPadding);
   return minimum_size;
 }
 
@@ skipping 148 matching lines @@
   // as child Views (which is the preferred method).  Instead, these UI elements
   // are drawn directly on the canvas from within Tab::Paint(). 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(MirroredLeftPointForRect(title_bounds_));
 }
 
 void Tab::OnThemeChanged() {
-  Tab::LoadTabImages();
+  LoadTabImages();
 }
 
 bool Tab::HasHitTestMask() const {
   return true;
 }
 
 void Tab::GetHitTestMask(gfx::Path* path) const {
   DCHECK(path);
 
   SkScalar h = SkIntToScalar(height());
@@ skipping 28 matching lines @@
 void Tab::OnMouseMoved(const views::MouseEvent& e) {
   hover_point_ = e.location();
   // We need to redraw here because otherwise the hover glow does not update
   // and follow the new mouse position.
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private
 
+void Tab::PaintIcon(gfx::Canvas* canvas) {
+  BaseTab::PaintIcon(canvas, favicon_bounds_.x(), favicon_bounds_.y());
+}
+
 void Tab::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsSelected()) {
     PaintActiveTabBackground(canvas);
   } else {
     if (mini_title_animation_.get() && mini_title_animation_->is_animating())
       PaintInactiveTabBackgroundWithTitleChange(canvas);
     else
       PaintInactiveTabBackground(canvas);
 
     double throb_value = GetThrobValue();
@@ skipping 75 matching lines @@
   if (GetWidget() &&
       GetWidget()->GetWindow()->GetNonClientView()->UseNativeFrame()) {
     tab_id = IDR_THEME_TAB_BACKGROUND_V;
   } else {
     tab_id = is_otr ? IDR_THEME_TAB_BACKGROUND_INCOGNITO :
                       IDR_THEME_TAB_BACKGROUND;
   }
 
   SkBitmap* tab_bg = GetThemeProvider()->GetBitmapNamed(tab_id);
 
-  TabImage* tab_image = &tab_active;
-  TabImage* tab_inactive_image = &tab_inactive;
-  TabImage* alpha = &tab_alpha;
+  TabImage* tab_image = &tab_active_;
+  TabImage* tab_inactive_image = &tab_inactive_;
+  TabImage* alpha = &tab_alpha_;
 
   // If the theme is providing a custom background image, then its top edge
   // should be at the top of the tab. Otherwise, we assume that the background
   // image is a composited foreground + frame image.
   int bg_offset_y = GetThemeProvider()->HasCustomImage(tab_id) ?
       0 : background_offset_.y();
 
   // We need a CanvasSkia object to be able to extract the bitmap from.
   // We draw everything to this canvas and then output it to the canvas
   // parameter in addition to using it to mask the hover glow if needed.
@@ skipping 51 matching lines @@
                            tab_inactive_image->r_width,
                        height());
   canvas->DrawBitmapInt(*tab_inactive_image->image_r,
                         width() - tab_inactive_image->r_width, 0);
 }
 
 void Tab::PaintActiveTabBackground(gfx::Canvas* canvas) {
   int offset = GetX(views::View::APPLY_MIRRORING_TRANSFORMATION) +
       background_offset_.x();
   ThemeProvider* tp = GetThemeProvider();
-  if (!tp)
-    NOTREACHED() << "Unable to get theme provider";
+  DCHECK(tp) << "Unable to get theme provider";
 
   SkBitmap* tab_bg = GetThemeProvider()->GetBitmapNamed(IDR_THEME_TOOLBAR);
 
-  TabImage* tab_image = &tab_active;
-  TabImage* alpha = &tab_alpha;
+  TabImage* tab_image = &tab_active_;
+  TabImage* alpha = &tab_alpha_;
 
   // Draw left edge.
   SkBitmap tab_l = SkBitmapOperations::CreateTiledBitmap(
       *tab_bg, offset, 0, tab_image->l_width, height());
   SkBitmap theme_l =
       SkBitmapOperations::CreateMaskedBitmap(tab_l, *alpha->image_l);
   canvas->DrawBitmapInt(theme_l, 0, 0);
 
   // Draw right edge.
   SkBitmap tab_r = SkBitmapOperations::CreateTiledBitmap(*tab_bg,
@@ skipping 86 matching lines @@
     return pulse_animation()->GetCurrentValue() * kHoverOpacity;
 
   return hover_animation() ?
       kHoverOpacity * hover_animation()->GetCurrentValue() : 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private:
 
 // static
+void Tab::InitTabResources() {
+  static bool initialized = false;
+  if (initialized)
+    return;
+
+  initialized = true;
+
+  // 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.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
-  tab_alpha.image_l = rb.GetBitmapNamed(IDR_TAB_ALPHA_LEFT);
-  tab_alpha.image_r = rb.GetBitmapNamed(IDR_TAB_ALPHA_RIGHT);
+  tab_alpha_.image_l = rb.GetBitmapNamed(IDR_TAB_ALPHA_LEFT);
+  tab_alpha_.image_r = rb.GetBitmapNamed(IDR_TAB_ALPHA_RIGHT);
 
-  tab_active.image_l = rb.GetBitmapNamed(IDR_TAB_ACTIVE_LEFT);
-  tab_active.image_c = rb.GetBitmapNamed(IDR_TAB_ACTIVE_CENTER);
-  tab_active.image_r = rb.GetBitmapNamed(IDR_TAB_ACTIVE_RIGHT);
-  tab_active.l_width = tab_active.image_l->width();
-  tab_active.r_width = tab_active.image_r->width();
+  tab_active_.image_l = rb.GetBitmapNamed(IDR_TAB_ACTIVE_LEFT);
+  tab_active_.image_c = rb.GetBitmapNamed(IDR_TAB_ACTIVE_CENTER);
+  tab_active_.image_r = rb.GetBitmapNamed(IDR_TAB_ACTIVE_RIGHT);
+  tab_active_.l_width = tab_active_.image_l->width();
+  tab_active_.r_width = tab_active_.image_r->width();
 
-  tab_inactive.image_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
-  tab_inactive.image_c = rb.GetBitmapNamed(IDR_TAB_INACTIVE_CENTER);
-  tab_inactive.image_r = rb.GetBitmapNamed(IDR_TAB_INACTIVE_RIGHT);
-  tab_inactive.l_width = tab_inactive.image_l->width();
-  tab_inactive.r_width = tab_inactive.image_r->width();
+  tab_inactive_.image_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
+  tab_inactive_.image_c = rb.GetBitmapNamed(IDR_TAB_INACTIVE_CENTER);
+  tab_inactive_.image_r = rb.GetBitmapNamed(IDR_TAB_INACTIVE_RIGHT);
+  tab_inactive_.l_width = tab_inactive_.image_l->width();
+  tab_inactive_.r_width = tab_inactive_.image_r->width();
 }