Retain tray bubble's rounded corners when the bubble animates out

ui/views/bubble/tray_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 "ui/views/bubble/tray_bubble_view.h"
 
 #include <algorithm>
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 161 matching lines @@
 
 // This mask layer clips the bubble's content so that it does not overwrite the
 // rounded bubble corners.
 // TODO(miket): This does not work on Windows. Implement layer masking or
 // alternate solutions if the TrayBubbleView is needed there in the future.
 class TrayBubbleContentMask : public ui::LayerDelegate {
  public:
   explicit TrayBubbleContentMask(int corner_radius);
   virtual ~TrayBubbleContentMask();
 
-  ui::Layer* layer() { return &layer_; }
+  void set_bounds(gfx::Rect bounds) { bounds_ = bounds; }
 
   // Overridden from LayerDelegate.
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE;
 
  private:
-  ui::Layer layer_;
+  gfx::Rect bounds_;
   SkScalar corner_radius_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBubbleContentMask);
 };
 
 TrayBubbleContentMask::TrayBubbleContentMask(int corner_radius)
-    : layer_(ui::LAYER_TEXTURED),
-      corner_radius_(corner_radius) {
-  layer_.set_delegate(this);
+    : corner_radius_(corner_radius) {
 }
 
 TrayBubbleContentMask::~TrayBubbleContentMask() {
-  layer_.set_delegate(NULL);
 }
 
 void TrayBubbleContentMask::OnPaintLayer(gfx::Canvas* canvas) {
   SkPath path;

[Mr4D (OOO till 08-26), 2013/12/10 15:28:58]

Could you please add a comment towards why you are using this bounds rather then
the layer's bounds?

[michaelpg, 2013/12/10 22:01:34]

As discussed, we are using the layer's bounds. :)

-  path.addRoundRect(gfx::RectToSkRect(gfx::Rect(layer()->bounds().size())),
+  path.addRoundRect(gfx::RectToSkRect(gfx::Rect(bounds_.size())),
                     corner_radius_, corner_radius_);
   SkPaint paint;
   paint.setAlpha(255);
   paint.setStyle(SkPaint::kFill_Style);
   canvas->DrawPath(path, paint);
 }
 
 void TrayBubbleContentMask::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   // Redrawing will take care of scale factor change.
@@ skipping 114 matching lines @@
     SetPaintToLayer(true);
     SetFillsBoundsOpaquely(true);
 
     bubble_content_mask_.reset(
         new TrayBubbleContentMask(bubble_border_->GetBorderCornerRadius()));
   }
 }
 
 TrayBubbleView::~TrayBubbleView() {
   mouse_watcher_.reset();
+
+  if (get_use_acceleration_when_possible() &&

[stevenjb, 2013/12/10 22:16:02]

Do we need the first check? i.e. if it's false, then
layer()->parent()->layer_mask_layer() is always going to be NULL anyway, yes?
Removing the extra test means that if the logic changes, it only needs to happen
in one place.

[michaelpg, 2013/12/10 22:26:08]

Yes, you're right. I added the second check because in most cases the layer is
recreated before this destructor is called, and that makes the first check
redundant.

+      layer()->parent()->layer_mask_layer())
+    layer()->parent()->layer_mask_layer()->set_delegate(NULL);
+
   // Inform host items (models) that their views are being destroyed.
   if (delegate_)
     delegate_->BubbleViewDestroyed();
 }
 
 void TrayBubbleView::InitializeAndShowBubble() {
   // Must occur after call to BubbleDelegateView::CreateBubble().
   SetAlignment(params_.arrow_alignment);
   bubble_border_->UpdateArrowOffset();
 
-  if (get_use_acceleration_when_possible())
-    layer()->parent()->SetMaskLayer(bubble_content_mask_->layer());
+  if (get_use_acceleration_when_possible()) {
+    scoped_ptr<ui::Layer> mask_layer(new ui::Layer(ui::LAYER_TEXTURED));
+    mask_layer->set_delegate(bubble_content_mask_.get());
+    layer()->parent()->SetMaskLayer(mask_layer.Pass());
+  }
 
   GetWidget()->Show();
   UpdateBubble();
 }
 
 void TrayBubbleView::UpdateBubble() {
   SizeToContents();
-  if (get_use_acceleration_when_possible())
-    bubble_content_mask_->layer()->SetBounds(layer()->bounds());
+  if (get_use_acceleration_when_possible()) {
+    bubble_content_mask_->set_bounds(layer()->bounds());
+    if (layer()->parent()->layer_mask_layer())
+      layer()->parent()->layer_mask_layer()->SetBounds(layer()->bounds());
+  }
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 void TrayBubbleView::SetMaxHeight(int height) {
   params_.max_height = height;
   if (GetWidget())
     SizeToContents();
 }
 
 void TrayBubbleView::SetWidth(int width) {
@@ skipping 128 matching lines @@
     const ViewHierarchyChangedDetails& details) {
   if (get_use_acceleration_when_possible() && details.is_add &&
       details.child == this) {
     details.parent->SetPaintToLayer(true);
     details.parent->SetFillsBoundsOpaquely(true);
     details.parent->layer()->SetMasksToBounds(true);
   }
 }
 
 }  // namespace views