[Test]Swiping on system tray bubble.

ash/system/tray/system_tray.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.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 60 matching lines @@
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
 using views::TrayBubbleView;
 
 namespace ash {
 
+// The velocity of the swiping on the system bubble.
+constexpr float kSwipingVelocity = 100.0;
+
 namespace {
 
 // A tray item that just reserves space in the tray.
 class PaddingTrayItem : public SystemTrayItem {
  public:
   PaddingTrayItem() : SystemTrayItem(nullptr, UMA_NOT_RECORDED) {}
   ~PaddingTrayItem() override {}
 
   // SystemTrayItem:
   views::View* CreateTrayView(LoginStatus status) override {
@@ skipping 73 matching lines @@
 
   // WmActivationObserver:
   void OnWindowActivated(ActivationReason reason,
                          aura::Window* gained_active,
                          aura::Window* lost_active) override {
     if (!tray_->HasSystemBubble() || !gained_active)
       return;
 
     int container_id = wm::GetContainerForWindow(gained_active)->id();
 
-    // Don't close the bubble if a popup notification is activated.
-    if (container_id == kShellWindowId_StatusContainer)
+    // Don't close the bubble if a popup notification is activated and don't
+    // close the the bubble if click the items in the default system tray bubble
+    // on maximize mode.
+    if (container_id == kShellWindowId_StatusContainer ||
+        container_id == kShellWindowId_SettingBubbleContainer)
       return;
 
     views::Widget* bubble_widget =
         tray_->GetSystemBubble()->bubble_view()->GetWidget();
     // Don't close the bubble if a transient child is gaining or losing
     // activation.
     if (bubble_widget == GetInternalWidgetForWindow(gained_active) ||
         ::wm::HasTransientAncestor(gained_active,
                                    bubble_widget->GetNativeWindow()) ||
         (lost_active && ::wm::HasTransientAncestor(
                             lost_active, bubble_widget->GetNativeWindow()))) {
       return;
     }
 
     tray_->CloseSystemBubble();
   }
 
  private:
   SystemTray* tray_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivationObserver);
 };
 
 // SystemTray
 
-SystemTray::SystemTray(Shelf* shelf) : TrayBackgroundView(shelf) {
+SystemTray::SystemTray(Shelf* shelf)
+    : TrayBackgroundView(shelf), shelf_(shelf) {
   SetInkDropMode(InkDropMode::ON);
 
   // Since user avatar is on the right hand side of System tray of a
   // horizontal shelf and that is sufficient to indicate separation, no
   // separator is required.
   set_separator_visibility(false);
+
+  Shell::Get()->AddShellObserver(this);
 }
 
 SystemTray::~SystemTray() {
   // Destroy any child views that might have back pointers before ~View().
   activation_observer_.reset();
   key_event_watcher_.reset();
   system_bubble_.reset();
   for (const auto& item : items_)
     item->OnTrayViewDestroyed();
+  Shell::Get()->RemoveShellObserver(this);
 }
 
 void SystemTray::InitializeTrayItems(
     SystemTrayDelegate* delegate,
     WebNotificationTray* web_notification_tray) {
   DCHECK(web_notification_tray);
   web_notification_tray_ = web_notification_tray;
   TrayBackgroundView::Initialize();
   CreateItems(delegate);
 }
@@ skipping 355 matching lines @@
 }
 
 base::string16 SystemTray::GetAccessibleNameForBubble() {
   return GetAccessibleNameForTray();
 }
 
 void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
   HideBubbleWithView(bubble_view);
 }
 
+void SystemTray::OnMaximizeModeStarted() {
+  on_maximize_mode_ = true;
+}
+
+void SystemTray::OnMaximizeModeEnded() {
+  on_maximize_mode_ = false;
+}
+
 void SystemTray::CloseBubble(const ui::KeyEvent& key_event) {
   CloseSystemBubble();
 }
 
 void SystemTray::ActivateAndStartNavigation(const ui::KeyEvent& key_event) {
   if (!system_bubble_)
     return;
   ActivateBubble();
 
   views::Widget* widget = GetSystemBubble()->bubble_view()->GetWidget();
@@ skipping 21 matching lines @@
 void SystemTray::ActivateBubble() {
   TrayBubbleView* bubble_view = GetSystemBubble()->bubble_view();
   // If system tray bubble is in the process of closing, do not try to activate
   // bubble.
   if (bubble_view->GetWidget()->IsClosed())
     return;
   bubble_view->set_can_activate(true);
   bubble_view->GetWidget()->Activate();
 }
 
+gfx::Rect SystemTray::GetWorkAreaBoundsInScreen() const {
+  return shelf_->GetUserWorkAreaBounds();
+}
+
 bool SystemTray::PerformAction(const ui::Event& event) {
   // If we're already showing the default view or detailed view in system menu,
   // hide it; otherwise, show it (and hide any popup that's currently shown).
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT) ||
       (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED) &&
        full_system_tray_menu_)) {
     system_bubble_->bubble()->Close();
   } else {
     ShowDefaultView(BUBBLE_CREATE_NEW);
     if (event.IsKeyEvent() || (event.flags() & ui::EF_TOUCH_ACCESSIBILITY))
       ActivateBubble();
   }
   return true;
 }
 
+void SystemTray::OnGestureEvent(ui::GestureEvent* event) {
+  if (on_maximize_mode_ && shelf_->IsHorizontalAlignment() &&
+      ProcessGestureEvent(*event))
+    event->StopPropagation();
+  else
+    CustomButton::OnGestureEvent(event);
+}
+
+bool SystemTray::ProcessGestureEvent(const ui::GestureEvent& event) {
+  if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN) {
+    return StartGestureDrag(event);
+  }
+
+  if (event.type() == ui::ET_GESTURE_SCROLL_UPDATE) {
+    UpdateGestureDrag(event);
+    return true;
+  }
+
+  if (event.type() == ui::ET_GESTURE_SCROLL_END ||
+      event.type() == ui::ET_SCROLL_FLING_START) {
+    CompleteGestureDrag(event);
+    return true;
+  }
+  return false;
+}
+
+bool SystemTray::StartGestureDrag(const ui::GestureEvent& gesture) {
+  if (full_system_tray_menu_ || IsSwipingDownOnShelf(gesture))
+    return false;
+
+  gesture_drag_amount_ = 0.f;
+  ShowDefaultView(BUBBLE_CREATE_NEW);
+  system_tray_bubble_bounds_ =
+      system_bubble_->bubble_view()->GetWidget()->GetWindowBoundsInScreen();
+  system_bubble_->bubble_view()->GetWidget()->Hide();
+  return true;
+}
+
+void SystemTray::UpdateGestureDrag(const ui::GestureEvent& gesture) {
+  gfx::Point gesture_location = gesture.location();
+  View::ConvertPointToScreen(this, &gesture_location);
+
+  // System tray bubble should not be dragged higher than its original height.
+  if (gesture_location.y() < system_tray_bubble_bounds_.y())
+    gesture_location.set_y(system_tray_bubble_bounds_.y());
+  gfx::Rect bounds_on_gesture(
+      system_tray_bubble_bounds_.x(), gesture_location.y(),
+      system_tray_bubble_bounds_.width(), system_tray_bubble_bounds_.height());
+  system_bubble_->bubble_view()->GetWidget()->SetBounds(bounds_on_gesture);
+  system_bubble_->bubble_view()->GetWidget()->Show();
+
+  gesture_drag_amount_ += gesture.details().scroll_y();
+  final_scroll_y_ = gesture.details().scroll_y();
+}
+
+void SystemTray::CompleteGestureDrag(const ui::GestureEvent& gesture) {
+  if (gesture.details().scroll_y())
+    final_scroll_y_ = gesture.details().scroll_y();
+  if (ShouldShowSystemBubbleForSwiping(gesture))
+    system_bubble_->bubble_view()->GetWidget()->SetBounds(
+        system_tray_bubble_bounds_);
+  else
+    system_bubble_->bubble()->Close();
+}
+
+bool SystemTray::IsSwipingDownOnShelf(const ui::GestureEvent& gesture) {
+  gfx::Point gesture_location = gesture.location();
+  View::ConvertPointToScreen(this, &gesture_location);
+
+  if (gesture_location.y() >= shelf_->GetIdealBounds().y() &&
+      gesture.details().scroll_y() > 0) {
+    return true;
+  }
+  return false;
+}
+
+bool SystemTray::ShouldShowSystemBubbleBasedOnPosition() {
+  int system_bubble_height = system_tray_bubble_bounds_.height();
+  float one_third = system_bubble_height / 3.0;
+
+  if (gesture_drag_amount_ > 0)
+    return false;
+
+  if (fabs(gesture_drag_amount_) < one_third)
+    return false;
+  else if (fabs(gesture_drag_amount_) > 2 * one_third)
+    return true;
+  else
+    return final_scroll_y_ < 0;
+}
+
+bool SystemTray::ShouldShowSystemBubbleForSwiping(
+    const ui::GestureEvent& gesture) {
+  if (gesture.type() == ui::ET_GESTURE_SCROLL_END) {
+    return ShouldShowSystemBubbleBasedOnPosition();
+  } else {
+    if (fabs(gesture.details().velocity_y()) > kSwipingVelocity)
+      return gesture.details().velocity_y() < 0;
+    return ShouldShowSystemBubbleBasedOnPosition();
+  }
+}
+
 void SystemTray::CloseSystemBubbleAndDeactivateSystemTray() {
   activation_observer_.reset();
   key_event_watcher_.reset();
   system_bubble_.reset();
   // When closing a system bubble with the alternate shelf layout, we need to
   // turn off the active tinting of the shelf.
   if (full_system_tray_menu_) {
     SetIsActive(false);
     full_system_tray_menu_ = false;
   }
@@ skipping 20 matching lines @@
           .work_area()
           .height();
   if (work_area_height > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Ash.SystemMenu.PercentageOfWorkAreaHeightCoveredByMenu",
         100 * bubble_view->height() / work_area_height, 1, 300, 100);
   }
 }
 
 }  // namespace ash