Create c/b/ui/views/layout_constants.*.

chrome/browser/ui/views/location_bar/location_bar_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 "chrome/browser/ui/views/location_bar/location_bar_view.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/i18n/rtl.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/location_bar_controller.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/translate/translate_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model.h"
 #include "chrome/browser/ui/passwords/manage_passwords_icon.h"
 #include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
+#include "chrome/browser/ui/views/layout_constants.h"
 #include "chrome/browser/ui/views/location_bar/content_setting_image_view.h"
 #include "chrome/browser/ui/views/location_bar/ev_bubble_view.h"
 #include "chrome/browser/ui/views/location_bar/keyword_hint_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_layout.h"
 #include "chrome/browser/ui/views/location_bar/location_icon_view.h"
 #include "chrome/browser/ui/views/location_bar/open_pdf_in_reader_view.h"
 #include "chrome/browser/ui/views/location_bar/page_action_image_view.h"
 #include "chrome/browser/ui/views/location_bar/page_action_with_badge_view.h"
 #include "chrome/browser/ui/views/location_bar/selected_keyword_view.h"
 #include "chrome/browser/ui/views/location_bar/star_view.h"
@@ skipping 157 matching lines @@
         font_list.DeriveWithSizeDelta(desired_font_size - current_font_size);
   }
   // Shrink large fonts to make them fit.
   // TODO(pkasting): Stretch the location bar instead in this case.
   const int location_height = GetInternalHeight(true);
   font_list = font_list.DeriveWithHeightUpperBound(location_height);
 
   // Determine the font for use inside the bubbles.  The bubble background
   // images have 1 px thick edges, which we don't want to overlap.
   const int kBubbleInteriorVerticalPadding = 1;
-  const int bubble_padding = GetThemeProvider()->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_BUBBLE_VERTICAL_PADDING);
   const int bubble_vertical_padding =
-      (bubble_padding + kBubbleInteriorVerticalPadding) * 2;
+      (GetLayoutConstant(LOCATION_BAR_BUBBLE_VERTICAL_PADDING) +
+          kBubbleInteriorVerticalPadding) * 2;
   const gfx::FontList bubble_font_list(font_list.DeriveWithHeightUpperBound(
       location_height - bubble_vertical_padding));
 
   const SkColor background_color =
       GetColor(connection_security::NONE, LocationBarView::BACKGROUND);
   ev_bubble_view_ = new EVBubbleView(
       bubble_font_list, GetColor(connection_security::EV_SECURE, SECURITY_TEXT),
       background_color, this);
   ev_bubble_view_->set_drag_controller(this);
   AddChildView(ev_bubble_view_);
@@ skipping 229 matching lines @@
   show_focus_rect_ = show;
   SchedulePaint();
 }
 
 void LocationBarView::SelectAll() {
   omnibox_view_->SelectAll(true);
 }
 
 gfx::Point LocationBarView::GetLocationBarAnchorPoint() const {
   // The +1 in the next line creates a 1-px gap between icon and arrow tip.
-  const int icon_internal_padding = GetThemeProvider()->GetDisplayProperty(
-      ThemeProperties::PROPERTY_ICON_LABEL_VIEW_TRAILING_PADDING);
-  gfx::Point icon_bottom(0, location_icon_view_->GetImageBounds().bottom() -
-                                icon_internal_padding + 1);
+  const int icon_padding = GetLayoutConstant(ICON_LABEL_VIEW_TRAILING_PADDING);
+  gfx::Point icon_bottom(
+      0, location_icon_view_->GetImageBounds().bottom() - icon_padding + 1);
   gfx::Point icon_center(location_icon_view_->GetImageBounds().CenterPoint());
   gfx::Point point(icon_center.x(), icon_bottom.y());
   ConvertPointToTarget(location_icon_view_, this, &point);
   return point;
 }
 
 int LocationBarView::GetInternalHeight(bool use_preferred_size) {
   int total_height =
       use_preferred_size ? GetPreferredSize().height() : height();
   return std::max(total_height - (VerticalPadding() * 2), 0);
@@ skipping 40 matching lines @@
 }
 
 void LocationBarView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_GROUP;
 }
 
 gfx::Size LocationBarView::GetPreferredSize() const {
   // Compute minimum height.
   gfx::Size min_size(border_painter_->GetMinimumSize());
   // For non-material the size of the asset determines the size of the
-  // LocationBarView. For Material Design the height is encoded as a constant in
-  // ThemeProperties.
-  ui::ThemeProvider* theme_provider = GetThemeProvider();
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    min_size.set_height(theme_provider->GetDisplayProperty(
-        ThemeProperties::PROPERTY_LOCATION_BAR_HEIGHT));
-  }
+  // LocationBarView.
+  if (ui::MaterialDesignController::IsModeMaterial())
+    min_size.set_height(GetLayoutConstant(LOCATION_BAR_HEIGHT));
 
   if (!IsInitialized())
     return min_size;
 
   min_size.set_height(min_size.height() * size_animation_.GetCurrentValue());
 
-  const int horizontal_item_padding = theme_provider->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_HORIZONTAL_PADDING);
-  const int bubble_horizontal_padding = theme_provider->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING);
+  const int padding = GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING);
 
   // Compute width of omnibox-leading content.
   const int horizontal_edge_thickness = GetHorizontalEdgeThickness();
   int leading_width = horizontal_edge_thickness;
   if (ShouldShowKeywordBubble()) {
     // The selected keyword view can collapse completely.
   } else if (ShouldShowEVBubble()) {
-    leading_width += bubble_horizontal_padding +
-                     ev_bubble_view_->GetMinimumSizeForLabelText(
-                                        GetToolbarModel()->GetEVCertName())
-                         .width();
+    leading_width += GetLayoutConstant(LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING) +
+        ev_bubble_view_->GetMinimumSizeForLabelText(
+            GetToolbarModel()->GetEVCertName()).width();
   } else {
-    leading_width +=
-        horizontal_item_padding + location_icon_view_->GetMinimumSize().width();
+    leading_width += padding + location_icon_view_->GetMinimumSize().width();
   }
 
   // Compute width of omnibox-trailing content.
   int trailing_width = horizontal_edge_thickness;
   trailing_width += IncrementalMinimumWidth(star_view_) +
       IncrementalMinimumWidth(translate_icon_view_) +
       IncrementalMinimumWidth(open_pdf_in_reader_view_) +
       IncrementalMinimumWidth(manage_passwords_icon_view_) +
       IncrementalMinimumWidth(zoom_view_) +
       IncrementalMinimumWidth(mic_search_view_);
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i)
     trailing_width += IncrementalMinimumWidth((*i));
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i)
     trailing_width += IncrementalMinimumWidth((*i));
 
   min_size.set_width(leading_width + omnibox_view_->GetMinimumSize().width() +
-                     2 * horizontal_item_padding -
-                     omnibox_view_->GetInsets().width() + trailing_width);
+                     2 * padding - omnibox_view_->GetInsets().width() +
+                     trailing_width);
   return min_size;
 }
 
 void LocationBarView::Layout() {
   if (!IsInitialized())
     return;
 
   selected_keyword_view_->SetVisible(false);
   location_icon_view_->SetVisible(false);
   ev_bubble_view_->SetVisible(false);
   keyword_hint_view_->SetVisible(false);
 
-  ui::ThemeProvider* theme_provider = GetThemeProvider();
-  const int horizontal_item_padding = theme_provider->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_HORIZONTAL_PADDING);
+  const int item_padding = GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING);
   int trailing_edge_item_padding = 0;
   if (!ui::MaterialDesignController::IsModeMaterial()) {
-    trailing_edge_item_padding = horizontal_item_padding -
-                                 GetHorizontalEdgeThickness() -
-                                 omnibox_view_->GetInsets().right();
+    trailing_edge_item_padding = item_padding - GetHorizontalEdgeThickness() -
+        omnibox_view_->GetInsets().right();
   }
 
   LocationBarLayout leading_decorations(
-      LocationBarLayout::LEFT_EDGE, horizontal_item_padding,
-      horizontal_item_padding - omnibox_view_->GetInsets().left() -
+      LocationBarLayout::LEFT_EDGE, item_padding,
+      item_padding - omnibox_view_->GetInsets().left() -
           GetEditLeadingInternalSpace());
-  LocationBarLayout trailing_decorations(LocationBarLayout::RIGHT_EDGE,
-                                         horizontal_item_padding,
-                                         trailing_edge_item_padding);
+  LocationBarLayout trailing_decorations(
+      LocationBarLayout::RIGHT_EDGE, item_padding, trailing_edge_item_padding);
 
   const base::string16 keyword(omnibox_view_->model()->keyword());
   // In some cases (e.g. fullscreen mode) we may have 0 height.  We still want
   // to position our child views in this case, because other things may be
   // positioned relative to them (e.g. the "bookmark added" bubble if the user
   // hits ctrl-d).
   const int bubble_vertical_padding =
       GetVerticalEdgeThickness() +
-      theme_provider->GetDisplayProperty(
-          ThemeProperties::PROPERTY_LOCATION_BAR_BUBBLE_VERTICAL_PADDING);
+      GetLayoutConstant(LOCATION_BAR_BUBBLE_VERTICAL_PADDING);
   const int bubble_height =
       std::max(height() - (bubble_vertical_padding * 2), 0);
-  const int bubble_horizontal_padding = theme_provider->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING);
+  const int bubble_horizontal_padding =
+      GetLayoutConstant(LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING);
   const int location_height = GetInternalHeight(false);
   const int vertical_padding = VerticalPadding();
   if (ShouldShowKeywordBubble()) {
     leading_decorations.AddDecoration(bubble_vertical_padding, bubble_height,
                                       true, 0, bubble_horizontal_padding,
-                                      horizontal_item_padding,
-                                      selected_keyword_view_);
+                                      item_padding, selected_keyword_view_);
     if (selected_keyword_view_->keyword() != keyword) {
       selected_keyword_view_->SetKeyword(keyword);
       const TemplateURL* template_url =
           TemplateURLServiceFactory::GetForProfile(profile())->
           GetTemplateURLForKeyword(keyword);
       if (template_url &&
           (template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION)) {
         gfx::Image image = extensions::OmniboxAPI::Get(profile())->
             GetOmniboxIcon(template_url->GetExtensionId());
         selected_keyword_view_->SetImage(image.AsImageSkia());
         selected_keyword_view_->set_is_extension_icon(true);
       } else {
         selected_keyword_view_->SetImage(
             *(GetThemeProvider()->GetImageSkiaNamed(IDR_OMNIBOX_SEARCH)));
         selected_keyword_view_->set_is_extension_icon(false);
       }
     }
   } else if (ShouldShowEVBubble()) {
     ev_bubble_view_->SetLabel(GetToolbarModel()->GetEVCertName());
     // The largest fraction of the omnibox that can be taken by the EV bubble.
     const double kMaxBubbleFraction = 0.5;
     leading_decorations.AddDecoration(
         bubble_vertical_padding, bubble_height, false, kMaxBubbleFraction,
-        bubble_horizontal_padding, horizontal_item_padding, ev_bubble_view_);
+        bubble_horizontal_padding, item_padding, ev_bubble_view_);
   } else {
     leading_decorations.AddDecoration(vertical_padding, location_height,
                                       location_icon_view_);
   }
 
   if (star_view_->visible()) {
     trailing_decorations.AddDecoration(vertical_padding, location_height,
                                        star_view_);
   }
   if (translate_icon_view_->visible()) {
@@ skipping 17 matching lines @@
   }
   if (zoom_view_->visible()) {
     trailing_decorations.AddDecoration(vertical_padding, location_height,
                                        zoom_view_);
   }
   for (ContentSettingViews::const_reverse_iterator i(
            content_setting_views_.rbegin()); i != content_setting_views_.rend();
        ++i) {
     if ((*i)->visible()) {
       trailing_decorations.AddDecoration(bubble_vertical_padding, bubble_height,
-                                         false, 0, horizontal_item_padding,
-                                         horizontal_item_padding, (*i));
+                                         false, 0, item_padding, item_padding,
+                                         *i);
     }
   }
   if (mic_search_view_->visible()) {
     trailing_decorations.AddDecoration(vertical_padding, location_height,
                                        mic_search_view_);
   }
   // Because IMEs may eat the tab key, we don't show "press tab to search" while
   // IME composition is in progress.
   if (!keyword.empty() && omnibox_view_->model()->is_keyword_hint() &&
       !omnibox_view_->IsImeComposing()) {
-    trailing_decorations.AddDecoration(
-        vertical_padding, location_height, true, 0, horizontal_item_padding,
-        horizontal_item_padding, keyword_hint_view_);
+    trailing_decorations.AddDecoration(vertical_padding, location_height, true,
+                                       0, item_padding, item_padding,
+                                       keyword_hint_view_);
     if (keyword_hint_view_->keyword() != keyword)
       keyword_hint_view_->SetKeyword(keyword);
   }
 
   // Perform layout.
   const int horizontal_edge_thickness = GetHorizontalEdgeThickness();
   int full_width = width() - (2 * horizontal_edge_thickness);
 
   int entry_width = full_width;
   leading_decorations.LayoutPass1(&entry_width);
@@ skipping 133 matching lines @@
 }
 
 WebContents* LocationBarView::GetWebContents() {
   return delegate_->GetWebContents();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private:
 
 int LocationBarView::IncrementalMinimumWidth(views::View* view) const {
-  const int horizontal_item_padding = GetThemeProvider()->GetDisplayProperty(
-      ThemeProperties::PROPERTY_LOCATION_BAR_HORIZONTAL_PADDING);
-  return view->visible()
-             ? (horizontal_item_padding + view->GetMinimumSize().width())
-             : 0;
+  return view->visible() ?
+      (GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING) +
+          view->GetMinimumSize().width()) : 0;
 }
 
 int LocationBarView::GetHorizontalEdgeThickness() const {
   // In maximized popup mode, there isn't any edge.
   return (is_popup_mode_ && browser_ && browser_->window() &&
-          browser_->window()->IsMaximized())
-             ? 0
-             : GetVerticalEdgeThickness();
+          browser_->window()->IsMaximized()) ?
+      0 : GetVerticalEdgeThickness();
 }
 
 int LocationBarView::GetVerticalEdgeThickness() const {
   return is_popup_mode_ ? kPopupEdgeThickness : kNormalEdgeThickness;
 }
 
 int LocationBarView::VerticalPadding() const {
-  return is_popup_mode_
-             ? kPopupEdgeThickness
-             : GetThemeProvider()->GetDisplayProperty(
-                   ThemeProperties::PROPERTY_LOCATION_BAR_VERTICAL_PADDING);
+  return is_popup_mode_ ?
+      kPopupEdgeThickness : GetLayoutConstant(LOCATION_BAR_VERTICAL_PADDING);
 }
 
 bool LocationBarView::RefreshContentSettingViews() {
   bool visibility_changed = false;
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     const bool was_visible = (*i)->visible();
     (*i)->Update(GetToolbarModel()->input_in_progress() ?
         NULL : GetWebContents());
     if (was_visible != (*i)->visible())
@@ skipping 504 matching lines @@
 
 void LocationBarView::ModelChanged(const SearchModel::State& old_state,
                                    const SearchModel::State& new_state) {
   const bool visible = !GetToolbarModel()->input_in_progress() &&
       new_state.voice_search_supported;
   if (mic_search_view_->visible() != visible) {
     mic_search_view_->SetVisible(visible);
     Layout();
   }
 }