ash: Start/stop observing KeyboardController via ShellObserver

ash/common/wm/panels/panel_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/wm/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 83 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CalloutWidgetBackground);
 };
 
 struct VisiblePanelPositionInfo {
   VisiblePanelPositionInfo()
       : min_major(0),
         max_major(0),
         major_pos(0),
         major_length(0),
-        window(NULL),
+        window(nullptr),
         slide_in(false) {}
 
   int min_major;
   int max_major;
   int major_pos;
   int major_length;
   WmWindow* window;
   bool slide_in;
 };
 
@@ skipping 123 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager public implementation:
 PanelLayoutManager::PanelLayoutManager(WmWindow* panel_container)
     : panel_container_(panel_container),
       root_window_controller_(panel_container->GetRootWindowController()),
       in_add_window_(false),
       in_layout_(false),
       show_callout_widgets_(true),
-      dragged_panel_(NULL),
+      dragged_panel_(nullptr),
       shelf_(nullptr),
-      last_active_panel_(NULL),
+      last_active_panel_(nullptr),
+      keyboard_observer_(this),
       weak_factory_(this) {
   DCHECK(panel_container);
   WmShell* shell = panel_container->GetShell();
   Shell::GetInstance()->activation_client()->AddObserver(this);
   shell->AddDisplayObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 PanelLayoutManager::~PanelLayoutManager() {
   Shutdown();
@@ skipping 26 matching lines @@
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 void PanelLayoutManager::StartDragging(WmWindow* panel) {
   DCHECK(!dragged_panel_);
   dragged_panel_ = panel;
   Relayout();
 }
 
 void PanelLayoutManager::FinishDragging() {
-  dragged_panel_ = NULL;
+  dragged_panel_ = nullptr;
   Relayout();
 }
 
 void PanelLayoutManager::SetShelf(WmShelf* shelf) {
   DCHECK(!shelf_);
   shelf_ = shelf;
   shelf_->AddObserver(this);
   WillChangeVisibilityState(shelf_->GetVisibilityState());
 }
 
@@ skipping 70 matching lines @@
   if (found != panel_windows_.end()) {
     delete found->callout_widget;
     panel_windows_.erase(found);
   }
   if (restore_windows_on_shelf_visible_)
     restore_windows_on_shelf_visible_->Remove(child->aura_window());
   child->aura_window()->RemoveObserver(this);
   child->GetWindowState()->RemoveObserver(this);
 
   if (dragged_panel_ == child)
-    dragged_panel_ = NULL;
+    dragged_panel_ = nullptr;
 
   if (last_active_panel_ == child)
-    last_active_panel_ = NULL;
+    last_active_panel_ = nullptr;
 
   Relayout();
 }
 
 void PanelLayoutManager::OnChildWindowVisibilityChanged(WmWindow* child,
                                                         bool visible) {
   if (visible)
     child->GetWindowState()->Restore();
   Relayout();
 }
@@ skipping 148 matching lines @@
   restore_windows_on_shelf_visible_ = std::move(minimized_windows);
 }
 
 void PanelLayoutManager::OnShelfIconPositionsChanged() {
   // TODO: As this is called for every animation step now. Relayout needs to be
   // updated to use current icon position instead of use the ideal bounds so
   // that the panels slide with their icons instead of jumping.
   Relayout();
 }
 
+void PanelLayoutManager::StartObservingKeyboard(
+    keyboard::KeyboardController* keyboard_controller) {
+  DCHECK(!keyboard_observer_.IsObservingSources());
+  keyboard_observer_.Add(keyboard_controller);
+}
+
+void PanelLayoutManager::StopObservingKeyboard(
+    keyboard::KeyboardController* keyboard_controller) {
+  if (keyboard_observer_.IsObserving(keyboard_controller))
+    keyboard_observer_.Remove(keyboard_controller);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager private implementation:
 
 void PanelLayoutManager::MinimizePanel(WmWindow* panel) {
   // Clusterfuzz can trigger panel accelerators before the shelf is created.
   // TODO(jamescook): Revert this after http://crbug.com/648964 is fixed.
   if (!shelf_)
     return;
 
   panel->SetVisibilityAnimationType(
@@ skipping 215 matching lines @@
   }
 
   WmWindow* previous_panel = nullptr;
   for (std::map<int, WmWindow*>::const_iterator it = window_ordering.begin();
        it != window_ordering.end() && it->second != active_panel; ++it) {
     if (previous_panel)
       panel_container_->StackChildAbove(it->second, previous_panel);
     previous_panel = it->second;
   }
 
-  previous_panel = NULL;
+  previous_panel = nullptr;
   for (std::map<int, WmWindow*>::const_reverse_iterator it =
            window_ordering.rbegin();
        it != window_ordering.rend() && it->second != active_panel; ++it) {
     if (previous_panel)
       panel_container_->StackChildAbove(it->second, previous_panel);
     previous_panel = it->second;
   }
 
   panel_container_->StackChildAtTop(active_panel);
   if (dragged_panel_ && dragged_panel_->GetParent() == panel_container_)
@@ skipping 117 matching lines @@
     } else if (panel_state->HasRestoreBounds()) {
       // Keyboard hidden, restore original bounds if they exist.
       panel->SetBoundsDirect(panel_state->GetRestoreBoundsInScreen());
     }
   }
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
-void PanelLayoutManager::OnKeyboardClosed() {}
+void PanelLayoutManager::OnKeyboardClosed() {
+  keyboard_observer_.RemoveAll();
+}
 
 }  // namespace ash