Makes WorkspaceLayoutManager use ash/wm/common types

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 <cstring>
 #include <string>
 #include <vector>
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
+#include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/common/window_state.h"
+#include "ash/wm/common/wm_root_window_controller.h"
+#include "ash/wm/common/wm_root_window_controller_observer.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/command_line.h"
@@ skipping 138 matching lines @@
     if (shelf_)
       shelf_->update_shelf_observer_ = NULL;
   }
 
   // Shelf we're in. NULL if deleted before we're deleted.
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
+// ShelfLayoutManager::RootWindowControllerObserverImpl ------------------------
+
+// NOTE: OnShelfAlignmentChanged() is implemented by way of

[sky, 2016/04/27 20:48:05]

This is subtle and a bit unfortunate. But I think this class will die long term,
or at least be refactored in such a way that this code can be nuked.

+// WmRootWindowControllerObserver to avoid ordering issues. The way
+// WmRootWindowControllerObserver is wired in means
+// WmRootWindowControllerObservers may be notified after ShellObservers.

[James Cook, 2016/04/27 23:24:24]

The part that I missed in thinking about this was that some other layout manager
had been converted to WmRootWindowControllerObserver, and the ordering problem
was with the ones that have moved there. Is the comment below any clearer?

NOTE: Some other layout managers also observe for OnShelfAlignmentChanged() via
WmRootWindowControllerObserver instead of via ShellObserver. There are implicit
assumptions that these layout managers run in order. In order to preserve the
ordering, OnShelfAlignmentChanged() is implemented here in terms of a
WmRootWindowControllerObserver instead of a ShellObserver. This gives us a sane
ordering (or at least ordering as we've always had it in ash).

[sky, 2016/04/27 23:33:28]

I copied what you have here.

+// By making this code use a WmRootWindowControllerObservers we get sane
+// ordering (or at least ordering as we've always had it in ash).
+class ShelfLayoutManager::RootWindowControllerObserverImpl
+    : public wm::WmRootWindowControllerObserver {
+ public:
+  explicit RootWindowControllerObserverImpl(
+      ShelfLayoutManager* shelf_layout_manager)
+      : shelf_layout_manager_(shelf_layout_manager) {}
+  ~RootWindowControllerObserverImpl() override {}
+
+  // WmRootWindowControllerObserver:
+  void OnShelfAlignmentChanged() override {
+    shelf_layout_manager_->LayoutShelf();
+  }
+
+ private:
+  ShelfLayoutManager* shelf_layout_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(RootWindowControllerObserverImpl);
+};
+
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
     : SnapToPixelLayoutManager(shelf->GetNativeView()->parent()),
       root_window_(shelf->GetNativeView()->GetRootWindow()),
       updating_bounds_(false),
       shelf_(shelf),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
       mouse_over_shelf_when_auto_hide_timer_started_(false),
       bezel_event_filter_(new ShelfBezelEventFilter(this)),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
       update_shelf_observer_(NULL),
       chromevox_panel_height_(0),
-      duration_override_in_ms_(0) {
+      duration_override_in_ms_(0),
+      root_window_controller_observer_(
+          new RootWindowControllerObserverImpl(this)) {
   Shell::GetInstance()->AddShellObserver(this);
+  wm::WmWindowAura::Get(root_window_)
+      ->GetRootWindowController()
+      ->AddObserver(root_window_controller_observer_.get());
   Shell::GetInstance()->lock_state_controller()->AddObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
   Shell::GetInstance()->session_state_delegate()->AddSessionStateObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_, WillDeleteShelf());
   Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetInstance()->lock_state_controller()->RemoveObserver(this);
   Shell::GetInstance()->
       session_state_delegate()->RemoveSessionStateObserver(this);
+  wm::WmWindowAura::Get(root_window_)
+      ->GetRootWindowController()
+      ->RemoveObserver(root_window_controller_observer_.get());
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   // Clear all event filters, otherwise sometimes those filters may catch
   // synthesized mouse event and cause crashes during the shutdown.
   set_workspace_controller(NULL);
   auto_hide_event_filter_.reset();
   bezel_event_filter_.reset();
   // Stop observing window change, otherwise we can attempt to update a
   // partially destructed shelf.
@@ skipping 242 matching lines @@
   }
 }
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   // Force the shelf to layout for alignment (bottom if locked, restore
   // the previous alignment otherwise).
   state_.is_screen_locked = locked;
   UpdateShelfVisibilityAfterLoginUIChange();
 }
 
-void ShelfLayoutManager::OnShelfAlignmentChanged(aura::Window* root_window) {
-  LayoutShelf();
-}
-
 void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(
     aura::Window* root_window) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   UpdateAutoHideStateNow();
@@ skipping 607 matching lines @@
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 }  // namespace ash