Implementation of a full screen app list and re-alphabetized switches

ui/app_list/views/app_list_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/app_list/views/app_list_view.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 106 matching lines @@
   bool GetHitTestMask(aura::Window* window, gfx::Path* mask) const override {
     mask->addRect(gfx::RectToSkRect(search_box_->GetContentsBounds()));
     return true;
   }
 
   views::View* search_box_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchBoxWindowTargeter);
 };
 
+// Returns whether the fullscreen app list has been enabled via cmd line switch.
+bool IsFullscreenAppListEnabled() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableFullscreenAppList);
+}
+
 }  // namespace
 
 // An animation observer to hide the view at the end of the animation.
 class HideViewAnimationObserver : public ui::ImplicitAnimationObserver {
  public:
-  HideViewAnimationObserver()
-      : frame_(NULL),
-        target_(NULL) {
-  }
+  HideViewAnimationObserver() : frame_(NULL), target_(NULL) {}
 
   ~HideViewAnimationObserver() override {
     if (target_)
       StopObservingImplicitAnimations();
   }
 
   void SetTarget(views::View* target) {
     if (target_)
       StopObservingImplicitAnimations();
     target_ = target;
@@ skipping 37 matching lines @@
   delegate_->GetSpeechUI()->AddObserver(this);
 }
 
 AppListView::~AppListView() {
   delegate_->GetSpeechUI()->RemoveObserver(this);
   animation_observer_.reset();
   // Remove child views first to ensure no remaining dependencies on delegate_.
   RemoveAllChildViews(true);
 }
 
-void AppListView::InitAsBubble(gfx::NativeView parent, int initial_apps_page) {
+void AppListView::Initialize(gfx::NativeView parent,
+                             int initial_apps_page,
+                             const gfx::Rect& display_work_area_bounds) {
+  base::Time start_time = base::Time::Now();
+  InitContents(parent, initial_apps_page);
+  AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
+  set_color(kContentsBackgroundColor);
+
+  if (IsFullscreenAppListEnabled()) {
+    InitializeFullscreen(parent, initial_apps_page,
+                               display_work_area_bounds);

[vadimt, 2017/04/20 20:21:35]

indentation....

[sky, 2017/04/20 21:08:45]

I think if you run git cl format it'll fix all the spacing issues (hopefully).

[newcomer, 2017/04/21 19:51:22]

I gave it a shot!

+  } else {
+    InitializeBubble(parent, initial_apps_page);
+  }
+
+  InitChildWidgets();
+  AddChildView(overlay_view_);
+  if (delegate_)
+    delegate_->ViewInitialized();
+  UMA_HISTOGRAM_TIMES("Apps.AppListCreationTime",
+                      base::Time::Now() - start_time);
+}
+
+void AppListView::Initialize(gfx::NativeView parent,
+                int initial_apps_page){
   base::Time start_time = base::Time::Now();
 
   InitContents(parent, initial_apps_page);
-
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
-  set_margins(gfx::Insets());
-  set_parent_window(parent);
-  set_close_on_deactivate(false);
-  set_shadow(views::BubbleBorder::NO_ASSETS);
   set_color(kContentsBackgroundColor);
-  // This creates the app list widget. (Before this, child widgets cannot be
-  // created.)
-  views::BubbleDialogDelegateView::CreateBubble(this);
-
-  SetBubbleArrow(views::BubbleBorder::FLOAT);
-  // We can now create the internal widgets.
+  InitializeBubble(parent, initial_apps_page);
   InitChildWidgets();
-
-  aura::Window* window = GetWidget()->GetNativeWindow();
-  window->SetEventTargeter(base::MakeUnique<views::BubbleWindowTargeter>(this));
-
-  const int kOverlayCornerRadius =
-      GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius();
-  overlay_view_ = new AppListOverlayView(kOverlayCornerRadius);
-  overlay_view_->SetBoundsRect(GetContentsBounds());
   AddChildView(overlay_view_);
 
   if (delegate_)
     delegate_->ViewInitialized();
 
   UMA_HISTOGRAM_TIMES("Apps.AppListCreationTime",
-                      base::Time::Now() - start_time);
+                    base::Time::Now() - start_time);
 }
 
 void AppListView::SetBubbleArrow(views::BubbleBorder::Arrow arrow) {
   GetBubbleFrameView()->bubble_border()->set_arrow(arrow);
   SizeToContents();  // Recalcuates with new border.
   GetBubbleFrameView()->SchedulePaint();
 }
 
-void AppListView::SetAnchorPoint(const gfx::Point& anchor_point) {
-  SetAnchorRect(gfx::Rect(anchor_point, gfx::Size()));
+void AppListView::MaybeSetAnchorPoint(const gfx::Point& anchor_point) {
+  // if the AppListView is a bubble
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          app_list::switches::kEnableFullscreenAppList)) {
+    SetAnchorRect(gfx::Rect(anchor_point, gfx::Size()));
+  }
 }
 
 void AppListView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
   app_list_main_view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
 }
 
 void AppListView::ShowWhenReady() {
   app_list_main_view_->ShowAppListWhenReady();
 }
 
 void AppListView::CloseAppList() {
   app_list_main_view_->Close();
   delegate_->Dismiss();
 }
 
 void AppListView::UpdateBounds() {
-  SizeToContents();
+  // if the AppListView is a bubble
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          app_list::switches::kEnableFullscreenAppList)) {
+    SizeToContents();
+  }
 }
 
 void AppListView::SetAppListOverlayVisible(bool visible) {
   DCHECK(overlay_view_);
 
   // Display the overlay immediately so we can begin the animation.
   overlay_view_->SetVisible(true);
 
   ui::ScopedLayerAnimationSettings settings(
       overlay_view_->layer()->GetAnimator());
@@ skipping 33 matching lines @@
 }
 
 void AppListView::OnPaint(gfx::Canvas* canvas) {
   views::BubbleDialogDelegateView::OnPaint(canvas);
   if (!next_paint_callback_.is_null()) {
     next_paint_callback_.Run();
     next_paint_callback_.Reset();
   }
 }
 
+const char* AppListView::GetClassName() const {
+  return "AppListView";
+}
+
 bool AppListView::ShouldHandleSystemCommands() const {
   return true;
 }
 
 bool AppListView::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
   // While on the start page, don't descend into the custom launcher page. Since
   // the only valid action is to open it.
   ContentsView* contents_view = app_list_main_view_->contents_view();
@@ skipping 19 matching lines @@
   // crbug.com/441028 are fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "440224, 441028 AppListView::InitContents"));
 
   app_list_main_view_ = new AppListMainView(delegate_);
   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_->SetPaintToLayer();
   search_box_view_->layer()->SetFillsBoundsOpaquely(false);
   search_box_view_->layer()->SetMasksToBounds(true);
 
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440224 and
   // crbug.com/441028 are fixed.
   tracked_objects::ScopedTracker tracking_profile1(
@@ skipping 46 matching lines @@
       GetWidget()->GetFocusTraversable());
 
   // Mouse events on the search box shadow should not be captured.
   aura::Window* window = search_box_widget_->GetNativeWindow();
   window->SetEventTargeter(
       base::MakeUnique<SearchBoxWindowTargeter>(search_box_view_));
 
   app_list_main_view_->contents_view()->Layout();
 }
 
-void AppListView::OnBeforeBubbleWidgetInit(
-    views::Widget::InitParams* params,
-    views::Widget* widget) const {
+void AppListView::InitializeFullscreen(
+    gfx::NativeView parent,
+    int initial_apps_page,
+    const gfx::Rect& display_work_area_bounds) {
+
+  views::Widget* widget = new views::Widget;
+  views::Widget::InitParams app_list_overlay_view_params(
+      views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
+
+  app_list_overlay_view_params.parent = parent;
+  app_list_overlay_view_params.delegate = this;
+
+  widget->Init(app_list_overlay_view_params);
+  widget->SetBounds(display_work_area_bounds);
+  widget->GetLayer()->SetFillsBoundsOpaquely(false);
+  widget->GetLayer()->SetBackgroundBlur(10);
+
+  overlay_view_ = new AppListOverlayView(0 /* no corners */);
+}
+
+void AppListView::InitializeBubble(gfx::NativeView parent,
+                                         int initial_apps_page) {
+  set_margins(gfx::Insets());
+  set_parent_window(parent);
+  set_close_on_deactivate(false);
+  set_shadow(views::BubbleBorder::NO_ASSETS);
+
+
+  // This creates the app list widget. (Before this, child widgets cannot be
+  // created.)
+  views::BubbleDialogDelegateView::CreateBubble(this);
+
+  SetBubbleArrow(views::BubbleBorder::FLOAT);
+  // We can now create the internal widgets.
+
+  aura::Window* window = GetWidget()->GetNativeWindow();
+  window->SetEventTargeter(base::MakeUnique<views::BubbleWindowTargeter>(this));
+
+  const int kOverlayCornerRadius =
+      GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius();
+  overlay_view_ = new AppListOverlayView(kOverlayCornerRadius);
+  overlay_view_->SetBoundsRect(GetContentsBounds());
+}
+
+void AppListView::OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
+                                           views::Widget* widget) const {
   if (!params->native_widget) {
     views::ViewsDelegate* views_delegate = views::ViewsDelegate::GetInstance();
     if (views_delegate && !views_delegate->native_widget_factory().is_null()) {
       params->native_widget =
           views_delegate->native_widget_factory().Run(*params, widget);
     }
   }
   // Apply a WM-provided shadow (see ui/wm/core/).
   params->shadow_type = views::Widget::InitParams::SHADOW_TYPE_DROP;
   params->shadow_elevation = wm::ShadowElevation::LARGE;
 }
 
 int AppListView::GetDialogButtons() const {
   return ui::DIALOG_BUTTON_NONE;
 }
 
 views::View* AppListView::GetInitiallyFocusedView() {
   return app_list_main_view_->search_box_view()->search_box();
 }
 
 bool AppListView::WidgetHasHitTestMask() const {
   return GetBubbleFrameView() != nullptr;
 }
 
 void AppListView::GetWidgetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
   DCHECK(GetBubbleFrameView());
 
-  mask->addRect(gfx::RectToSkRect(
-      GetBubbleFrameView()->GetContentsBounds()));
+  mask->addRect(gfx::RectToSkRect(GetBubbleFrameView()->GetContentsBounds()));
 }
 
 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
 
   // If the ContentsView does not handle the back action, then this is the
   // top level, so we close the app list.
   if (!app_list_main_view_->contents_view()->Back()) {
     GetWidget()->Deactivate();
     CloseAppList();
@@ skipping 12 matching lines @@
   centered_bounds.ClampToCenteredSize(gfx::Size(
       app_list_main_view_->contents_view()->GetDefaultContentsBounds().width(),
       contents_bounds.height()));
 
   app_list_main_view_->SetBoundsRect(centered_bounds);
 
   if (speech_view_) {
     gfx::Rect speech_bounds = centered_bounds;
     int preferred_height = speech_view_->GetPreferredSize().height();
     speech_bounds.Inset(kSpeechUIMargin, kSpeechUIMargin);
-    speech_bounds.set_height(std::min(speech_bounds.height(),
-                                      preferred_height));
+    speech_bounds.set_height(
+        std::min(speech_bounds.height(), preferred_height));
     speech_bounds.Inset(-speech_view_->GetInsets());
     speech_view_->SetBoundsRect(speech_bounds);
   }
 }
 
 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
   BubbleDialogDelegateView::SchedulePaintInRect(rect);
   if (GetBubbleFrameView())
     GetBubbleFrameView()->SchedulePaint();
 }
@@ skipping 25 matching lines @@
                       new_state == SPEECH_RECOGNITION_NETWORK_ERROR);
   // No change for this class.
   if (speech_view_->visible() == will_appear)
     return;
 
   if (will_appear)
     speech_view_->Reset();
 
   animation_observer_->set_frame(GetBubbleFrameView());
   gfx::Transform speech_transform;
-  speech_transform.Translate(
-      0, SkFloatToMScalar(kSpeechUIAppearingPosition));
+  speech_transform.Translate(0, SkFloatToMScalar(kSpeechUIAppearingPosition));
   if (will_appear)
     speech_view_->layer()->SetTransform(speech_transform);
 
   {
     ui::ScopedLayerAnimationSettings main_settings(
         app_list_main_view_->layer()->GetAnimator());
     if (will_appear) {
       animation_observer_->SetTarget(app_list_main_view_);
       main_settings.AddObserver(animation_observer_.get());
     }
@@ skipping 30 matching lines @@
     app_list_main_view_->SetVisible(true);
     // Refocus the search box. However, if the app list widget does not have
     // focus, it means another window has already taken focus, and we *must not*
     // focus the search box (or we would steal focus back into the app list).
     if (GetWidget()->IsActive())
       search_box_view_->search_box()->RequestFocus();
   }
 }
 
 }  // namespace app_list