Implement Harmony-style consistent button widths for Collected Cookies.

ui/views/layout/grid_layout.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 "ui/views/layout/grid_layout.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 168 matching lines @@
   void ResetSize() override;
 
  private:
   friend class ColumnSet;
   friend class GridLayout;
 
   Column* GetLastMasterColumn();
 
   // Determines the max size of all linked columns, and sets each column
   // to that size. This should only be used for the master column.
-  void UnifySameSizedColumnSizes();
+  void UnifyLinkedColumnSizes(int size_limit);
 
   void AdjustSize(int size) override;
 
   const GridLayout::Alignment h_align_;
   const GridLayout::Alignment v_align_;
   const GridLayout::SizeType size_type_;
   int same_size_column_;
   const int fixed_width_;
   const int min_width_;
 
@@ skipping 24 matching lines @@
 Column* Column::GetLastMasterColumn() {
   if (master_column_ == nullptr) {
     return nullptr;
   }
   if (master_column_ == this) {
     return this;
   }
   return master_column_->GetLastMasterColumn();
 }
 
-void Column::UnifySameSizedColumnSizes() {
+void Column::UnifyLinkedColumnSizes(int size_limit) {
   DCHECK(master_column_ == this);
 
   // Accumulate the size first.
   int size = 0;
-  for (auto* column : same_size_columns_)
-    size = std::max(size, column->Size());
+  for (auto* column : same_size_columns_) {
+    if (column->Size() <= size_limit)
+      size = std::max(size, column->Size());
+  }
 
   // Then apply it.
   for (auto* column : same_size_columns_)
-    column->SetSize(size);
+    column->SetSize(std::max(size, column->Size()));
 }
 
 void Column::AdjustSize(int size) {
   if (size_type_ == GridLayout::USE_PREF)
     LayoutElement::AdjustSize(size);
 }
 
 // Row -------------------------------------------------------------
 
 class Row : public LayoutElement {
@@ skipping 103 matching lines @@
   return v1->col_span < v2->col_span;
 }
 
 static bool CompareByRowSpan(const std::unique_ptr<ViewState>& v1,
                              const ViewState* v2) {
   return v1->row_span < v2->row_span;
 }
 
 // ColumnSet -------------------------------------------------------------
 
-ColumnSet::ColumnSet(int id) : id_(id) {
-}
+ColumnSet::ColumnSet(int id) : id_(id), linked_column_size_limit_(INT_MAX) {}
 
 ColumnSet::~ColumnSet() {
 }
 
 void ColumnSet::AddPaddingColumn(float resize_percent, int width) {
   AddColumn(GridLayout::FILL, GridLayout::FILL, resize_percent,
             GridLayout::FIXED, width, width, true);
 }
 
 void ColumnSet::AddColumn(GridLayout::Alignment h_align,
@@ skipping 108 matching lines @@
                   master_column) == master_columns_.end()) {
       master_columns_.push_back(master_column);
     }
     // At this point, GetLastMasterColumn may not == master_column
     // (may have to go through a few Columns)_. Reset master_column to
     // avoid hops.
     column->master_column_ = master_column;
   }
 }
 
-void ColumnSet::UnifySameSizedColumnSizes() {
+void ColumnSet::UnifyLinkedColumnSizes() {
   for (auto* column : master_columns_)
-    column->UnifySameSizedColumnSizes();
+    column->UnifyLinkedColumnSizes(linked_column_size_limit_);
 }
 
 void ColumnSet::UpdateRemainingWidth(ViewState* view_state) {
   for (int i = view_state->start_col,
        max_col = view_state->start_col + view_state->col_span;
        i < max_col; ++i) {
     view_state->remaining_width -= columns_[i]->Size();
   }
 }
 
@@ skipping 91 matching lines @@
   auto view_state_iterator = view_states_.begin();
   for (; view_state_iterator != view_states_.end() &&
          (*view_state_iterator)->col_span == 1; ++view_state_iterator) {
     ViewState* view_state = *view_state_iterator;
     Column* column = columns_[view_state->start_col].get();
     column->AdjustSize(view_state->pref_width);
     view_state->remaining_width -= column->Size();
   }
 
   // Make sure all linked columns have the same size.
-  UnifySameSizedColumnSizes();
+  UnifyLinkedColumnSizes();
 
   // Distribute the size of each view with a column span > 1.
   for (; view_state_iterator != view_states_.end(); ++view_state_iterator) {
     ViewState* view_state = *view_state_iterator;
 
     // Update the remaining_width from columns this view_state touches.
     UpdateRemainingWidth(view_state);
 
     // Distribute the remaining width.
     DistributeRemainingWidth(view_state);
 
     // Update the size of linked columns.
     // This may need to be combined with previous step.
-    UnifySameSizedColumnSizes();
+    UnifyLinkedColumnSizes();
   }
 }
 
 void ColumnSet::Resize(int delta) {
   LayoutElement::DistributeDelta(delta, &columns_);
 }
 
 // GridLayout -------------------------------------------------------------
 
 GridLayout::GridLayout(View* host)
@@ skipping 383 matching lines @@
 
 ColumnSet* GridLayout::GetLastValidColumnSet() {
   for (int i = current_row_ - 1; i >= 0; --i) {
     if (rows_[i]->column_set())
       return rows_[i]->column_set();
   }
   return nullptr;
 }
 
 }  // namespace views