Top Chrome MD cleanup - get rid of most of GetLayoutInsets.

chrome/browser/ui/views/toolbar/toolbar_view.cc

 // Copyright 2013 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/toolbar/toolbar_view.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
@@ skipping 88 matching lines @@
 #if !defined(OS_CHROMEOS)
 bool HasAshShell() {
 #if defined(USE_ASH)
   return ash::Shell::HasInstance();
 #else
   return false;
 #endif  // USE_ASH
 }
 #endif  // OS_CHROMEOS
 
+int GetToolbarHorizontalPadding() {
+  using Md = ui::MaterialDesignController;
+  return Md::GetMode() == Md::MATERIAL_HYBRID ? 8 : 4;
+}
+
 }  // namespace
 
 // static
 const char ToolbarView::kViewClassName[] = "ToolbarView";
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, public:
 
 ToolbarView::ToolbarView(Browser* browser)
     : back_(nullptr),
@@ skipping 405 matching lines @@
   // If the window is maximized, we extend the back button to the left so that
   // clicking on the left-most pixel will activate the back button.
   // TODO(abarth):  If the window becomes maximized but is not resized,
   //                then Layout() might not be called and the back button
   //                will be slightly the wrong size.  We should force a
   //                Layout() in this case.
   //                http://crbug.com/5540
   const bool maximized =
       browser_->window() && browser_->window()->IsMaximized();
   const int back_width = back_->GetPreferredSize().width();
-  const gfx::Insets insets(GetLayoutInsets(TOOLBAR));
+  // The padding at either end of the toolbar.
+  const int end_padding = GetToolbarHorizontalPadding();
   if (maximized) {
-    back_->SetBounds(0, child_y, back_width + insets.left(), child_height);
-    back_->SetLeadingMargin(insets.left());
+    back_->SetBounds(0, child_y, back_width + end_padding, child_height);
+    back_->SetLeadingMargin(end_padding);
   } else {
-    back_->SetBounds(insets.left(), child_y, back_width, child_height);
+    back_->SetBounds(end_padding, child_y, back_width, child_height);
     back_->SetLeadingMargin(0);
   }
   const int element_padding = GetLayoutConstant(TOOLBAR_ELEMENT_PADDING);
   int next_element_x = back_->bounds().right() + element_padding;
 
   forward_->SetBounds(next_element_x, child_y,
                       forward_->GetPreferredSize().width(), child_height);
   next_element_x = forward_->bounds().right() + element_padding;
 
   reload_->SetBounds(next_element_x, child_y,
@@ skipping 16 matching lines @@
   int app_menu_width = app_menu_button_->GetPreferredSize().width();
   const int right_padding =
       GetLayoutConstant(TOOLBAR_LOCATION_BAR_RIGHT_PADDING);
 
   // Note that the browser actions container has its own internal left and right
   // padding to visually separate it from the location bar and app menu button.
   // However if the container is empty we must account for the |right_padding|
   // value used to visually separate the location bar and app menu button.
   int available_width = std::max(
       0,
-      width() - insets.right() - app_menu_width -
+      width() - end_padding - app_menu_width -
       (browser_actions_->GetPreferredSize().IsEmpty() ? right_padding : 0) -
       next_element_x);
   // Don't allow the omnibox to shrink to the point of non-existence, so
   // subtract its minimum width from the available width to reserve it.
   const int browser_actions_width = browser_actions_->GetWidthForMaxWidth(
       available_width - location_bar_->GetMinimumSize().width());
   available_width -= browser_actions_width;
   const int location_bar_width = available_width;
 
   const int location_height = location_bar_->GetPreferredSize().height();
@@ skipping 14 matching lines @@
   // re-adds everything, regardless of whether it has a page action. For a
   // page action, browser action bounds do not change, as a result of which
   // SetBounds does not do a layout at all.
   // TODO(sidchat): Rework the above behavior so that explicit layout is not
   //                required.
   browser_actions_->Layout();
 
   // Extend the app menu to the screen's right edge in maximized mode just like
   // we extend the back button to the left edge.
   if (maximized)
-    app_menu_width += insets.right();
+    app_menu_width += end_padding;
   app_menu_button_->SetBounds(next_element_x, child_y, app_menu_width,
                               child_height);
-  app_menu_button_->SetTrailingMargin(maximized ? insets.right() : 0);
+  app_menu_button_->SetTrailingMargin(maximized ? end_padding : 0);
 }
 
 void ToolbarView::OnThemeChanged() {
   if (is_display_mode_normal())
     LoadImages();
 }
 
 const char* ToolbarView::GetClassName() const {
   return kViewClassName;
 }
@@ skipping 75 matching lines @@
 gfx::Size ToolbarView::GetSizeInternal(
     gfx::Size (View::*get_size)() const) const {
   gfx::Size size((location_bar_->*get_size)());
   if (is_display_mode_normal()) {
     const int element_padding = GetLayoutConstant(TOOLBAR_ELEMENT_PADDING);
     const int browser_actions_width =
         (browser_actions_->*get_size)().width();
     const int right_padding =
         GetLayoutConstant(TOOLBAR_LOCATION_BAR_RIGHT_PADDING);
     const int content_width =
-        GetLayoutInsets(TOOLBAR).width() +
-        (back_->*get_size)().width() + element_padding +
-        (forward_->*get_size)().width() + element_padding +
+        2 * GetToolbarHorizontalPadding() + (back_->*get_size)().width() +
+        element_padding + (forward_->*get_size)().width() + element_padding +
         (reload_->*get_size)().width() +
         (show_home_button_.GetValue()
              ? element_padding + (home_->*get_size)().width()
              : 0) +
         GetLayoutConstant(TOOLBAR_STANDARD_SPACING) +
         (browser_actions_width > 0 ? browser_actions_width : right_padding) +
         (app_menu_button_->*get_size)().width();
     size.Enlarge(content_width, 0);
   }
   return SizeForContentSize(size);
 }
 
 gfx::Size ToolbarView::SizeForContentSize(gfx::Size size) const {
   if (is_display_mode_normal()) {
     // The size of the toolbar is computed using the size of the location bar
     // and constant padding values.
     int content_height = std::max(back_->GetPreferredSize().height(),
                                   location_bar_->GetPreferredSize().height());
-    int padding = GetLayoutInsets(TOOLBAR).height();
-    size.SetToMax(gfx::Size(0, content_height + padding));
+    const int kExtraVerticalSpace = 9;
+    size.SetToMax(gfx::Size(0, content_height + kExtraVerticalSpace));
   }
   return size;
 }
 
 void ToolbarView::LoadImages() {
   const ui::ThemeProvider* tp = GetThemeProvider();
 
   const SkColor normal_color =
       tp->GetColor(ThemeProperties::COLOR_TOOLBAR_BUTTON_ICON);
   const SkColor disabled_color =
@@ skipping 35 matching lines @@
   if (OutdatedUpgradeBubbleView::IsAvailable()) {
     OutdatedUpgradeBubbleView::ShowBubble(app_menu_button_, browser_,
                                           auto_update_enabled);
   }
 }
 
 void ToolbarView::OnShowHomeButtonChanged() {
   Layout();
   SchedulePaint();
 }