Touch gestures for System Tray/ IME/ Stylus/ Notifications

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 71 matching lines @@
     system_tray_bubble_->Close();
     delete this;
   }
 
  private:
   SystemTrayBubble* system_tray_bubble_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(CloseBubbleObserver);
 };
 
+class SystemTrayBubbleView : public TrayBubbleView {

[tdanderson, 2017/07/04 21:50:45]

I agree with earlier comments regarding the event-handling logic here; to me it
seems out of place that you are performing event-handling logic in SystemTray
for the bubble itself.

Please correct me if I am mistaken, but as I understand the specs, you would
like to do all of the following (is all of this work targeted for M-61?):

(1) Swiping up on the following tray surfaces should open the corresponding
bubble:
- system menu
- notifications
- palette
- IME menu

(2) Swiping up anywhere else on the shelf will show the launcher.

(3) Swiping down on an open bubble will close the bubble:
- system menu
- notifications
- palette
- IME menu


Now might be the best time to take a step back and put together a small design
doc for what you want the final implementation to look like. Here are some
thoughts that may help:

* Regarding (3), note that all of the surfaces listed are already subclasses of
TrayBubbleView. Instead of creating SystemTrayBubbleView, consider overriding
OnGestureEvent() in the TrayBubbleView; that will be a common entry point for
gesture events  among all four bubble types.

* Regarding (1), note that all of the surfaces listed are subclasses of
TrayBackgroundView and will all need to have the same swipe-up logic you
currently have in SystemTray. Consider overriding OnGestureEvent() in
TrayBackgroundView instead. Note that there are some TrayBackgroundView
subclasses which have currently-undefined behavior for swipe-up (see
https://bugs.chromium.org/p/chromium/issues/detail?id=725977#c4). You (or your
TL) should reach out to PM/UX to find out what should happen for swipe-up on all
surfaces; for example, should swipe-up on the overview mode button launch
overview mode?

* Then, to share code, an idea off the top of my head: introduce a new class
(for lack of a better name let's call it TrayDragController) that contains all
of the drag logic, current drag amount, etc. TrayBubbleView and
TrayBackgroundView could each have an instance of TrayDragController, then call
into TrayDragController from TrayBubbleView::OnGestureEvent() and
TrayBackgroundView::OnGestureEvent().


I am happy to discuss and iterate on this design with you. IMO this will
ultimately make it much easier for you to accomplish (1)-(3) for M-61 if that is
your goal. But again please let me know if I am mistaken on the scope of what
you are trying to accomplish.

+ public:
+  SystemTrayBubbleView(TrayBubbleView::InitParams* init_params,
+                       SystemTray* tray)
+      : TrayBubbleView(*init_params), tray_(tray) {}
+
+  // views::View:
+  void OnGestureEvent(ui::GestureEvent* event) override {
+    if (tray_ && tray_->ProcessGestureEvent(*event, true /* is_on_bubble */))
+      event->SetHandled();
+    else
+      TrayBubbleView::OnGestureEvent(event);
+  }
+
+ private:
+  SystemTray* tray_;  // Not owned.
+
+  DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleView);
+};  // namespace ash
+
 // 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 134 matching lines @@
       tray_->GetBubbleWindowContainer()->AddChild(clipping_window_.get());
       clipping_window_->Show();
     }
     clipping_window_->SetBounds(tray_->GetWorkAreaBoundsInScreen());
     init_params->parent_window = clipping_window_.get();
   } else {
     init_params->parent_window = tray_->GetBubbleWindowContainer();
   }
 
   init_params->anchor_view = anchor;
-  bubble_view_ = new TrayBubbleView(*init_params);
+  bubble_view_ = new SystemTrayBubbleView(init_params, tray_);
   UpdateBottomPadding();
   bubble_view_->set_adjust_if_offscreen(false);
   CreateItemViews(login_status);
 
   if (bubble_view_->CanActivate()) {
     bubble_view_->NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, true);
   }
 }
 
 void SystemTrayBubble::DestroyItemViews() {
@@ skipping 125 matching lines @@
     }
   }
 
   if (focus_view) {
     tray_->ActivateBubble();
     focus_view->RequestFocus();
   }
 }
 
 }  // namespace ash