ash: Start/stop observing KeyboardController via ShellObserver

ash/common/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/common/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
 #include "ash/animation/animation_change_type.h"
+#include "ash/common/keyboard/keyboard_observer_register.h"
 #include "ash/common/session/session_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_layout_manager_observer.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.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"
@@ skipping 64 matching lines @@
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
-  void Detach() { shelf_ = NULL; }
+  void Detach() { shelf_ = nullptr; }
 
   void OnImplicitAnimationsCompleted() override {
     if (shelf_)
       shelf_->MaybeUpdateShelfBackground(AnimationChangeType::ANIMATE);
     delete this;
   }
 
  private:
   ~UpdateShelfObserver() override {
     if (shelf_)
-      shelf_->update_shelf_observer_ = NULL;
+      shelf_->update_shelf_observer_ = nullptr;
   }
 
-  // Shelf we're in. NULL if deleted before we're deleted.
+  // Shelf we're in. nullptr if deleted before we're deleted.
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
 ShelfLayoutManager::State::State()
     : visibility_state(SHELF_VISIBLE),
       auto_hide_state(SHELF_AUTO_HIDE_HIDDEN),
       window_state(wm::WORKSPACE_WINDOW_STATE_DEFAULT),
       pre_lock_screen_animation_active(false),
@@ skipping 22 matching lines @@
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf_widget,
                                        WmShelf* wm_shelf)
     : updating_bounds_(false),
       shelf_widget_(shelf_widget),
       wm_shelf_(wm_shelf),
       window_overlaps_shelf_(false),
       mouse_over_shelf_when_auto_hide_timer_started_(false),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
-      update_shelf_observer_(NULL),
+      update_shelf_observer_(nullptr),
       chromevox_panel_height_(0),
       duration_override_in_ms_(0),
-      shelf_background_type_(SHELF_BACKGROUND_OVERLAP) {
+      shelf_background_type_(SHELF_BACKGROUND_OVERLAP),
+      keyboard_observer_(this) {
   DCHECK(shelf_widget_);
   DCHECK(wm_shelf_);
   Shell::GetInstance()->AddShellObserver(this);
   WmShell::Get()->AddLockStateObserver(this);
   Shell::GetInstance()->activation_client()->AddObserver(this);
   WmShell::Get()->session_controller()->AddSessionStateObserver(this);
   state_.session_state =
       WmShell::Get()->session_controller()->GetSessionState();
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   for (auto& observer : observers_)
     observer.WillDeleteShelfLayoutManager();
   Shell::GetInstance()->RemoveShellObserver(this);
   WmShell::Get()->RemoveLockStateObserver(this);
   WmShell::Get()->session_controller()->RemoveSessionStateObserver(this);
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   in_shutdown_ = true;
   // Stop observing changes to avoid updating a partially destructed shelf.
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
 }
 
 bool ShelfLayoutManager::IsVisible() const {
-  // status_area_widget() may be NULL during the shutdown.
+  // status_area_widget() may be nullptr during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
           (state_.visibility_state == SHELF_AUTO_HIDE &&
            state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   const int shelf_size = GetShelfConstant(SHELF_SIZE);
   WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   gfx::Rect rect(wm::GetDisplayBoundsInParent(shelf_window));
   return SelectValueForShelfAlignment(
       gfx::Rect(rect.x(), rect.bottom() - shelf_size, rect.width(), shelf_size),
       gfx::Rect(rect.x(), rect.y(), shelf_size, rect.height()),
       gfx::Rect(rect.right() - shelf_size, rect.y(), shelf_size,
                 rect.height()));
 }
 
 gfx::Size ShelfLayoutManager::GetPreferredSize() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   return target_bounds.shelf_bounds_in_root.size();
 }
 
 void ShelfLayoutManager::LayoutShelfAndUpdateBounds(bool change_work_area) {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, false, change_work_area, NULL);
+  UpdateBoundsAndOpacity(target_bounds, false, change_work_area, nullptr);
 
   // Update insets in ShelfWindowTargeter when shelf bounds change.
   for (auto& observer : observers_)
     observer.WillChangeVisibilityState(visibility_state());
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   LayoutShelfAndUpdateBounds(true);
 }
 
@@ skipping 174 matching lines @@
 void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnPinnedStateChanged(WmWindow* pinned_window) {
   // Shelf needs to be hidden on entering to pinned mode, or restored
   // on exiting from pinned mode.
   UpdateVisibilityState();
 }
 
+void ShelfLayoutManager::OnVirtualKeyboardStateChanged(bool activated,
+                                                       WmWindow* root_window) {
+  UpdateKeyboardObserverFromStateChanged(
+      activated, root_window,
+      WmWindow::Get(shelf_widget_->GetNativeWindow())->GetRootWindow(),
+      &keyboard_observer_);
+}
+
 void ShelfLayoutManager::OnWindowActivated(ActivationReason reason,
                                            aura::Window* gained_active,
                                            aura::Window* 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;
@@ skipping 10 matching lines @@
   // 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) {
     WmWindow* window = WmWindow::Get(shelf_widget_->GetNativeWindow());
     WmShell::Get()->SetDisplayWorkAreaInsets(window, gfx::Insets());
   }
 }
 
-void ShelfLayoutManager::OnKeyboardClosed() {}
+void ShelfLayoutManager::OnKeyboardClosed() {
+  keyboard_observer_.RemoveAll();
+}
 
 ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
   if (state_.pre_lock_screen_animation_active)
     return SHELF_BACKGROUND_DEFAULT;
 
   // Handle all non active screen states, including OOBE and pre-login.
   if (state_.session_state != session_manager::SessionState::ACTIVE)
     return SHELF_BACKGROUND_OVERLAP;
 
   if (state_.visibility_state != SHELF_AUTO_HIDE &&
@@ skipping 81 matching lines @@
     // |update_shelf_observer_| deletes itself when the animation is done.
     update_shelf_observer_ = new UpdateShelfObserver(this);
   } else {
     MaybeUpdateShelfBackground(change_type);
   }
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(
       target_bounds, true /* animate */, true /* change_work_area */,
-      delay_background_change ? update_shelf_observer_ : NULL);
+      delay_background_change ? update_shelf_observer_ : nullptr);
 
   // 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) {
     for (auto& observer : observers_)
       observer.OnAutoHideStateChanged(state_.auto_hide_state);
   }
@@ skipping 461 matching lines @@
   }
 
   // Force the shelf to layout for alignment (bottom if locked, restore the
   // previous alignment otherwise).
   if (was_locked != state_.IsScreenLocked())
     UpdateShelfVisibilityAfterLoginUIChange();
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true /* animate */,
-                         true /* change_work_area */, NULL);
+                         true /* change_work_area */, nullptr);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 float ShelfLayoutManager::ComputeTargetOpacity(const State& state) {
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
@@ skipping 104 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash