ShelfLayoutManager virtual keyboard - do not change work area of screen if in non-sticky mode.

ash/shelf/shelf_layout_manager.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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
+#include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_root_window_controller_observer.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shell.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
+#include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
+#include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/border.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
@@ skipping 206 matching lines @@
 
 gfx::Size ShelfLayoutManager::GetPreferredSize() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   return target_bounds.shelf_bounds_in_root.size();
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, false, NULL);
+  UpdateBoundsAndOpacity(target_bounds, false, true, NULL);
 
   // Update insets in ShelfWindowTargeter when shelf bounds change.
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state()));
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
   switch (shelf_widget_->shelf()->auto_hide_behavior()) {
     case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
       return SHELF_AUTO_HIDE;
@@ skipping 262 matching lines @@
 void ShelfLayoutManager::OnWindowActivated(WmWindow* gained_active,
                                            WmWindow* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 void ShelfLayoutManager::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {
   bool keyboard_is_about_to_hide = false;
   if (new_bounds.IsEmpty() && !keyboard_bounds_.IsEmpty())
     keyboard_is_about_to_hide = true;
 
+  // If new window behavior flag enabled and in non-sticky mode, do not change
+  // the work area.
+  bool change_work_area =
+      (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+           switches::kAshUseNewVKWindowBehavior) ||
+       keyboard::KeyboardController::GetInstance()->get_lock_keyboard());
+
   keyboard_bounds_ = new_bounds;
-  OnWindowResized();
+  TargetBounds target_bounds;
+  CalculateTargetBounds(state_, &target_bounds);
+  UpdateBoundsAndOpacity(target_bounds, false, change_work_area, NULL);
+
+  FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
+                    WillChangeVisibilityState(visibility_state()));

[oshima, 2016/08/02 16:33:53]

Instead of coyping, can you add change_work_area parameter to LayoutShelf, and
call it from here?

[hariank, 2016/08/03 18:09:39]

Done.

 
   // On login screen if keyboard has been just hidden, update bounds just once
   // but ignore target_bounds.work_area_insets since shelf overlaps with login
   // window.
   if (WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked() &&
       keyboard_is_about_to_hide) {
     Shell::GetInstance()->SetDisplayWorkAreaInsets(root_window_, gfx::Insets());
   }
 }
 
@@ skipping 88 matching lines @@
   } else {
     UpdateShelfBackground(change_type);
   }
 
   shelf_widget_->SetDimsShelf(state.visibility_state == SHELF_VISIBLE &&
                               state.window_state ==
                                   wm::WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, true, delay_background_change
-                                                  ? update_shelf_observer_
-                                                  : NULL);
+  UpdateBoundsAndOpacity(target_bounds, true, true, delay_background_change
+                                                        ? update_shelf_observer_
+                                                        : NULL);
 
   // The delegate must be notified after |state_| is updated so that it can
   // query the new target bounds.
   ShelfDelegate* shelf_delegate = WmShell::Get()->shelf_delegate();
   DCHECK(shelf_delegate);
   if (old_state.visibility_state != state_.visibility_state)
     shelf_delegate->OnShelfVisibilityStateChanged(shelf_widget_->shelf());
 
   // OnAutoHideStateChanged Should be emitted when:
   //  - firstly state changed to auto-hide from other state
   //  - or, auto_hide_state has changed
   if ((old_state.visibility_state != state_.visibility_state &&
        state_.visibility_state == SHELF_AUTO_HIDE) ||
       old_state.auto_hide_state != state_.auto_hide_state) {
     shelf_delegate->OnShelfAutoHideStateChanged(shelf_widget_->shelf());
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                       OnAutoHideStateChanged(state_.auto_hide_state));
   }
 }
 
 void ShelfLayoutManager::UpdateBoundsAndOpacity(
     const TargetBounds& target_bounds,
     bool animate,
+    bool change_work_area,
     ui::ImplicitAnimationObserver* observer) {
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
   {
     ui::ScopedLayerAnimationSettings shelf_animation_setter(
         GetLayer(shelf_widget_)->GetAnimator());
     ui::ScopedLayerAnimationSettings status_animation_setter(
         GetLayer(shelf_widget_->status_area_widget())->GetAnimator());
     if (animate) {
       int duration = duration_override_in_ms_ ? duration_override_in_ms_
                                               : kCrossFadeDurationMS;
@@ skipping 41 matching lines @@
     // mash::wm::ShelfLayout manages window bounds when running mash.
     if (!Shell::GetInstance()->in_mus()) {
       shelf_widget_->status_area_widget()->SetBounds(
           ScreenUtil::ConvertRectToScreen(
               shelf_widget_->status_area_widget()->GetNativeView()->parent(),
               status_bounds));
     }
     // For crbug.com/622431, when the shelf alignment is BOTTOM_LOCKED, we
     // don't set display work area, as it is not real user-set alignment.
     if (!state_.is_screen_locked &&
-        shelf_widget_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM_LOCKED) {
+        shelf_widget_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM_LOCKED &&
+        change_work_area) {
       gfx::Insets insets;
       // If user session is blocked (login to new user session or add user to
       // the existing session - multi-profile) then give 100% of work area only
       // if keyboard is not shown.

[oshima, 2016/08/02 16:33:53]

can you test if this works in lock screen?

[hariank, 2016/08/03 18:09:39]

Done.

       if (!state_.is_adding_user_screen || !keyboard_bounds_.IsEmpty())
         insets = target_bounds.work_area_insets;
       Shell::GetInstance()->SetDisplayWorkAreaInsets(root_window_, insets);
     }
   }
 
   // Set an empty border to avoid the shelf view and status area overlapping.
   // TODO(msw): Avoid setting bounds of views within the shelf widget here.
   gfx::Rect shelf_bounds = gfx::Rect(target_bounds.shelf_bounds_in_root.size());
   shelf_widget_->GetContentsView()->SetBorder(views::Border::CreateEmptyBorder(
@@ skipping 393 matching lines @@
   // Check transition changes to/from the add user to session and change the
   // shelf alignment accordingly
   bool add_user = state == SessionStateDelegate::SESSION_STATE_LOGIN_SECONDARY;
   if (add_user != state_.is_adding_user_screen) {
     state_.is_adding_user_screen = add_user;
     UpdateShelfVisibilityAfterLoginUIChange();
     return;
   }
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, true, NULL);
+  UpdateBoundsAndOpacity(target_bounds, true, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 float ShelfLayoutManager::ComputeTargetOpacity(const State& state) {
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
       state.visibility_state == SHELF_VISIBLE) {
     return 1.0f;
   }
   // In Chrome OS Material Design, when shelf is hidden during auto hide state,
   // target bounds are also hidden. So the window can extend to the edge of
   // screen.
   if (ash::MaterialDesignController::IsShelfMaterial()) {
     return (state.visibility_state == SHELF_AUTO_HIDE &&
             state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)
                ? 1.0f
                : 0.0f;
   }
   return (state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
 }
 
 }  // namespace ash