Attempt 2 at:

chrome/browser/views/tabs/base_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/views/tabs/base_tab.h"
 
 #include <limits>
 
 #include "app/animation_container.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "app/throb_animation.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/tabs/tab_controller.h"
 #include "chrome/common/chrome_switches.h"
 #include "gfx/canvas.h"
 #include "gfx/favicon_size.h"
 #include "gfx/font.h"
+#include "gfx/skbitmap_operations.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/controls/button/image_button.h"
 
 #ifdef WIN32
 #include "app/win_util.h"
 #endif
 
 // How long the pulse throb takes.
 static const int kPulseDurationMs = 200;
 
 // How long the hover state takes.
 static const int kHoverDurationMs = 90;
 
 static SkBitmap* waiting_animation_frames = NULL;
 static SkBitmap* loading_animation_frames = NULL;
 static int loading_animation_frame_count = 0;
 static int waiting_animation_frame_count = 0;
 static int waiting_to_loading_frame_count_ratio = 0;
 
 // Close button images.
 static SkBitmap* close_button_n = NULL;
 static SkBitmap* close_button_h = NULL;
 static SkBitmap* close_button_p = NULL;
 
 static SkBitmap* crashed_fav_icon = NULL;
 
-namespace {
-
 ////////////////////////////////////////////////////////////////////////////////
 // TabCloseButton
 //
 //  This is a Button subclass that causes middle clicks to be forwarded to the
 //  parent View by explicitly not handling them in OnMousePressed.
-class TabCloseButton : public views::ImageButton {
+class BaseTab::TabCloseButton : public views::ImageButton {
  public:
-  explicit TabCloseButton(views::ButtonListener* listener)
-      : views::ImageButton(listener) {
+  TabCloseButton(BaseTab* tab, bool show_mini_dot)
+      : views::ImageButton(tab),
+        tab_(tab),
+        is_mouse_near_(!show_mini_dot),
+        color_(0) {
   }
   virtual ~TabCloseButton() {}
 
+  // Sets the color used to derive the background color.
+  void SetColor(SkColor color) {
+    if (color_ == color)
+      return;
+
+    color_ = color;
+    // This is invoked from Paint, so we don't need to schedule a paint.
+    UpdateBackgroundImage(false);
+  }
+
+  // Invoked when the selected state changes.
+  void SelectedStateChanged() {
+    UpdateBackgroundImage(true);
+  }
+
   virtual bool OnMousePressed(const views::MouseEvent& event) {
     bool handled = ImageButton::OnMousePressed(event);
     // Explicitly mark midle-mouse clicks as non-handled to ensure the tab
     // sees them.
     return event.IsOnlyMiddleMouseButton() ? false : handled;
   }
 
   // We need to let the parent know about mouse state so that it
   // can highlight itself appropriately. Note that Exit events
   // fire before Enter events, so this works.
   virtual void OnMouseEntered(const views::MouseEvent& event) {
     CustomButton::OnMouseEntered(event);
     GetParent()->OnMouseEntered(event);
   }
 
   virtual void OnMouseExited(const views::MouseEvent& event) {
     CustomButton::OnMouseExited(event);
     GetParent()->OnMouseExited(event);
   }
 
+  virtual void OnMouseNear(const views::MouseEvent& event) {
+    is_mouse_near_ = true;
+    UpdateBackgroundImage(true);
+  }
+
+  virtual void OnMouseExitedNear(const views::MouseEvent& event) {
+    is_mouse_near_ = false;
+    UpdateBackgroundImage(true);
+  }
+
  private:
+  // Returns the image to use for the background.
+  static const SkBitmap& GetBackgroundImage(SkColor color, bool is_mouse_near) {
+    // All tabs share the same color, so we cache the bitmaps.
+    static SkColor cached_color = 0;
+    static SkBitmap* near_image = NULL;
+    static SkBitmap* far_image = NULL;
+    if (!near_image || cached_color != color) {
+      cached_color = color;
+      if (!near_image) {
+        near_image = new SkBitmap();
+        far_image = new SkBitmap();
+      }
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      *near_image = SkBitmapOperations::CreateButtonBackground(
+          color,
+          *rb.GetBitmapNamed(IDR_TAB_CLOSE),
+          *rb.GetBitmapNamed(IDR_TAB_CLOSE_MASK));
+      *far_image = SkBitmapOperations::CreateButtonBackground(
+          color,
+          *rb.GetBitmapNamed(IDR_TAB_CLOSE),
+          *rb.GetBitmapNamed(IDR_TAB_CLOSE_DOT_MASK));
+    }
+    return is_mouse_near ? *near_image : *far_image;
+  }
+
+  // Should we use the near image?
+  bool use_near_image() const { return is_mouse_near_ || tab_->IsSelected(); }
+
+  // Resets the background image.
+  void UpdateBackgroundImage(bool paint) {
+    set_background_image(GetBackgroundImage(color_, use_near_image()));
+    if (paint)
+      SchedulePaint();
+  }
+
+  BaseTab* tab_;
+
+  // Is the mouse near the close button?
+  bool is_mouse_near_;
+
+  // Color used to derive the background image from.
+  SkColor color_;
+
   DISALLOW_COPY_AND_ASSIGN(TabCloseButton);
 };
 
-}  // namespace
-
 // static
 int BaseTab::close_button_width_ = 0;
 // static
 int BaseTab::close_button_height_ = 0;
 // static
 int BaseTab::loading_animation_size_ = 0;
 
 // static
 gfx::Font* BaseTab::font_ = NULL;
 // static
@@ skipping 31 matching lines @@
   virtual void AnimationCanceled(const Animation* animation) {
     target_->SetFavIconHidingOffset(0);
   }
 
  private:
   BaseTab* target_;
 
   DISALLOW_COPY_AND_ASSIGN(FavIconCrashAnimation);
 };
 
-BaseTab::BaseTab(TabController* controller)
+BaseTab::BaseTab(TabController* controller, bool show_mini_dot)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       loading_animation_frame_(0),
       throbber_disabled_(false),
       theme_provider_(NULL),
       fav_icon_hiding_offset_(0),
       should_display_crashed_favicon_(false) {
   BaseTab::InitResources();
 
   // Add the Close Button.
-  TabCloseButton* close_button = new TabCloseButton(this);
+  TabCloseButton* close_button = new TabCloseButton(this, show_mini_dot);
   close_button_ = close_button;
   close_button->SetImage(views::CustomButton::BS_NORMAL, close_button_n);
   close_button->SetImage(views::CustomButton::BS_HOT, close_button_h);
   close_button->SetImage(views::CustomButton::BS_PUSHED, close_button_p);
   close_button->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_CLOSE_TAB));
   close_button->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_CLOSE));
   close_button->SetAnimationDuration(0);
   AddChildView(close_button);
 
   SetContextMenuController(this);
@@ skipping 56 matching lines @@
 }
 
 void BaseTab::StopPulse() {
   if (!pulse_animation_.get())
     return;
 
   pulse_animation_->Stop();  // Do stop so we get notified.
   pulse_animation_.reset(NULL);
 }
 
+void BaseTab::SelectedChanged() {
+  close_button_->SelectedStateChanged();
+}
+
 bool BaseTab::IsSelected() const {
   return controller() ? controller()->IsTabSelected(this) : true;
 }
 
 void BaseTab::OnMouseEntered(const views::MouseEvent& e) {
   if (!hover_animation_.get()) {
     hover_animation_.reset(new SlideAnimation(this));
     hover_animation_->SetContainer(animation_container_.get());
     hover_animation_->SetSlideDuration(kHoverDurationMs);
   }
@@ skipping 86 matching lines @@
   if (state != TabRendererData::NETWORK_STATE_NONE) {
     loading_animation_frame_ = ++loading_animation_frame_ %
         ((state == TabRendererData::NETWORK_STATE_WAITING) ?
             waiting_animation_frame_count : loading_animation_frame_count);
   } else {
     loading_animation_frame_ = 0;
   }
   SchedulePaint();
 }
 
+views::ImageButton* BaseTab::close_button() const {
+  return close_button_;
+}
+
+void BaseTab::SetCloseButtonColor(SkColor color) {
+  close_button_->SetColor(color);
+}
+
 void BaseTab::PaintIcon(gfx::Canvas* canvas, int x, int y) {
   if (base::i18n::IsRTL()) {
     if (!data().favicon.isNull())
       x = width() - x - data().favicon.width();
     else
       x = width() - x - kFavIconSize;
   }
 
   int favicon_x = x;
   if (!data().favicon.isNull() && data().favicon.width() != kFavIconSize)
@@ skipping 182 matching lines @@
   font_height_ = font_->height();
 }
 
 // static
 void BaseTab::LoadThemeImages() {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   loading_animation_frames = rb.GetBitmapNamed(IDR_THROBBER);
   waiting_animation_frames = rb.GetBitmapNamed(IDR_THROBBER_WAITING);
   loading_animation_size_ = loading_animation_frames->height();
 }