New location security strings and animation.

chrome/browser/ui/views/location_bar/icon_label_bubble_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/icon_label_bubble_view.h"
 
+#include <iostream>
+
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/views/location_bar/background_with_1_px_border.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/image/image_util.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/native_theme/native_theme.h"
@@ skipping 99 matching lines @@
 
 bool IconLabelBubbleView::IsShrinking() const {
   return false;
 }
 
 bool IconLabelBubbleView::OnActivate(const ui::Event& event) {
   return false;
 }
 
 gfx::Size IconLabelBubbleView::GetPreferredSize() const {
+  std::cout << "Icon::GetPreferredSize\n";

[Peter Kasting, 2016/07/19 21:17:19]

You may want to use the VLOG macro for this kind of debug logging instead.

[Kevin Bailey, 2016/08/12 18:49:14]

ack

   // Height will be ignored by the LocationBarView.
-  return GetSizeForLabelWidth(label_->GetPreferredSize().width());
+  return GetSizeForLabelWidth(GetLabelPreferredWidth());
 }
 
 bool IconLabelBubbleView::OnKeyPressed(const ui::KeyEvent& event) {
   if (event.key_code() == ui::VKEY_RETURN)
     return OnActivate(event);
   return false;
 }
 
 bool IconLabelBubbleView::OnKeyReleased(const ui::KeyEvent& event) {
   if (event.key_code() == ui::VKEY_SPACE)
     return OnActivate(event);
   return false;
 }
 
 void IconLabelBubbleView::Layout() {
+  std::cout << "Icon::Layout " << (void*)this << "\n";
   // Compute the image bounds.  In non-MD, the leading padding depends on
   // whether this is an extension icon, since extension icons and
   // Chrome-provided icons are different sizes.  In MD, these sizes are the
   // same, so it's not necessary to handle the two types differently.
   const bool icon_has_enough_padding =
       !is_extension_icon_ || ui::MaterialDesignController::IsModeMaterial();
   int image_x = GetOuterPadding(icon_has_enough_padding);
   int bubble_trailing_padding = GetOuterPadding(false);
 
   // If ShouldShowBackground() is true, then either we show a background in the
@@ skipping 90 matching lines @@
     const int post_label_width = ui::MaterialDesignController::IsModeMaterial()
         ? (kSpaceBesideSeparator + separator_width + GetPostSeparatorPadding())
         : GetOuterPadding(false);
 
     // |multiplier| grows from zero to one, stays equal to one and then shrinks
     // to zero again. The view width should correspondingly grow from zero to
     // fully showing both label and icon, stay there, then shrink to just large
     // enough to show the icon. We don't want to shrink all the way back to
     // zero, since this would mean the view would completely disappear and then
     // pop back to an icon after the animation finishes.
-    const int max_width = GetImageTrailingEdge() + GetInternalSpacing() +
-                          label_width + post_label_width;
-    const int current_width = WidthMultiplier() * max_width;
-    size.set_width(shrinking ? std::max(current_width, size.width())
-                             : current_width);
+    // Changed so that, while shrinking, |multiplier| only refers to the label,
+    // separator and padding.

[Peter Kasting, 2016/07/19 21:17:20]

I'm not really sure why.  You'll want to explain this more.

Also make sure you're not breaking the content setting animations by making
functional changes in this base class.

[Kevin Bailey, 2016/08/12 18:49:14]

I integrated the comment better. Strictly speaking, the change is not necessary,
although I think it reads and represents what's going on better. But now that
we're not shrinking, I'm not sure it belongs in this CL. Let me know if you'd
prefer leaving it out.

+    if (shrinking) {
+      const int current_width = GetImageTrailingEdge() + GetInternalSpacing() +
+          (label_width + post_label_width) * WidthMultiplier();
+      size.set_width(std::max(current_width, size.width()));

[Peter Kasting, 2016/07/19 21:17:20]

Unless GetInternalSpacing() or WidthMultiplier() can be negative, I don't think
you need the max() call here.

[Kevin Bailey, 2016/08/12 18:49:14]

Done.

+    } else {
+      const int max_width = GetImageTrailingEdge() + GetInternalSpacing() +
+                            label_width + post_label_width;
+      const int current_width = WidthMultiplier() * max_width;
+      size.set_width(current_width);
+    }
   }
   return size;
 }
 
 int IconLabelBubbleView::MinimumWidthForImageWithBackgroundShown() const {
   return GetImageTrailingEdge() + GetOuterPadding(false);
 }
 
+int IconLabelBubbleView::GetLabelPreferredWidth() const {
+  return label_->GetPreferredSize().width();
+}
+
 void IconLabelBubbleView::SetLabelBackgroundColor(
     SkColor chip_background_color) {
   // The background images are painted atop |parent_background_color_|.
   // Alpha-blend |chip_background_color| with |parent_background_color_| to
   // determine the actual color the label text will sit atop.
   // Tricky bit: We alpha blend an opaque version of |chip_background_color|
   // against |parent_background_color_| using the original image grid color's
   // alpha. This is because AlphaBlend(a, b, 255) always returns |a| unchanged
   // even if |a| is a color with non-255 alpha.
   label_->SetBackgroundColor(color_utils::AlphaBlend(
@@ skipping 24 matching lines @@
   // The location bar will add LOCATION_BAR_HORIZONTAL_PADDING after us.
   return kSpaceBesideSeparator -
          GetLayoutConstant(LOCATION_BAR_HORIZONTAL_PADDING);
 }
 
 const char* IconLabelBubbleView::GetClassName() const {
   return "IconLabelBubbleView";
 }
 
 void IconLabelBubbleView::OnPaint(gfx::Canvas* canvas) {
+  std::cout << "Icon::OnPaint\n";
   if (!ShouldShowBackground())
     return;
   if (background_painter_) {
     views::Painter::PaintPainterAt(canvas, background_painter_.get(),
                                    GetContentsBounds());
   }
 
   // In MD, draw a separator and not a background.
   if (ui::MaterialDesignController::IsModeMaterial()) {
     const SkColor plain_text_color = GetNativeTheme()->GetSystemColor(
         ui::NativeTheme::kColorId_TextfieldDefaultColor);
     const SkColor separator_color = SkColorSetA(
         plain_text_color, color_utils::IsDark(plain_text_color) ? 0x59 : 0xCC);
 
-    gfx::Rect bounds(GetLocalBounds());
-    const int kSeparatorHeight = 16;
-    bounds.Inset(GetPostSeparatorPadding(),
-                 (bounds.height() - kSeparatorHeight) / 2);
+    if (!IsShrinking() || WidthMultiplier() > 0) {

[Peter Kasting, 2016/07/19 21:17:19]

This doesn't break the keyword search presentation (by removing the separator in
the steady state), does it?

[Kevin Bailey, 2016/08/12 18:49:14]

We don't shrink any more, so reverted.

+      gfx::Rect bounds(GetLocalBounds());
+      const int kSeparatorHeight = 16;
+      bounds.Inset(GetPostSeparatorPadding(),
+                   (bounds.height() - kSeparatorHeight) / 2);
 
-    // Draw the 1 px separator.
-    gfx::ScopedCanvas scoped_canvas(canvas);
-    const float scale = canvas->UndoDeviceScaleFactor();
-    // Keep the separator aligned on a pixel center.
-    const gfx::RectF pixel_aligned_bounds =
-        gfx::ScaleRect(gfx::RectF(bounds), scale) - gfx::Vector2dF(0.5f, 0);
-    canvas->DrawLine(pixel_aligned_bounds.top_right(),
-                     pixel_aligned_bounds.bottom_right(), separator_color);
+      // Draw the 1 px separator.
+      gfx::ScopedCanvas scoped_canvas(canvas);
+      const float scale = canvas->UndoDeviceScaleFactor();
+      // Keep the separator aligned on a pixel center.
+      const gfx::RectF pixel_aligned_bounds =
+          gfx::ScaleRect(gfx::RectF(bounds), scale) - gfx::Vector2dF(0.5f, 0);
+      canvas->DrawLine(pixel_aligned_bounds.top_right(),
+                       pixel_aligned_bounds.bottom_right(), separator_color);
+    }
   }
 }