When animating a content setting bubble smaller, hide the background later.

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 "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"
@@ skipping 102 matching lines @@
   const int image_width = image_->GetPreferredSize().width();
   return image_width ? (image_width + GetInternalSpacing()) : 0;
 }
 
 gfx::Size IconLabelBubbleView::GetPreferredSize() const {
   // Height will be ignored by the LocationBarView.
   return GetSizeForLabelWidth(label_->GetPreferredSize().width());
 }
 
 void IconLabelBubbleView::Layout() {
-  // Compute the label bounds.  The label gets whatever size is left over after
-  // accounting for the preferred image width and padding amounts.  Note that if
-  // the label has zero size it doesn't actually matter what we compute its X
-  // value to be, since it won't be visible, so the X value can be "wrong"
-  // compared to where the right edge of the image is computed to be below.
-  // This means doing this layout doesn't doesn't depend on any of the layout
-  // below.  That layout, however, may need for this layout to have already
-  // happened, since the value of ShouldShowBackground() we read below may
-  // depend on whether the label has nonzero size.  Therefore, we do this first.
-  const int label_x = GetOuterPadding(true) + GetImageAndPaddingWidth();
-  const int label_width =
-      std::max(0, width() - label_x - GetOuterPadding(false));
-  label_->SetBounds(label_x, 0, label_width, height());
-
-  // Now compute the image bounds.  In non-MD, the leading padding depends on
+  // 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();

[varkha, 2016/03/30 03:43:19]

nit: Do you still need the check for IsModeMaterial() given that with MD
GetOuterPadding(true) = GetOuterPadding(false)?

[Peter Kasting, 2016/03/30 03:57:55]

Yes, because in the next change set that will no longer be true (due to
adjusting for built-in padding in the image with the leading value).

   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
   // steady state, or we're not yet in the last portion of the animation.  In
   // these cases, we leave the leading and trailing padding alone; we don't want
   // to let the image overlap the edge of the background, as this looks glitchy.
   // If this is false, however, then we're only showing the image, and either
   // the view width is the image width, or it's animating downwards and getting
   // close to it.  In these cases, we want to shrink the trailing padding first,
   // so the image slides all the way to the trailing edge before slowing or
   // stopping; then we want to shrink the leading padding down to zero.
   const int image_preferred_width = image_->GetPreferredSize().width();
   if (!ShouldShowBackground()) {
     image_x = std::min(image_x, width() - image_preferred_width);
     bubble_trailing_padding = std::min(
         bubble_trailing_padding, width() - image_preferred_width - image_x);
   }
 
   // Now that we've computed the padding values, give the image all the
   // remaining width.  This will be less than the image's preferred width during
   // the first portion of the animation; during the very beginning there may not
   // be enough room to show the image at all.
   const int image_width =
       std::min(image_preferred_width,
                std::max(0, width() - image_x - bubble_trailing_padding));
   image_->SetBounds(image_x, 0, image_width, height());
+
+  // Compute the label bounds.  The label gets whatever size is left over after
+  // accounting for the preferred image width and padding amounts.  Note that if
+  // the label has zero size it doesn't actually matter what we compute its X
+  // value to be, since it won't be visible.
+  const int label_x = image_x + GetImageAndPaddingWidth();
+  const int label_width =
+      std::max(0, width() - label_x - bubble_trailing_padding);
+  label_->SetBounds(label_x, 0, label_width, height());
 }
 
 void IconLabelBubbleView::OnNativeThemeChanged(
     const ui::NativeTheme* native_theme) {
   label_->SetEnabledColor(GetTextColor());
 
   if (!ui::MaterialDesignController::IsModeMaterial())
     return;
 
   bool inverted = color_utils::IsDark(GetParentBackgroundColor());
@@ skipping 96 matching lines @@
 void IconLabelBubbleView::OnPaint(gfx::Canvas* canvas) {
   if (!ShouldShowBackground())
     return;
   if (background_painter_) {
     views::Painter::PaintPainterAt(canvas, background_painter_.get(),
                                    GetContentsBounds());
   }
   if (background())
     background()->Paint(canvas, this);
 }