Draggable peeking/fullscreen launcher with transparent background.

ui/app_list/views/app_list_view.cc

Index: ui/app_list/views/app_list_view.cc
diff --git a/ui/app_list/views/app_list_view.cc b/ui/app_list/views/app_list_view.cc
index 060e7d718b0806e9c333653e0f6d5274b17a4e10..a4a57f9f653204b1215849092131bfa153412077 100644
--- a/ui/app_list/views/app_list_view.cc
+++ b/ui/app_list/views/app_list_view.cc
@@ -53,10 +53,27 @@ namespace app_list {
 namespace {
 
 // The margin from the edge to the speech UI.
-const int kSpeechUIMargin = 12;
+constexpr int kSpeechUIMargin = 12;
+
+// The height/width of the shelf.
+constexpr int kShelfSize = 48;
+
+// The height of the peeking launcher.
+constexpr int kPeekingLauncherHeight = 320;
+
+// The fraction of launcher height that the launcher must be released at in
+// order to transition to the next state.
+constexpr int kLauncherThresholdDenominator = 3;
+
+// The velocity the launcher must be dragged in order to transition to the next
+// state, measured in DIPs/event.
+constexpr int kLauncherDragVelocityThreshold = 25;
+
+// The opacity of the launcher background.
+constexpr float kLauncherOpacity = 0.8;
 
 // The vertical position for the appearing animation of the speech UI.
-const float kSpeechUIAppearingPosition = 12;
+constexpr float kSpeechUIAppearingPosition = 12;
 
 // This view forwards the focus to the search box widget by providing it as a
 // FocusTraversable when a focus search is provided.
@@ -174,11 +191,15 @@ AppListView::AppListView(AppListViewDelegate* delegate)
       search_box_focus_host_(nullptr),
       search_box_widget_(nullptr),
       search_box_view_(nullptr),
+      display_observer_(this),
       overlay_view_(nullptr),
       animation_observer_(new HideViewAnimationObserver()) {
   CHECK(delegate);
 
   delegate_->GetSpeechUI()->AddObserver(this);
+
+  if (features::IsFullscreenAppListEnabled())
+    display_observer_.Add(display::Screen::GetScreen());
 }
 
 AppListView::~AppListView() {
@@ -202,8 +223,10 @@ void AppListView::Initialize(gfx::NativeView parent, int initial_apps_page) {
 
   InitChildWidgets();
   AddChildView(overlay_view_);
+
   if (delegate_)
     delegate_->ViewInitialized();
+
   UMA_HISTOGRAM_TIMES("Apps.AppListCreationTime",
                       base::Time::Now() - start_time);
 }
@@ -236,10 +259,18 @@ void AppListView::CloseAppList() {
 
 void AppListView::UpdateBounds() {
   // if the AppListView is a bubble
-  if (!features::IsFullscreenAppListEnabled())
+  if (!launcher_background_shield_)

[msw, 2017/06/06 17:56:31]

q: Why change this? it seems to make more sense to check
IsFullscreenAppListEnabled, and then remove this function altogether once the
feature is always enabled, right?

[newcomer, 2017/06/06 23:26:27]

Done.

     SizeToContents();
 }
 
+void AppListView::UpdateDimensions() {
+  display_work_area_bounds_ = display::Screen::GetScreen()

[msw, 2017/06/06 17:56:32]

optional: I don't think it makes sense to cache |display_work_area_bounds_| nor
|default_y_for_state_| as members of the AppListView class, they should just be
calculated as needed as function-local variables. If you take that advice, you
can remove UpdateDimensions, or replace it with a cc-local anon namespace
function like |int GetPeekingYPosition()|.

[newcomer, 2017/06/06 23:26:28]

Removed UpdateBounds() and created local variables that serve the same
functionality without caching.

+                                  ->GetDisplayNearestView(parent_window())
+                                  .work_area();
+  default_y_for_state_ =
+      display_work_area_bounds_.height() + kShelfSize - kPeekingLauncherHeight;
+}
+
 void AppListView::SetAppListOverlayVisible(bool visible) {
   DCHECK(overlay_view_);
 
@@ -329,14 +360,23 @@ void AppListView::InitContents(gfx::NativeView parent, int initial_apps_page) {
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "440224, 441028 AppListView::InitContents"));
 
-  app_list_main_view_ = new AppListMainView(delegate_);
+  if (features::IsFullscreenAppListEnabled()) {
+    // The shield view that colors the background of the launcher and makes it
+    // transparent.
+    launcher_background_shield_ = new views::View;
+    launcher_background_shield_->SetPaintToLayer(ui::LAYER_SOLID_COLOR);
+    launcher_background_shield_->layer()->SetColor(SK_ColorBLACK);
+    launcher_background_shield_->layer()->SetOpacity(kLauncherOpacity);
+    AddChildView(launcher_background_shield_);
+  }
+  app_list_main_view_ = new AppListMainView(delegate_, this);
   AddChildView(app_list_main_view_);
   app_list_main_view_->SetPaintToLayer();
   app_list_main_view_->layer()->SetFillsBoundsOpaquely(false);
   app_list_main_view_->layer()->SetMasksToBounds(true);
   // This will be added to the |search_box_widget_| after the app list widget is
   // initialized.
-  search_box_view_ = new SearchBoxView(app_list_main_view_, delegate_);
+  search_box_view_ = new SearchBoxView(app_list_main_view_, delegate_, this);
   search_box_view_->SetPaintToLayer();
   search_box_view_->layer()->SetFillsBoundsOpaquely(false);
   search_box_view_->layer()->SetMasksToBounds(true);
@@ -403,21 +443,34 @@ void AppListView::InitChildWidgets() {
 
 void AppListView::InitializeFullscreen(gfx::NativeView parent,
                                        int initial_apps_page) {
-  views::Widget* widget = new views::Widget;
+  UpdateDimensions();
+
+  gfx::Rect app_list_overlay_view_bounds(
+      display_work_area_bounds_.x(), default_y_for_state_,
+      display_work_area_bounds_.width(),
+      display_work_area_bounds_.height() + kShelfSize);
+
+  fullscreen_widget_ = new views::Widget;
   views::Widget::InitParams app_list_overlay_view_params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 
+  app_list_overlay_view_params.name = "AppList";
   app_list_overlay_view_params.parent = parent;
   app_list_overlay_view_params.delegate = this;
   app_list_overlay_view_params.opacity =
       views::Widget::InitParams::TRANSLUCENT_WINDOW;
-  app_list_overlay_view_params.bounds =
-      display::Screen::GetScreen()->
-      GetDisplayNearestView(parent).work_area();
-  widget->Init(app_list_overlay_view_params);
-  widget->GetLayer()->SetBackgroundBlur(10);
+  app_list_overlay_view_params.bounds = app_list_overlay_view_bounds;

[msw, 2017/06/06 17:56:32]

When you make the bounds of this widget extend beyond the display's lower edge
(by using the full display height with the top y-coordinate of the peeking app
list state), does that make the widget extend onto a display located below the
display actually showing the app list? You should test this with a vertical
multi-display setup, to ensure we don't have some weird behavior like that. I
think this command line switch should help: chrome
--ash-host-window-bounds=600x600,0+700-600x600 [maybe also try
--ash-enable-unified-desktop?]

[newcomer, 2017/06/06 23:26:28]

It does not extend onto any other display regardless of position. (I just
manually tested it). 

+  app_list_overlay_view_params.layer_type = ui::LAYER_SOLID_COLOR;
+  fullscreen_widget_->Init(app_list_overlay_view_params);
 
+  fullscreen_widget_bounds_ = fullscreen_widget_->GetWindowBoundsInScreen();
   overlay_view_ = new AppListOverlayView(0 /* no corners */);
+
+  // Launcher + shelf height, used in HandleDrag.
+  launcher_threshold_ =
+      (default_y_for_state_ + fullscreen_widget_bounds_.height() -
+       fullscreen_widget_bounds_.y()) /
+      kLauncherThresholdDenominator;
 }
 
 void AppListView::InitializeBubble(gfx::NativeView parent,
@@ -427,7 +480,7 @@ void AppListView::InitializeBubble(gfx::NativeView parent,
   set_shadow(views::BubbleBorder::NO_ASSETS);
 
   // This creates the app list widget. (Before this, child widgets cannot be
-  // created.)
+  // created.

[msw, 2017/06/06 17:56:32]

nit: don't remove the close paren, or remove the open paren too

[newcomer, 2017/06/06 23:26:28]

Done.

   views::BubbleDialogDelegateView::CreateBubble(this);
 
   SetBubbleArrow(views::BubbleBorder::FLOAT);
@@ -442,6 +495,96 @@ void AppListView::InitializeBubble(gfx::NativeView parent,
   overlay_view_->SetBoundsRect(GetContentsBounds());
 }
 
+void AppListView::HandleDrag(const gfx::Point& location, ui::EventType type) {

[msw, 2017/06/06 17:56:32]

I suggest removing this function, and just inlining the calls to
Start/Update/EndDrag in OnMouseEvent and OnGestureEvent, where you already have
EventType switch statements. (remove a layer of indirection)

[newcomer, 2017/06/06 23:26:27]

Done.

+  switch (type) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+    case ui::ET_MOUSE_PRESSED: {
+      StartDrag(location);
+      break;
+    }
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+    case ui::ET_MOUSE_DRAGGED: {
+      UpdateDrag(location);
+      break;
+    }
+    case ui::ET_GESTURE_END:
+    case ui::ET_MOUSE_RELEASED: {
+      EndDrag(location);
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void AppListView::StartDrag(const gfx::Point& location) {
+  initial_drag_separation_ = location.y();

[msw, 2017/06/06 17:56:32]

nit: keep a member |gfx::Point initial_drag_location_| instead, the meaning of
that is more immediately obvious than a 'separation' int

[newcomer, 2017/06/06 23:26:28]

Done.

+  fullscreen_widget_bounds_ = fullscreen_widget_->GetWindowBoundsInScreen();

[msw, 2017/06/06 17:56:31]

I'm not sure it makes sense to cache |fullscreen_widget_bounds_| as a class
member, if the value is readily accessible as
fullscreen_widget_->GetWindowBoundsInScreen()

[newcomer, 2017/06/06 23:26:28]

Done.

+}
+
+void AppListView::UpdateDrag(const gfx::Point& location) {
+  // Update the bounds of the widget while maintaining the
+  // relative position of the top of the widget and the mouse/gesture.
+  // Block drags north of 0 and recalculate the initial_drag_separation_.
+  int const new_y_position =
+      location.y() - initial_drag_separation_ + fullscreen_widget_bounds_.y();
+  if (new_y_position < 0) {
+    fullscreen_widget_bounds_.set_y(0);
+    initial_drag_separation_ = location.y();
+  } else {
+    fullscreen_widget_bounds_.set_y(new_y_position);
+  }
+  fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+}
+
+void AppListView::EndDrag(const gfx::Point& location) {
+  // Change the launcher state based on where the drag ended. If fling velocity
+  // was over the threshold, snap to the next state in the direction of the
+  // fling.
+  int const new_y_position =
+      location.y() - initial_drag_separation_ + fullscreen_widget_bounds_.y();
+  if (std::abs(last_fling_velocity_) > kLauncherDragVelocityThreshold) {
+    // If the user releases drag with velocity over the threshold, snap to
+    // the next state, ignoring the drag release position.
+    if (is_fullscreen_launcher_) {
+      if (last_fling_velocity_ > 0) {
+        ToPeeking();
+      }
+    } else {
+      if (last_fling_velocity_ > 0) {
+        CloseAppList();
+      } else if (last_fling_velocity_ < 0) {
+        ToFullscreen();
+      }
+    }
+    last_fling_velocity_ = 0;
+  } else {
+    // The drag release velocity was too low, so use the release point.
+    int launcher_snap_y = is_fullscreen_launcher_ ? 0 : default_y_for_state_;
+    // If the user releases +/- 1/3 of launcher_threshold_ , snap to the

[msw, 2017/06/06 17:56:32]

nit: no space before comma, feel free to use vertical bars around |identifiers|
in comments here and elsewhere

[newcomer, 2017/06/06 23:26:28]

Done.

+    // next state.
+    if (std::abs(launcher_snap_y - new_y_position) < (launcher_threshold_)) {

[msw, 2017/06/06 17:56:31]

I don't think it makes sense to cache |launcher_threshold_| as a member
variable, it's only really used in this conditional block of this function, and
it's easy enough to calculate here.

[msw, 2017/06/06 17:56:32]

nit: no parens needed around |launcher_threshold_|

[newcomer, 2017/06/06 23:26:28]

Done.

[newcomer, 2017/06/06 23:26:28]

Done.

+      // If the drag released to the state above.

[msw, 2017/06/06 17:56:32]

Can you try clarifying this comment? It doesn't seem helpful to me.

[newcomer, 2017/06/06 23:26:28]

Done.

+      if (is_fullscreen_launcher_) {

[msw, 2017/06/06 17:56:32]

Does this actually do anything? It seems like you're instructing the app list to
go to fullscreen when it already is fullscreen, ditto for peeking. I suppose
this might be fitting the app list bounds to the target bounds from some
intermediary drag state? If so, revise the comment to something like: "Set the
app list bounds to the target bounds for the current state, to revert the
incomplete drag resizing."

[newcomer, 2017/06/06 23:26:28]

Done.

+        ToFullscreen();
+      } else {
+        ToPeeking();
+      }
+    } else if ((launcher_snap_y + (launcher_threshold_)) < new_y_position) {

[msw, 2017/06/06 17:56:31]

nit: no parens needed around |launcher_threshold_|

[newcomer, 2017/06/06 23:26:27]

Done.

+      // If the user released to the state below.

[msw, 2017/06/06 17:56:31]

Can you try clarifying this comment? It doesn't seem helpful to me.

[newcomer, 2017/06/06 23:26:28]

Done.

+      if (is_fullscreen_launcher_) {
+        ToPeeking();
+      } else {
+        CloseAppList();
+      }
+    } else {
+      // if the user released to the state above, go to the state above.

[msw, 2017/06/06 17:56:32]

Can you try clarifying this comment? It doesn't seem helpful to me.

[newcomer, 2017/06/06 23:26:28]

Done.

+      ToFullscreen();
+    }
+  }
+}
+
 void AppListView::OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
                                            views::Widget* widget) const {
   if (!params->native_widget) {
@@ -475,6 +618,42 @@ void AppListView::GetWidgetHitTestMask(gfx::Path* mask) const {
   mask->addRect(gfx::RectToSkRect(GetBubbleFrameView()->GetContentsBounds()));
 }
 
+void AppListView::OnMouseEvent(ui::MouseEvent* event) {
+  if (!launcher_background_shield_)

[msw, 2017/06/06 17:56:31]

ditto: it seems to make more sense to check IsFullscreenAppListEnabled, and then
remove this early return altogether once the feature is always enabled, right?

[newcomer, 2017/06/06 23:26:27]

Done.

+    return;
+
+  switch (event->type()) {
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_DRAGGED:
+    case ui::ET_MOUSE_RELEASED:
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    default:
+      break;
+  }
+}
+
+void AppListView::OnGestureEvent(ui::GestureEvent* event) {
+  if (!launcher_background_shield_)

[msw, 2017/06/06 17:56:31]

ditto: it seems to make more sense to check IsFullscreenAppListEnabled, and then
remove this early return altogether once the feature is always enabled, right?

[newcomer, 2017/06/06 23:26:28]

Done.

+    return;
+
+  switch (event->type()) {
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      last_fling_velocity_ = event->details().velocity_y();
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+    case ui::ET_GESTURE_END:
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    default:
+      break;
+  }
+}
+
 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
 
@@ -510,6 +689,11 @@ void AppListView::Layout() {
     speech_bounds.Inset(-speech_view_->GetInsets());
     speech_view_->SetBoundsRect(speech_bounds);
   }
+  // If the fullscreen feature has been enabled.

[msw, 2017/06/06 17:56:32]

Ditto, why comment and then check for the shield? Just check the feature flag

[newcomer, 2017/06/06 23:26:28]

Done.

+  if (launcher_background_shield_) {
+    app_list_main_view_->contents_view()->Layout();
+    launcher_background_shield_->SetBoundsRect(contents_bounds);
+  }
 }
 
 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
@@ -518,6 +702,27 @@ void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
     GetBubbleFrameView()->SchedulePaint();
 }
 
+void AppListView::ToFullscreen() {
+  fullscreen_widget_bounds_.set_y(0);
+  fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+  is_fullscreen_launcher_ = true;
+  launcher_threshold_ = (fullscreen_widget_bounds_.height() + kShelfSize) /
+                        kLauncherThresholdDenominator;
+}
+
+void AppListView::ToPeeking() {
+  fullscreen_widget_bounds_.set_y(default_y_for_state_);
+  fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+  is_fullscreen_launcher_ = false;
+  launcher_threshold_ = (fullscreen_widget_bounds_.height() + kShelfSize -
+                         kPeekingLauncherHeight) /
+                        kLauncherThresholdDenominator;
+}
+
+bool AppListView::IsFullscreen() const {
+  return is_fullscreen_launcher_;
+}
+
 void AppListView::OnWidgetDestroying(views::Widget* widget) {
   BubbleDialogDelegateView::OnWidgetDestroying(widget);
   if (delegate_ && widget == GetWidget())
@@ -602,4 +807,25 @@ void AppListView::OnSpeechRecognitionStateChanged(
   }
 }
 
+void AppListView::OnDisplayMetricsChanged(const display::Display& display,
+                                          uint32_t changed_metrics) {
+  if (!launcher_background_shield_)

[msw, 2017/06/06 17:56:32]

ditto: check the feature flag

[newcomer, 2017/06/06 23:26:28]

Done.

+    return;
+
+  UpdateDimensions();
+
+  gfx::Rect recomputed_fullscreen_widget_bounds(

[msw, 2017/06/06 17:56:31]

nit: inline this below, there's no reason for this temporary value

[newcomer, 2017/06/06 23:26:28]

Done.

+      display_work_area_bounds_.x(), default_y_for_state_,
+      display_work_area_bounds_.width(),
+      display_work_area_bounds_.height() + kShelfSize);
+
+  fullscreen_widget_bounds_ = recomputed_fullscreen_widget_bounds;
+
+  if (is_fullscreen_launcher_) {

[msw, 2017/06/06 17:56:32]

nit: curlies not needed

[newcomer, 2017/06/06 23:26:28]

Done.

+    ToFullscreen();
+  } else {
+    ToPeeking();
+  }
+}
+
 }  // namespace app_list