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 UnifySameSizedColumnSizes(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::UnifySameSizedColumnSizes(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);
+  for (auto* column : same_size_columns_) {
+    if (column->Size() <= size_limit)
+      column->SetSize(size);

[Peter Kasting, 2017/03/07 02:50:37]

Nit: Or (allows not adding {}):

    column->SetSize(std::max(size, column->Size()));

[tapted, 2017/03/07 12:06:41]

Done. (I suppose we should rename: SetSize -> set_size so it doesn't suggest
there are side-effects, but that's quite a bit of fallout)

+  }
 }
 
 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) {}

[Peter Kasting, 2017/03/07 02:50:37]

Nit: I wonder if it makes any sense for readability/maintainability/caller
convenience to treat 0 as "there is no limit".

[tapted, 2017/03/07 12:06:41]

0 is convenient for other things (i.e. effectively "unlinking" columns). -1
might work, but I like the arithmetic neatness of INT_MAX, so it might make
sense to still set the member to INT_MAX, but accept -1 in
set_linked_column_size_limit. (leaving this for now).

[Peter Kasting, 2017/03/07 21:22:49]

Oh, do we actually use that?  I figured allowing callers to do that was a
bug-not-feature as it could be confusing to readers.  But maybe we want it.
Yeah, if 0 doesn't work, I'm fine leaving INT_MAX alone.

[tapted, 2017/03/07 22:39:19]

Yup, that's the approach here for collected cookies: the non-harmony layout
delegate returns 0 for the linked button max width, so there's no need to
additionally wrap the LinkColumnSizes(0, 2, -1) call in IsSecondaryUIMaterial(),
since the size linking is effectively disabled.

 
 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 110 matching lines @@
     }
     // 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() {
   for (auto* column : master_columns_)
-    column->UnifySameSizedColumnSizes();
+    column->UnifySameSizedColumnSizes(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 509 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