Two changes to extension app icons:...

chrome/browser/views/tabs/tab_strip.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/tab_strip.h"
 
 #include "app/animation_container.h"
 #include "app/drag_drop_types.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
@@ skipping 220 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RemoveTabDelegate);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const int TabStrip::mini_to_non_mini_gap_ = 3;
 
+// static
+const int TabStrip::extra_gap_for_nano_ = 10;
+
 TabStrip::TabStrip(TabStripModel* model)
     : model_(model),
       resize_layout_factory_(this),
       added_as_message_loop_observer_(false),
       needs_resize_layout_(false),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       animation_container_(new AnimationContainer()),
       ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)),
@@ skipping 818 matching lines @@
 }
 
 void TabStrip::GetCurrentTabWidths(double* unselected_width,
                                    double* selected_width) const {
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 void TabStrip::GetDesiredTabWidths(int tab_count,
                                    int mini_tab_count,
+                                   int nano_tab_count,
                                    double* unselected_width,
                                    double* selected_width) const {
   DCHECK(tab_count >= 0 && mini_tab_count >= 0 && mini_tab_count <= tab_count);
+  DCHECK(nano_tab_count >= 0 && nano_tab_count <= tab_count);
   const double min_unselected_width = Tab::GetMinimumUnselectedSize().width();
   const double min_selected_width = Tab::GetMinimumSelectedSize().width();
 
   *unselected_width = min_unselected_width;
   *selected_width = min_selected_width;
 
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     return;
   }
@@ skipping 18 matching lines @@
 
   if (mini_tab_count > 0) {
     available_width -= mini_tab_count * (Tab::GetMiniWidth() + kTabHOffset);
     tab_count -= mini_tab_count;
     if (tab_count == 0) {
       *selected_width = *unselected_width = Tab::GetStandardSize().width();
       return;
     }
     // Account for gap between the last mini-tab and first non-mini-tab.
     available_width -= mini_to_non_mini_gap_;
+    // And add some extra space if you have nano tabs in the mix.
+    if (nano_tab_count > 0)
+      available_width -= extra_gap_for_nano_;
   }
 
   // Calculate the desired tab widths by dividing the available space into equal
   // portions.  Don't let tabs get larger than the "standard width" or smaller
   // than the minimum width for each type, respectively.
   const int total_offset = kTabHOffset * (tab_count - 1);
   const double desired_tab_width = std::min((static_cast<double>(
       available_width - total_offset) / static_cast<double>(tab_count)),
       static_cast<double>(Tab::GetStandardSize().width()));
   *unselected_width = std::max(desired_tab_width, min_unselected_width);
@@ skipping 39 matching lines @@
 
   available_width_for_tabs_ = -1;
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == GetTabCount()) {
     // Only mini-tabs, we know the tab widths won't have changed (all
     // mini-tabs have the same width), so there is nothing to do.
     return;
   }
   Tab* first_tab  = GetTabAtTabDataIndex(mini_tab_count);
   double unselected, selected;
-  GetDesiredTabWidths(GetTabCount(), mini_tab_count, &unselected, &selected);
+  GetDesiredTabWidths(GetTabCount(), mini_tab_count, GetNanoTabCount(),
+                      &unselected, &selected);
   int w = Round(first_tab->IsSelected() ? selected : selected);
 
   // We only want to run the animation if we're not already at the desired
   // size.
   if (abs(first_tab->width() - w) > 1)
     StartResizeLayoutAnimation();
 }
 
 bool TabStrip::IsCursorInTabStripZone() const {
   gfx::Rect bounds = GetLocalBounds(true);
@@ skipping 188 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 // Called from:
 // - BasicLayout
 // - Tab insertion/removal
 // - Tab reorder
 void TabStrip::GenerateIdealBounds() {
   int tab_count = GetTabCount();
   int non_closing_tab_count = 0;
   int mini_tab_count = 0;
+  int nano_tab_count = 0;
   for (int i = 0; i < tab_count; ++i) {
     if (!tab_data_[i].tab->closing()) {
       ++non_closing_tab_count;
       if (tab_data_[i].tab->mini())
         mini_tab_count++;
+      if (tab_data_[i].tab->app())
+        nano_tab_count++;
     }
   }
 
   double unselected, selected;
-  GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, &unselected,
-                      &selected);
+  GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, nano_tab_count,
+                      &unselected, &selected);
 
   current_unselected_width_ = unselected;
   current_selected_width_ = selected;
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   double tab_x = 0;
   bool last_was_mini = false;
   for (int i = 0; i < tab_count; ++i) {
     if (!tab_data_[i].tab->closing()) {
       Tab* tab = GetTabAtTabDataIndex(i);
       double tab_width = unselected;
       if (tab->mini()) {
         tab_width = Tab::GetMiniWidth();
       } else {
         if (last_was_mini) {
           // Give a bigger gap between mini and non-mini tabs.
           tab_x += mini_to_non_mini_gap_;
+          if (nano_tab_count > 0)
+            tab_x += extra_gap_for_nano_;
         }
         if (tab->IsSelected())
           tab_width = selected;
       }
       double end_of_tab = tab_x + tab_width;
       int rounded_tab_x = Round(tab_x);
       tab_data_[i].ideal_bounds =
           gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height);
       tab_x = end_of_tab + kTabHOffset;
@@ skipping 235 matching lines @@
   int mini_count = 0;
   for (size_t i = 0; i < tab_data_.size(); ++i) {
     if (tab_data_[i].tab->mini())
       mini_count++;
     else
       return mini_count;
   }
   return mini_count;
 }
 
+int TabStrip::GetNanoTabCount() const {
+  int nano_count = 0;
+  for (size_t i = 0; i < tab_data_.size(); ++i) {
+    if (tab_data_[i].tab->app())
+      nano_count++;
+    else
+      return nano_count;
+  }
+  return nano_count;
+}
+
 int TabStrip::GetAvailableWidthForTabs(Tab* last_tab) const {
   return last_tab->x() + last_tab->width();
 }
 
 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);
 }
@@ skipping 65 matching lines @@
   return tab_data_.size();
 }
 
 int TabStrip::TabDataIndexOfTab(Tab* tab) const {
   for (size_t i = 0; i < tab_data_.size(); ++i) {
     if (tab_data_[i].tab == tab)
       return i;
   }
   return -1;
 }