Fix task manager's default sizing.

ui/views/controls/table/table_view.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/controls/table/table_view.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 119 matching lines @@
                      TableTypes table_type,
                      bool single_selection)
     : model_(NULL),
       columns_(columns),
       header_(NULL),
       table_type_(table_type),
       single_selection_(single_selection),
       select_on_remove_(true),
       table_view_observer_(NULL),
       row_height_(font_list_.GetHeight() + kTextVerticalPadding * 2),
-      last_parent_width_(0),
-      layout_width_(0),
       grouper_(NULL),
       in_set_visible_column_width_(false) {
   for (size_t i = 0; i < columns.size(); ++i) {
     VisibleColumn visible_column;
     visible_column.column = columns[i];
     visible_columns_.push_back(visible_column);
   }
   // Always focusable, even on Mac (consistent with NSTableView).
   SetFocusBehavior(FocusBehavior::ALWAYS);
   SetModel(model);
@@ skipping 158 matching lines @@
 int TableView::ViewToModel(int view_index) const {
   if (!is_sorted())
     return view_index;
   DCHECK_GE(view_index, 0) << " negative view_index " << view_index;
   DCHECK_LT(view_index, RowCount()) << " out of bounds view_index " <<
       view_index;
   return view_to_model_[view_index];
 }
 
 void TableView::Layout() {
-  // parent()->parent() is the scrollview. When its width changes we force
-  // recalculating column sizes.
-  View* scroll_view = parent() ? parent()->parent() : NULL;
-  if (scroll_view) {
-    const int scroll_view_width = scroll_view->GetContentsBounds().width();
-    if (scroll_view_width != last_parent_width_) {
-      last_parent_width_ = scroll_view_width;
-      if (!in_set_visible_column_width_) {
-        // Layout to the parent (the Viewport), which differs from
-        // |scroll_view_width| when scrollbars are present.
-        layout_width_ = parent()->width();
-        UpdateVisibleColumnSizes();
-      }
-    }
-  }
+  View* viewport = parent();
+  if (viewport && width() != viewport->width() && !in_set_visible_column_width_)

[sky, 2016/09/16 21:28:58]

I believe your change will result in forcing a call to UpdateVisibleColumnSizes
every time Layout is called if the preferred width is > viewport->width().

[Evan Stade, 2016/09/22 16:19:13]

I guess that's right. We're already calling it every time the parent size
changes even though we don't need to when there's a horizontal scrollbar, but I
guess in the case where Layout() is called multiple times without a change to
parent size this is now doing extra work. Fixed.

+    UpdateVisibleColumnSizes();
   // We have to override Layout like this since we're contained in a ScrollView.
   gfx::Size pref = GetPreferredSize();
-  int width = pref.width();
-  int height = pref.height();
-  if (parent()) {
-    width = std::max(parent()->width(), width);
-    height = std::max(parent()->height(), height);
-  }
-  SetBounds(x(), y(), width, height);
+  if (viewport)
+    pref.SetToMax(viewport->size());
+  SetSize(pref);
 }
 
 const char* TableView::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Size TableView::GetPreferredSize() const {
   int width = 50;
   if (header_ && !visible_columns_.empty())
     width = visible_columns_.back().x + visible_columns_.back().width;
@@ skipping 380 matching lines @@
   for (size_t i = 0; i < visible_columns_.size(); ++i)
     columns.push_back(visible_columns_[i].column);
 
   int first_column_padding = 0;
   if (table_type_ == ICON_AND_TEXT && header_)
     first_column_padding += kImageSize + kTextHorizontalPadding;
   if (grouper_)
     first_column_padding += kGroupingIndicatorSize + kTextHorizontalPadding;
 
   std::vector<int> sizes = views::CalculateTableColumnSizes(
-      layout_width_, first_column_padding, header_->font_list(), font_list_,
+      parent() ? parent()->width() : 0, first_column_padding,
+      header_->font_list(), font_list_,
       std::max(kTextHorizontalPadding, TableHeader::kHorizontalPadding) * 2,
       TableHeader::kSortIndicatorWidth, columns, model_);
   DCHECK_EQ(visible_columns_.size(), sizes.size());
   int x = 0;
   for (size_t i = 0; i < visible_columns_.size(); ++i) {
     visible_columns_[i].x = x;
     visible_columns_[i].width = sizes[i];
     x += sizes[i];
   }
 }
@@ skipping 202 matching lines @@
   if (tooltip)
     *tooltip = text;
   if (tooltip_origin) {
     tooltip_origin->SetPoint(cell_bounds.x(),
                              cell_bounds.y() + kTextVerticalPadding);
   }
   return true;
 }
 
 }  // namespace views