Draw popup window toolbars as only containing a location bar.

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"
@@ skipping 98 matching lines @@
   return base::i18n::IsRTL() ? 1 : 0;
 }
 
 }  // namespace
 
 
 // LocationBarView -----------------------------------------------------------
 
 // static
 
-// Thickness of the edges of the omnibox background images, for popup windows.
-const int kPopupEdgeThickness = 1;
-
 const char LocationBarView::kViewClassName[] = "LocationBarView";
 
 LocationBarView::LocationBarView(Browser* browser,
                                  Profile* profile,
                                  CommandUpdater* command_updater,
                                  Delegate* delegate,
                                  bool is_popup_mode)
     : LocationBar(profile),
       ChromeOmniboxEditController(command_updater),
       browser_(browser),
@@ skipping 35 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, public:
 
 void LocationBarView::Init() {
   // We need to be in a Widget, otherwise GetNativeTheme() may change and we're
   // not prepared for that.
   DCHECK(GetWidget());
 
-  if (is_popup_mode_) {
-    const int kOmniboxPopupBorderImages[] =
-        IMAGE_GRID(IDR_OMNIBOX_POPUP_BORDER_AND_SHADOW);
-    border_painter_.reset(
-        views::Painter::CreateImageGridPainter(kOmniboxPopupBorderImages));
-  } else if (!ui::MaterialDesignController::IsModeMaterial()) {
-    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-    const gfx::Insets omnibox_border_insets(14, 9, 14, 9);
-    border_painter_.reset(views::Painter::CreateImagePainter(
-        *rb.GetImageSkiaNamed(IDR_OMNIBOX_BORDER), omnibox_border_insets));
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    if (is_popup_mode_) {
+      const int kOmniboxPopupBorderImages[] =
+          IMAGE_GRID(IDR_OMNIBOX_POPUP_BORDER_AND_SHADOW);
+      border_painter_.reset(
+          views::Painter::CreateImageGridPainter(kOmniboxPopupBorderImages));
+    } else {
+      ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+      const gfx::Insets omnibox_border_insets(14, 9, 14, 9);
+      border_painter_.reset(views::Painter::CreateImagePainter(
+          *rb.GetImageSkiaNamed(IDR_OMNIBOX_BORDER), omnibox_border_insets));
+    }
   }
 
   location_icon_view_ = new LocationIconView(this);
   location_icon_view_->set_drag_controller(this);
   AddChildView(location_icon_view_);
 
   // Determine the main font.
   gfx::FontList font_list = ResourceBundle::GetSharedInstance().GetFontList(
       ResourceBundle::BaseFont);
   const int current_font_size = font_list.GetFontSize();
   const int desired_font_size = GetLayoutConstant(OMNIBOX_FONT_PIXEL_SIZE);
   if (current_font_size != desired_font_size) {
     font_list =
         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 =
       ui::MaterialDesignController::IsModeMaterial() ? 2 : 1;
   const int bubble_padding =
-      GetVerticalEdgeThickness() +
+      GetEdgeThickness() +
       GetLayoutConstant(LOCATION_BAR_BUBBLE_VERTICAL_PADDING) +
       kBubbleInteriorVerticalPadding;
   const int bubble_height = GetPreferredSize().height() - (bubble_padding * 2);
   gfx::FontList bubble_font_list =
       font_list.DeriveWithHeightUpperBound(bubble_height);
 
   const SkColor background_color = GetColor(LocationBarView::BACKGROUND);
   const SkColor ev_text_color = GetColor(EV_BUBBLE_TEXT_AND_BORDER);
   ev_bubble_view_ =
       new EVBubbleView(bubble_font_list, ev_text_color, background_color, this);
@@ skipping 291 matching lines @@
   return omnibox_view_->model()->has_focus();
 }
 
 void LocationBarView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_GROUP;
 }
 
 gfx::Size LocationBarView::GetPreferredSize() const {
   // Compute minimum height.
   gfx::Size min_size;
-  // For non-material the size of the asset determines the size of the
-  // LocationBarView.
-  if (ui::MaterialDesignController::IsModeMaterial())
-    min_size.set_height(GetLayoutConstant(LOCATION_BAR_HEIGHT));
-  else
+  if (ui::MaterialDesignController::IsModeMaterial() || is_popup_mode_) {
+    const int height = GetLayoutConstant(LOCATION_BAR_HEIGHT);
+    const int edge_thickness = views::NonClientFrameView::kClientEdgeThickness;
+    min_size.set_height(height - (is_popup_mode_ ? (2 * edge_thickness) : 0));
+  } else {
     min_size = border_painter_->GetMinimumSize();
+  }
 
   if (!IsInitialized())
     return min_size;
 
   min_size.set_height(min_size.height() * size_animation_.GetCurrentValue());
 
   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;
+  const int edge_thickness = GetEdgeThickness();
+  int leading_width = edge_thickness;
   if (ShouldShowKeywordBubble()) {
     // The selected keyword view can collapse completely.
   } else if (ShouldShowEVBubble()) {
     leading_width += GetLayoutConstant(LOCATION_BAR_BUBBLE_HORIZONTAL_PADDING) +
         ev_bubble_view_->GetMinimumSizeForLabelText(
             GetToolbarModel()->GetEVCertName()).width();
   } else {
     leading_width += padding + location_icon_view_->GetMinimumSize().width();
   }
 
   // Compute width of omnibox-trailing content.
-  int trailing_width = horizontal_edge_thickness;
+  int trailing_width = edge_thickness;
   trailing_width += IncrementalMinimumWidth(star_view_) +
                     IncrementalMinimumWidth(translate_icon_view_) +
                     IncrementalMinimumWidth(open_pdf_in_reader_view_) +
                     IncrementalMinimumWidth(save_credit_card_icon_view_) +
                     IncrementalMinimumWidth(manage_passwords_icon_view_) +
                     IncrementalMinimumWidth(zoom_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 * 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);
 
   const int item_padding = GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING);
+  const int edge_thickness = GetEdgeThickness();
   int trailing_edge_item_padding = 0;
   if (!ui::MaterialDesignController::IsModeMaterial()) {
-    trailing_edge_item_padding = item_padding - GetHorizontalEdgeThickness() -
-        omnibox_view_->GetInsets().right();
+    trailing_edge_item_padding =
+        item_padding - edge_thickness - omnibox_view_->GetInsets().right();
   }
 
   LocationBarLayout leading_decorations(
       LocationBarLayout::LEFT_EDGE, item_padding,
       item_padding - omnibox_view_->GetInsets().left() -
           GetEditLeadingInternalSpace());
   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() +
-      GetLayoutConstant(LOCATION_BAR_BUBBLE_VERTICAL_PADDING);
+      edge_thickness + GetLayoutConstant(LOCATION_BAR_BUBBLE_VERTICAL_PADDING);
   const int bubble_height =
       std::max(height() - (bubble_vertical_padding * 2), 0);
   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,
                                       item_padding, selected_keyword_view_);
@@ skipping 70 matching lines @@
   if (!keyword.empty() && omnibox_view_->model()->is_keyword_hint() &&
       !omnibox_view_->IsImeComposing()) {
     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 full_width = width() - (2 * 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);
 
   int location_needed_width = omnibox_view_->GetTextWidth();
   int available_width = entry_width - location_needed_width;
   // The bounds must be wide enough for all the decorations to fit.
-  gfx::Rect location_bounds(horizontal_edge_thickness, vertical_padding,
+  gfx::Rect location_bounds(edge_thickness, vertical_padding,
                             std::max(full_width, full_width - entry_width),
                             location_height);
   leading_decorations.LayoutPass3(&location_bounds, &available_width);
   trailing_decorations.LayoutPass3(&location_bounds, &available_width);
 
   // Layout out the suggested text view right aligned to the location
   // entry. Only show the suggested text if we can fit the text from one
   // character before the end of the selection to the end of the text and the
   // suggested text. If we can't it means either the suggested text is too big,
   // or the user has scrolled.
@@ skipping 65 matching lines @@
       x = entry_width - width;
     location_bounds.set_width(x);
     ime_inline_autocomplete_view_->SetBounds(
         location_bounds.right(), location_bounds.y(),
         std::min(width, entry_width), location_bounds.height());
   }
   omnibox_view_->SetBoundsRect(location_bounds);
 }
 
 void LocationBarView::OnNativeThemeChanged(const ui::NativeTheme* theme) {
-  if (!ui::MaterialDesignController::IsModeMaterial())
-    return;
-
-  RefreshLocationIcon();
-  set_background(new BackgroundWith1PxBorder(
-      GetColor(BACKGROUND), SkColorSetARGB(0x4D, 0x00, 0x00, 0x00),
-      is_popup_mode_));
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    RefreshLocationIcon();
+    if (!is_popup_mode_) {
+      set_background(new BackgroundWith1PxBorder(
+          GetColor(BACKGROUND), SkColorSetARGB(0x4D, 0x00, 0x00, 0x00)));
+    }
+  }
 }
 
 void LocationBarView::Update(const WebContents* contents) {
   RefreshContentSettingViews();
   RefreshZoomView();
   RefreshPageActionViews();
   RefreshTranslateIcon();
   RefreshSaveCreditCardIconView();
   RefreshManagePasswordsIconView();
   content::WebContents* web_contents_for_sub_views =
@@ skipping 36 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private:
 
 int LocationBarView::IncrementalMinimumWidth(views::View* view) const {
   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();
-}
-
-int LocationBarView::GetVerticalEdgeThickness() const {
-  return is_popup_mode_ ? kPopupEdgeThickness
-                        : GetLayoutConstant(LOCATION_BAR_BORDER_THICKNESS);
+int LocationBarView::GetEdgeThickness() const {
+  return is_popup_mode_ ? 0 : GetLayoutConstant(LOCATION_BAR_BORDER_THICKNESS);
 }
 
 int LocationBarView::VerticalPadding() const {
-  return is_popup_mode_ ?
-      kPopupEdgeThickness : GetLayoutConstant(LOCATION_BAR_VERTICAL_PADDING);
+  return is_popup_mode_ ? 0 : GetLayoutConstant(LOCATION_BAR_VERTICAL_PADDING);
 }
 
 void LocationBarView::RefreshLocationIcon() {
   // |omnibox_view_| may not be ready yet if Init() has not been called. The
   // icon will be set soon by OnChanged().
   if (!omnibox_view_)
     return;
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
     location_icon_view_->SetImage(gfx::CreateVectorIcon(
@@ skipping 390 matching lines @@
 
 void LocationBarView::OnFocus() {
   // Explicitly focus the omnibox so a focus ring will be displayed around it on
   // Windows.
   omnibox_view_->SetFocus();
 }
 
 void LocationBarView::OnPaint(gfx::Canvas* canvas) {
   View::OnPaint(canvas);
 
-  if (ui::MaterialDesignController::IsModeMaterial())
+  if (ui::MaterialDesignController::IsModeMaterial() && !is_popup_mode_)
     return;  // The background and border are painted by our Background.
 
   // Fill the location bar background color behind the border.  Parts of the
   // border images are meant to rest atop the toolbar background and parts atop
   // the omnibox background, so we can't just blindly fill our entire bounds.
   gfx::Rect bounds(GetContentsBounds());
-  bounds.Inset(GetHorizontalEdgeThickness(), GetVerticalEdgeThickness());
+  const int edge_thickness = GetEdgeThickness();
+  bounds.Inset(edge_thickness, edge_thickness);
   SkColor color(GetColor(BACKGROUND));
   if (is_popup_mode_) {
     canvas->FillRect(bounds, color);
   } else {
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(color);
     const int kBorderCornerRadius = 2;
     canvas->DrawRoundRect(bounds, kBorderCornerRadius, paint);
   }
 
   // The border itself will be drawn in PaintChildren() since it includes an
   // inner shadow which should be drawn over the contents.
 }
 
 void LocationBarView::PaintChildren(const ui::PaintContext& context) {
   View::PaintChildren(context);
 
   ui::PaintRecorder recorder(context, size());
 
   // For non-InstantExtendedAPI cases, if necessary, show focus rect. As we need
   // the focus rect to appear on top of children we paint here rather than
   // OnPaint().
   // Note: |Canvas::DrawFocusRect| paints a dashed rect with gray color.
   if (show_focus_rect_ && HasFocus())
     recorder.canvas()->DrawFocusRect(omnibox_view_->bounds());
 
-  if (ui::MaterialDesignController::IsModeMaterial())
-    return;  // The background and border are painted by our Background.
-
-  // Maximized popup windows don't draw the horizontal edges.  We implement this
-  // by simply expanding the paint area outside the view by the edge thickness.
-  gfx::Rect border_rect(GetContentsBounds());
-  if (is_popup_mode_ && (GetHorizontalEdgeThickness() == 0))
-    border_rect.Inset(-kPopupEdgeThickness, 0);
-
-  views::Painter::PaintPainterAt(recorder.canvas(), border_painter_.get(),
-                                 border_rect);
+  if (!ui::MaterialDesignController::IsModeMaterial() && !is_popup_mode_) {
+    views::Painter::PaintPainterAt(recorder.canvas(), border_painter_.get(),
+                                   GetContentsBounds());
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private views::DragController implementation:
 
 void LocationBarView::WriteDragDataForView(views::View* sender,
                                            const gfx::Point& press_pt,
                                            OSExchangeData* data) {
   DCHECK_NE(GetDragOperationsForView(sender, press_pt),
             ui::DragDropTypes::DRAG_NONE);
@@ skipping 22 matching lines @@
 
 bool LocationBarView::CanStartDragForView(View* sender,
                                           const gfx::Point& press_pt,
                                           const gfx::Point& p) {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private gfx::AnimationDelegate implementation:
 void LocationBarView::AnimationProgressed(const gfx::Animation* animation) {
-  browser_->window()->ToolbarSizeChanged(true);
+  GetWidget()->non_client_view()->Layout();
 }
 
 void LocationBarView::AnimationEnded(const gfx::Animation* animation) {
-  browser_->window()->ToolbarSizeChanged(false);
+  AnimationProgressed(animation);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private OmniboxEditController implementation:
 
 void LocationBarView::OnChanged() {
   RefreshLocationIcon();
   location_icon_view_->ShowTooltip(!GetOmniboxView()->IsEditingOrEmpty());
 
   Layout();
@@ skipping 23 matching lines @@
 // LocationBarView, private TemplateURLServiceObserver implementation:
 
 void LocationBarView::OnTemplateURLServiceChanged() {
   template_url_service_->RemoveObserver(this);
   template_url_service_ = NULL;
   // If the browser is no longer active, let's not show the info bubble, as this
   // would make the browser the active window again.
   if (omnibox_view_ && omnibox_view_->GetWidget()->IsActive())
     ShowFirstRunBubble();
 }