When the chrome window is maximized, make sure the new tab button extends

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

 // Copyright (c) 2011 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_strip.h"
 
 #include <algorithm>
 #include <iterator>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/stl_util-inl.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/tabs/tab_strip_selection_model.h"
 #include "chrome/browser/themes/theme_service.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 43 matching lines @@
 
 namespace {
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabButton
 //
 //  A subclass of button that hit-tests to the shape of the new tab button.
 
 class NewTabButton : public views::ImageButton {
  public:
-  explicit NewTabButton(views::ButtonListener* listener)
-      : views::ImageButton(listener) {
+  explicit NewTabButton(TabStrip* tab_strip, views::ButtonListener* listener)
+      : views::ImageButton(listener), tab_strip_(tab_strip) {
   }
   virtual ~NewTabButton() {}
 
  protected:
   // Overridden from views::View:
   virtual bool HasHitTestMask() const {
     // When the button is sized to the top of the tab strip we want the user to
     // be able to click on complete bounds, and so don't return a custom hit
     // mask.
-    return !browser_defaults::kSizeTabButtonToTopOfTabStrip;
+    return !tab_strip_->SizeTabButtonToTopOfTabStrip();
   }
   virtual void GetHitTestMask(gfx::Path* path) const {
     DCHECK(path);
 
     SkScalar w = SkIntToScalar(width());
 
     // These values are defined by the shape of the new tab bitmap. Should that
     // bitmap ever change, these values will need to be updated. They're so
     // custom it's not really worth defining constants for.
     path->moveTo(0, 1);
     path->lineTo(w - 7, 1);
     path->lineTo(w - 4, 4);
     path->lineTo(w, 16);
     path->lineTo(w - 1, 17);
     path->lineTo(7, 17);
     path->lineTo(4, 13);
     path->lineTo(0, 1);
     path->close();
   }
 
  private:
+  // Tab strip that contains this button.
+  TabStrip* tab_strip_;
+
   DISALLOW_COPY_AND_ASSIGN(NewTabButton);
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const int TabStrip::mini_to_non_mini_gap_ = 3;
 
-TabStrip::TabStrip(TabStripController* controller)
+TabStrip::TabStrip(Browser* browser, TabStripController* controller)
     : BaseTabStrip(controller, BaseTabStrip::HORIZONTAL_TAB_STRIP),
       newtab_button_(NULL),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
-      animation_container_(new ui::AnimationContainer()) {
+      animation_container_(new ui::AnimationContainer()),
+      browser_(browser) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   // The animations may reference the tabs. Shut down the animation before we
   // delete the tabs.
   StopAnimating(false);
 
   DestroyDragController();
 
   // Make sure we unhook ourselves as a message loop observer so that we don't
   // crash in the case where the user closes the window after closing a tab
   // but before moving the mouse.
   RemoveMessageLoopObserver();
 
   // The children (tabs) may callback to us from their destructor. Delete them
   // so that if they call back we aren't in a weird state.
   RemoveAllChildViews(true);
 }
 
 void TabStrip::InitTabStripButtons() {
-  newtab_button_ = new NewTabButton(this);
-  if (browser_defaults::kSizeTabButtonToTopOfTabStrip) {
-    newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                      views::ImageButton::ALIGN_BOTTOM);
-  }
+  newtab_button_ = new NewTabButton(this, this);
   LoadNewTabButtonImage();
   newtab_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
   AddChildView(newtab_button_);
 }
 
 gfx::Rect TabStrip::GetNewTabButtonBounds() {
   return newtab_button_->bounds();
 }
 
@@ skipping 306 matching lines @@
 }
 
 bool TabStrip::ShouldHighlightCloseButtonAfterRemove() {
   return in_tab_close_;
 }
 
 void TabStrip::DoLayout() {
   BaseTabStrip::DoLayout();
 
   // It is possible we don't have a new tab button yet.
-  if (newtab_button_)
+  if (newtab_button_) {
+    if (SizeTabButtonToTopOfTabStrip()) {
+      newtab_button_bounds_.set_height(
+          kNewTabButtonHeight + kNewTabButtonVOffset);
+      newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
+                                        views::ImageButton::ALIGN_BOTTOM);
+    } else {
+      newtab_button_bounds_.set_height(kNewTabButtonHeight);
+      newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
+                                        views::ImageButton::ALIGN_TOP);
+    }
     newtab_button_->SetBoundsRect(newtab_button_bounds_);
+  }
 }
 
 void TabStrip::LayoutDraggedTabsAt(const std::vector<BaseTab*>& tabs,
                                    BaseTab* active_tab,
                                    const gfx::Point& location,
                                    bool initial_drag) {
   std::vector<gfx::Rect> bounds;
   CalculateBoundsForDraggedTabs(tabs, &bounds);
   DCHECK_EQ(tabs.size(), bounds.size());
   int active_tab_model_index = GetModelIndexOfBaseTab(active_tab);
@@ skipping 59 matching lines @@
   if (sender == newtab_button_)
     controller()->CreateNewTab();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   newtab_button_bounds_.SetRect(0, 0, kNewTabButtonWidth, kNewTabButtonHeight);
-  if (browser_defaults::kSizeTabButtonToTopOfTabStrip) {
-    newtab_button_bounds_.set_height(
-        kNewTabButtonHeight + kNewTabButtonVOffset);
-  }
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     SkBitmap* drop_image = GetDropArrowImage(true);
     drop_indicator_width = drop_image->width();
     drop_indicator_height = drop_image->height();
   }
 }
 
+bool TabStrip::SizeTabButtonToTopOfTabStrip() {
+  if (browser_defaults::kSizeTabButtonToTopOfTabStrip)
+    return true;
+
+  if (browser_ && browser_->window())
+    return browser_->window()->IsMaximized();
+
+  return false;
+}
+
 void TabStrip::LoadNewTabButtonImage() {
   ui::ThemeProvider* tp = GetThemeProvider();
 
   // If we don't have a theme provider yet, it means we do not have a
   // root view, and are therefore in a test.
   bool in_test = false;
   if (tp == NULL) {
     tp = new views::DefaultThemeProvider();
     in_test = true;
   }
@@ skipping 344 matching lines @@
       set_ideal_bounds(i,
           gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height));
       tab_x = end_of_tab + kTabHOffset;
       last_was_mini = tab->data().mini;
     }
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
-  int new_tab_y = browser_defaults::kSizeTabButtonToTopOfTabStrip ?
-      0 : kNewTabButtonVOffset;
+  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : kNewTabButtonVOffset;
   if (abs(Round(unselected) - Tab::GetStandardSize().width()) > 1 &&
       !in_tab_close_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
     new_tab_x = width() - newtab_button_bounds_.width();
   } else {
     new_tab_x = Round(tab_x - kTabHOffset) + kNewTabButtonHOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
@@ skipping 73 matching lines @@
   }
   return mini_count;
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }