Tablet WM : Swiping on system tray bubble.

ash/system/tray/system_tray_bubble.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 "ash/system/tray/system_tray_bubble.h"
 
 #include <utility>
 #include <vector>
 
 #include "ash/session/session_controller.h"
@@ skipping 50 matching lines @@
   }
 
  private:
   std::unique_ptr<ui::Layer> layer_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimationObserverDeleteLayer);
 };
 
 }  // namespace
 
+// CloseBubbleObserver is used to delay closing the system tray bubble until the
+// animation completes.
+class CloseBubbleObserver : public ui::ImplicitAnimationObserver {
+ public:
+  explicit CloseBubbleObserver(SystemTrayBubble* system_tray_bubble)
+      : system_tray_bubble_(system_tray_bubble) {}
+
+  ~CloseBubbleObserver() override {}
+
+  void OnImplicitAnimationsCompleted() override {
+    if (system_tray_bubble_)

[xiyuan, 2017/06/16 17:33:42]

What if |system_tray_bubble_| go away before the animation finishes? Testing
|system_tray_bubble_| probably does not help on that.

If OnImplicitAnimationsCompleted() is called when bubble widget is closed before
animation finishes, we can drop the "if (system_tray_bubble_)" since it is not
useful.

If it is not called, then we might need to also observe the bubble widget so
that we clean up properly for such situation.

Think you can verify this by extending the animation to some long time (e.g. 5
seconds), then try to dismiss the tray (clicking on desktop, on the tray again
etc) while animation runs.

[minch1, 2017/06/16 22:11:51]

Verified that OnImplicitAnimationsCompleted() will be called if bubble_widget is
closed before animation finishes (click the desktop before the animation time
exhausted). Remove "if (system_tray_bubble_)" directly here.

[xiyuan, 2017/06/16 23:09:13]

Ack. Thanks.

+      system_tray_bubble_->Close();
+    delete this;
+  }
+
+ private:
+  SystemTrayBubble* system_tray_bubble_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(CloseBubbleObserver);
+};
+
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(nullptr),
       items_(items),
       bubble_type_(bubble_type),
@@ skipping 109 matching lines @@
                                 TrayBubbleView::InitParams* init_params) {
   DCHECK(anchor);
   DCHECK(!bubble_view_);
 
   if (bubble_type_ == BUBBLE_TYPE_DETAILED &&
       init_params->max_height < GetDetailedBubbleMaxHeight()) {
     init_params->max_height = GetDetailedBubbleMaxHeight();
   }
 
   init_params->delegate = tray_;
-  // Place the bubble on same display as this system tray.
-  init_params->parent_window = tray_->GetBubbleWindowContainer();
+  // Place the bubble on same display as this system tray if it is not on
+  // maximize mode. Otherwise, create an clipping window to hold the system
+  // bubble. And place the clipping window on the same display as the system
+  // tray.
+  if (tray_->in_maximize_mode()) {
+    if (!clipping_window_)
+      clipping_window_ = new aura::Window(nullptr);

[xiyuan, 2017/06/16 17:33:43]

When would |clipping_window_| be released?

We probably should do
  delete clipping_window_;
in SystemTrayBubble's dtor to balance this new.

[minch1, 2017/06/16 22:11:51]

Done.

+    clipping_window_->Init(ui::LAYER_NOT_DRAWN);
+    clipping_window_->layer()->SetMasksToBounds(true);
+    clipping_window_->SetBounds(tray_->GetWorkAreaBoundsInScreen());
+    tray_->GetBubbleWindowContainer()->AddChild(clipping_window_);
+    clipping_window_->Show();

[xiyuan, 2017/06/16 17:33:43]

Line 228-232 (except line 230 that updates bounds to match workarea) should be
included in "if (!clipping_window_)" as well since they only need to run once.

[minch1, 2017/06/16 22:11:51]

Done.

+    init_params->parent_window = clipping_window_;
+  } else {
+    init_params->parent_window = tray_->GetBubbleWindowContainer();
+  }
+
   init_params->anchor_view = anchor;
   bubble_view_ = new TrayBubbleView(*init_params);
   UpdateBottomPadding();
   bubble_view_->set_adjust_if_offscreen(false);
   CreateItemViews(login_status);
 
   if (bubble_view_->CanActivate()) {
     bubble_view_->NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, true);
   }
 }
@@ skipping 79 matching lines @@
   for (const std::pair<SystemTrayItem::UmaType, views::View*>& pair :
        tray_item_view_map_) {
     if (pair.second->visible() &&
         pair.first != SystemTrayItem::UMA_NOT_RECORDED) {
       UMA_HISTOGRAM_ENUMERATION("Ash.SystemMenu.DefaultView.VisibleRows",
                                 pair.first, SystemTrayItem::UMA_COUNT);
     }
   }
 }
 
+void SystemTrayBubble::UpdateBounds(const gfx::Rect& target_bounds,
+                                    bool close_bubble) {
+  const int kAnimationDurationMS = 200;
+
+  ui::ScopedLayerAnimationSettings settings(
+      bubble_view()->GetWidget()->GetNativeView()->layer()->GetAnimator());
+  settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kAnimationDurationMS));
+  settings.SetTweenType(gfx::Tween::EASE_OUT);
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  if (close_bubble)
+    settings.AddObserver(new CloseBubbleObserver(this));
+  bubble_view()->GetWidget()->SetBounds(target_bounds);
+}
+
 void SystemTrayBubble::UpdateBottomPadding() {
   if (bubble_type_ == BUBBLE_TYPE_DEFAULT)
     bubble_view_->SetBottomPadding(kDefaultViewBottomPadding);
   else
     bubble_view_->SetBottomPadding(0);
 }
 
 void SystemTrayBubble::CreateItemViews(LoginStatus login_status) {
   tray_item_view_map_.clear();
 
@@ skipping 23 matching lines @@
     }
   }
 
   if (focus_view) {
     tray_->ActivateBubble();
     focus_view->RequestFocus();
   }
 }
 
 }  // namespace ash