Compute minimum widths for the toolbar components.

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/command_line.h"
@@ skipping 87 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/ui/views/first_run_bubble.h"
 #endif
 
 using content::WebContents;
 using views::View;
 
 namespace {
 
-#if !defined(OS_CHROMEOS)
-Browser* GetBrowserFromDelegate(LocationBarView::Delegate* delegate) {
-  WebContents* web_contents = delegate->GetWebContents();
-  return web_contents ? chrome::FindBrowserWithWebContents(web_contents) : NULL;
-}
-#endif
+// The search button images are made to look as if they overlay the normal edge
+// images, but to align things, the search button needs to be inset horizontally
+// by 1 px.
+const int kSearchButtonInset = 1;
 
 // Given a containing |height| and a |base_font_list|, shrinks the font size
 // until the font list will fit within |height| while having its cap height
 // vertically centered.  Returns the correctly-sized font list.
 //
 // The expected layout:
 //   +--------+-----------------------------------------------+------------+
 //   |        | y offset                                      | space      |
 //   |        +--------+-------------------+------------------+ above      |
 //   |        |        |                   | internal leading | cap height |
@@ skipping 27 matching lines @@
                   font_list.GetCapHeight() : font_list.GetHeight());
     const int y_offset = space / 2 - internal_leading;
     const int space_at_bottom = height - (y_offset + font_list.GetHeight());
     if ((y_offset >= 0) && (space_at_bottom >= 0))
       break;
     font_list = font_list.DeriveWithSizeDelta(-1);
   }
   return font_list;
 }
 
+int GetEditLeadingInternalSpace() {
+  // The textfield has 1 px of whitespace before the text in the RTL case only.
+  return base::i18n::IsRTL() ? 1 : 0;
+}
+
 // Functor for moving BookmarkManagerPrivate page actions to the right via
 // stable_partition.
 class IsPageActionViewRightAligned {
  public:
   explicit IsPageActionViewRightAligned(ExtensionService* extension_service)
       : extension_service_(extension_service) {}
 
   bool operator()(PageActionWithBadgeView* page_action_view) {
     return extensions::PermissionsData::HasAPIPermission(
         extension_service_->GetExtensionById(
@@ skipping 520 matching lines @@
   if (is_popup_mode_) {
     state->AddStateFlag(ui::AX_STATE_READ_ONLY);
   } else {
     state->set_value_callback =
         base::Bind(&LocationBarView::AccessibilitySetValue,
                    weak_ptr_factory_.GetWeakPtr());
   }
 }
 
 gfx::Size LocationBarView::GetPreferredSize() {
-  gfx::Size background_min_size(border_painter_->GetMinimumSize());
+  // Compute minimum height.
+  gfx::Size min_size(border_painter_->GetMinimumSize());
   if (!IsInitialized())
-    return background_min_size;
+    return min_size;
+  gfx::Size search_button_min_size(search_button_->GetMinimumSize());
+  min_size.SetToMax(search_button_min_size);
 
-  gfx::Size origin_chip_view_min_size(origin_chip_view_->GetMinimumSize());
-  gfx::Size search_button_min_size(search_button_->GetMinimumSize());
-  gfx::Size min_size(background_min_size);
-  min_size.SetToMax(search_button_min_size);
-  min_size.set_width(origin_chip_view_min_size.width() +
-                     background_min_size.width() +
-                     search_button_min_size.width());
+  // Compute width of omnibox-leading content.
+  const int horizontal_edge_thickness = GetHorizontalEdgeThickness();
+  int leading_width = horizontal_edge_thickness;
+  // TODO(pkasting): Make the origin chip min width sane, and make the chip
+  // handle being shrunken down more gracefully; then uncomment this.
+  /*if (GetToolbarModel()->ShouldShowOriginChip())
+    leading_width += origin_chip_view_->GetMinimumSize().width();*/
+  if (ShouldShowKeywordBubble()) {
+    // The selected keyword view can collapse completely.
+  } else if (ShouldShowEVBubble()) {
+    leading_width += kBubblePadding +
+        ev_bubble_view_->GetMinimumSizeForLabelText(
+            GetToolbarModel()->GetEVCertName()).width();
+  } else if (!origin_chip_view_->visible()) {
+    leading_width +=
+        kItemPadding + location_icon_view_->GetMinimumSize().width();
+  }
+  leading_width += kItemPadding - GetEditLeadingInternalSpace();
+
+  // Compute width of omnibox-trailing content.
+  int trailing_width = search_button_->visible() ?
+      (search_button_->GetMinimumSize().width() + kSearchButtonInset) :
+      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(generated_credit_card_view_) +
+      IncrementalMinimumWidth(mic_search_view_) + kItemPadding;
+  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() + trailing_width);
   return min_size;
 }
 
 void LocationBarView::Layout() {
   if (!IsInitialized())
     return;
 
   animated_host_label_->SetVisible(false);
   origin_chip_view_->SetVisible(GetToolbarModel()->ShouldShowOriginChip());
   selected_keyword_view_->SetVisible(false);
   location_icon_view_->SetVisible(false);
   ev_bubble_view_->SetVisible(false);
   keyword_hint_view_->SetVisible(false);
 
-  // The textfield has 1 px of whitespace before the text in the RTL case only.
-  const int kEditLeadingInternalSpace = base::i18n::IsRTL() ? 1 : 0;
   LocationBarLayout leading_decorations(
-      LocationBarLayout::LEFT_EDGE, kItemPadding - kEditLeadingInternalSpace);
+      LocationBarLayout::LEFT_EDGE,
+      kItemPadding - GetEditLeadingInternalSpace());
   LocationBarLayout trailing_decorations(LocationBarLayout::RIGHT_EDGE,
                                          kItemPadding);
 
   // Show and position the animated host label used in the show and hide URL
   // animations.
   if (show_url_animation_->is_animating() ||
       hide_url_animation_->is_animating()) {
     WebContents* web_contents = GetWebContents();
     const GURL url = web_contents ? web_contents->GetURL() : GURL();
     const base::string16 host =
@@ skipping 28 matching lines @@
     animated_host_label_->SetBounds(
         host_label_x, 0,
         animated_host_label_->GetPreferredSize().width(), height());
     animated_host_label_->SetVisible(true);
   }
 
   const int origin_chip_width = origin_chip_view_->visible() ?
       origin_chip_view_->GetPreferredSize().width() : 0;
   origin_chip_view_->SetBounds(0, 0, origin_chip_width, height());
 
+  const int bubble_location_y = vertical_edge_thickness() + kBubblePadding;
   const base::string16 keyword(omnibox_view_->model()->keyword());
-  const bool is_keyword_hint(omnibox_view_->model()->is_keyword_hint());
-  const int bubble_location_y = vertical_edge_thickness() + kBubblePadding;
   // 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 location_height = GetInternalHeight(false);
   const int bubble_height = std::max(location_height - (kBubblePadding * 2), 0);
-  if (!keyword.empty() && !is_keyword_hint) {
+  if (ShouldShowKeywordBubble()) {
     leading_decorations.AddDecoration(bubble_location_y, bubble_height, true, 0,
                                       kBubblePadding, kItemPadding,
                                       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 (!toolbar_origin_chip_view_ &&
-      !chrome::ShouldDisplayOriginChipV2() &&
-      (GetToolbarModel()->GetSecurityLevel(false) == ToolbarModel::EV_SECURE)) {
+  } 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_location_y, bubble_height, false,
                                       kMaxBubbleFraction, kBubblePadding,
                                       kItemPadding, ev_bubble_view_);
   } else if (!origin_chip_view_->visible()) {
     leading_decorations.AddDecoration(
         vertical_edge_thickness(), location_height,
         location_icon_view_);
@@ skipping 40 matching lines @@
     trailing_decorations.AddDecoration(vertical_edge_thickness(),
                                        location_height,
                                        generated_credit_card_view_);
   }
   if (mic_search_view_->visible()) {
     trailing_decorations.AddDecoration(vertical_edge_thickness(),
                                        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() && is_keyword_hint && !omnibox_view_->IsImeComposing()) {
+  if (!keyword.empty() && omnibox_view_->model()->is_keyword_hint() &&
+      !omnibox_view_->IsImeComposing()) {
     trailing_decorations.AddDecoration(vertical_edge_thickness(),
                                        location_height, true, 0, kItemPadding,
                                        kItemPadding, 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() - horizontal_edge_thickness - origin_chip_width;
 
-  // The search button images are made to look as if they overlay the normal
-  // edge images, but to align things, the search button needs to be inset
-  // horizontally by 1 px.
-  const int kSearchButtonInset = 1;
   const gfx::Size search_button_size(search_button_->GetPreferredSize());
   const int search_button_reserved_width =
       search_button_size.width() + kSearchButtonInset;
   full_width -= search_button_->visible() ?
       search_button_reserved_width : horizontal_edge_thickness;
   int entry_width = full_width;
   leading_decorations.LayoutPass1(&entry_width);
   trailing_decorations.LayoutPass1(&entry_width);
   leading_decorations.LayoutPass2(&entry_width);
   trailing_decorations.LayoutPass2(&entry_width);
@@ skipping 139 matching lines @@
   return delegate_->GetToolbarModel();
 }
 
 WebContents* LocationBarView::GetWebContents() {
   return delegate_->GetWebContents();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private:
 
+// static
+int LocationBarView::IncrementalMinimumWidth(views::View* view) {
+  return view->visible() ? (kItemPadding + 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 : vertical_edge_thickness();
 }
 
 bool LocationBarView::RefreshContentSettingViews() {
   bool visibility_changed = false;
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
@@ skipping 129 matching lines @@
   WebContents* web_contents = GetWebContents();
   if (!web_contents)
     return false;
   const bool was_visible = manage_passwords_icon_view_->visible();
   ManagePasswordsUIController::FromWebContents(
       web_contents)->UpdateIconAndBubbleState(manage_passwords_icon_view_);
   return was_visible != manage_passwords_icon_view_->visible();
 }
 
 void LocationBarView::ShowFirstRunBubbleInternal() {
+  // First run bubble doesn't make sense for Chrome OS.
 #if !defined(OS_CHROMEOS)
-  // First run bubble doesn't make sense for Chrome OS.
-  Browser* browser = GetBrowserFromDelegate(delegate_);
-  if (!browser)
-    return; // Possible when browser is shutting down.
-
-  FirstRunBubble::ShowBubble(browser, GetLocationBarAnchor());
+  WebContents* web_contents = delegate_->GetWebContents();
+  if (!web_contents)
+    return;
+  Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
+  if (browser)
+    FirstRunBubble::ShowBubble(browser, GetLocationBarAnchor());
 #endif
 }
 
 void LocationBarView::AccessibilitySetValue(const base::string16& new_value) {
   omnibox_view_->SetUserText(new_value, new_value, true);
 }
 
 bool LocationBarView::HasValidSuggestText() const {
   return suggested_text_view_->visible() &&
       !suggested_text_view_->size().IsEmpty();
 }
 
+bool LocationBarView::ShouldShowKeywordBubble() const {
+  return !omnibox_view_->model()->keyword().empty() &&
+      !omnibox_view_->model()->is_keyword_hint();
+}
+
+bool LocationBarView::ShouldShowEVBubble() const {
+  return !toolbar_origin_chip_view_ && !chrome::ShouldDisplayOriginChipV2() &&
+      (GetToolbarModel()->GetSecurityLevel(false) == ToolbarModel::EV_SECURE);
+}
+
 void LocationBarView::OnShowURLAnimationEnded() {
   animated_host_label_->SetVisible(false);
   omnibox_view_->SetVisible(true);
   omnibox_view_->FadeIn();
   omnibox_view_->SetFocus();
 
   // Sometimes the selection established by OmniboxView::ShowURL() is lost at
   // the call to SetFocus() above.  Select all again to be sure.
   // TODO(jdonnelly): Figure out why the selection is sometimes lost and
   // implement a more principled fix.
@@ skipping 418 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();
   }
 }