mash: Avoid shelf crashes on display removal.

ash/mus/window_manager.cc

 // Copyright 2015 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/mus/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/bridge/wm_lookup_mus.h"
 #include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/window_manager_observer.h"
 #include "ash/public/interfaces/container.mojom.h"
+#include "services/shell/public/cpp/connector.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/mus_constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/app_list/presenter/app_list_presenter.h"
 #include "ui/base/hit_test.h"
+#include "ui/display/screen_base.h"
 #include "ui/events/mojo/event.mojom.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
-#include "ui/views/mus/screen_mus.h"
+#include "ui/views/mus/window_manager_frame_values.h"
 
-namespace ash {
-namespace mus {
+namespace mojo {
 
-void AssertTrue(bool success) {
-  DCHECK(success);
-}
+template <>
+struct TypeConverter<views::WindowManagerFrameValues,
+                     ui::mojom::FrameDecorationValuesPtr> {
+  static views::WindowManagerFrameValues Convert(
+      const ui::mojom::FrameDecorationValuesPtr& input) {
+    views::WindowManagerFrameValues result;
+    result.normal_insets = input->normal_client_area_insets;
+    result.maximized_insets = input->maximized_client_area_insets;
+    result.max_title_bar_button_width = input->max_title_bar_button_width;
+    return result;
+  }
+};
+
+}  // namespace mojo
+
+namespace {
 
 // TODO(jamescook): Port ash::sysui::AppListPresenterMus and eliminate this.
 class AppListPresenterStub : public app_list::AppListPresenter {
  public:
   AppListPresenterStub() {}
   ~AppListPresenterStub() override {}
 
   // app_list::AppListPresenter:
   void Show(int64_t display_id) override { NOTIMPLEMENTED(); }
   void Dismiss() override { NOTIMPLEMENTED(); }
   void ToggleAppList(int64_t display_id) override { NOTIMPLEMENTED(); }
   bool IsVisible() const override {
     NOTIMPLEMENTED();
     return false;
   }
   bool GetTargetVisibility() const override {
     NOTIMPLEMENTED();
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppListPresenterStub);
 };
 
+}  // namespace
+
+namespace ash {
+namespace mus {
+
 WindowManager::WindowManager(shell::Connector* connector)
-    : connector_(connector) {}
+    : connector_(connector), display_manager_observer_binding_(this) {}
 
 WindowManager::~WindowManager() {
   // NOTE: |window_tree_client_| may already be null.
   delete window_tree_client_;
 }
 
 void WindowManager::Init(ui::WindowTreeClient* window_tree_client) {
   DCHECK(!window_tree_client_);
   window_tree_client_ = window_tree_client;
 
@@ skipping 73 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 RootWindowController* WindowManager::CreateRootWindowController(
     ui::Window* window,
     const display::Display& display) {
-  // TODO(sky): there is timing issues with using ScreenMus.
+  // TODO(sky): There are timing issues with using ScreenBase.
   if (!screen_) {
-    std::unique_ptr<views::ScreenMus> screen(new views::ScreenMus(nullptr));
-    screen->Init(connector_);
-    screen_ = std::move(screen);
+    screen_.reset(new display::ScreenBase());
+
+    ui::mojom::DisplayManagerPtr display_manager;
+    connector_->ConnectToInterface("mojo:ui", &display_manager);

[sky, 2016/09/01 23:51:17]

The windowmanager shouldn't need to connect to displaymanager because it it is
already told what it needs via WindowManager/WindowTreeClient calls. For
example, when a new display is added OnWmNewDisplay() is called (when mash first
connects to mus, mus calls OnWmNewDisplay for all the existing displays).
Removal can be detected by the root being destroyed (as the code has now in
WindowManager::OnWindowDestroying). We may need to propagate metrics changes
separately, but you shouldn't need to worry about that now.

+    display_manager->AddObserver(
+        display_manager_observer_binding_.CreateInterfacePtrAndBind());
+
+    // We need the set of displays before we can continue. Wait for it.
+    //
+    // TODO(rockot): Do something better here. This should not have to block
+    // tasks from running on the calling thread. http://crbug.com/594852.
+    bool success =
+        display_manager_observer_binding_.WaitForIncomingMethodCall();
+
+    // The WaitForIncomingMethodCall() should have supplied the set of Displays,
+    // unless mus is going down, in which case encountered_error() is true, or
+    // the call to WaitForIncomingMethodCall() failed.
+    if (screen_->display_list()->displays().empty()) {
+      DCHECK(display_manager.encountered_error() || !success);
+      // In this case we install a default display and assume the process is
+      // going to exit shortly so that the real value doesn't matter.
+      screen_->display_list()->AddDisplay(
+          display::Display(0xFFFFFFFF, gfx::Rect(0, 0, 801, 802)),
+          display::DisplayList::Type::PRIMARY);
+    }
   }
 
   std::unique_ptr<RootWindowController> root_window_controller_ptr(
       new RootWindowController(this, window, display));
   RootWindowController* root_window_controller =
       root_window_controller_ptr.get();
   root_window_controllers_.insert(std::move(root_window_controller_ptr));
   window->AddObserver(this);
 
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
@@ skipping 65 matching lines @@
   // OnWmSetBounds() recommends doing. Remove that restriction, or fix this.
   WmWindowMus::Get(window)->SetBounds(*bounds);
   *bounds = window->bounds();
   return true;
 }
 
 bool WindowManager::OnWmSetProperty(
     ui::Window* window,
     const std::string& name,
     std::unique_ptr<std::vector<uint8_t>>* new_data) {
-  // TODO(sky): constrain this to set of keys we know about, and allowed
-  // values.
+  // TODO(sky): constrain this to set of keys we know about, and allowed values.
   return name == ui::mojom::WindowManager::kShowState_Property ||
          name == ui::mojom::WindowManager::kPreferredSize_Property ||
          name == ui::mojom::WindowManager::kResizeBehavior_Property ||
          name == ui::mojom::WindowManager::kWindowAppIcon_Property ||
          name == ui::mojom::WindowManager::kWindowTitle_Property;
 }
 
 ui::Window* WindowManager::OnWmCreateTopLevelWindow(
     std::map<std::string, std::vector<uint8_t>>* properties) {
   return NewTopLevelWindow(properties);
@@ skipping 40 matching lines @@
 
 ui::mojom::EventResult WindowManager::OnAccelerator(uint32_t id,
                                                     const ui::Event& event) {
   auto iter = accelerator_handlers_.find(GetAcceleratorNamespaceId(id));
   if (iter == accelerator_handlers_.end())
     return ui::mojom::EventResult::HANDLED;
 
   return iter->second->OnAccelerator(id, event);
 }
 
+void WindowManager::OnDisplays(
+    mojo::Array<ui::mojom::WsDisplayPtr> ws_displays) {
+  // This should only be called once from Init() before any observers have been
+  // added.
+  DCHECK(screen_->display_list()->displays().empty());
+  for (size_t i = 0; i < ws_displays.size(); ++i) {
+    const bool is_primary = ws_displays[i]->is_primary;
+    screen_->display_list()->AddDisplay(
+        ws_displays[i]->display, is_primary
+                                     ? display::DisplayList::Type::PRIMARY
+                                     : display::DisplayList::Type::NOT_PRIMARY);
+    if (is_primary) {
+      // TODO(sky): Make views::WindowManagerFrameValues per display.
+      views::WindowManagerFrameValues frame_values =
+          ws_displays[i]
+              ->frame_decoration_values.To<views::WindowManagerFrameValues>();
+      views::WindowManagerFrameValues::SetInstance(frame_values);
+    }
+  }
+  DCHECK(!screen_->display_list()->displays().empty());
+}
+
+void WindowManager::OnDisplaysChanged(
+    mojo::Array<ui::mojom::WsDisplayPtr> ws_displays) {
+  for (size_t i = 0; i < ws_displays.size(); ++i) {
+    const bool is_primary = ws_displays[i]->is_primary;
+    screen_->ProcessDisplayChanged(ws_displays[i]->display, is_primary);
+    if (is_primary) {
+      views::WindowManagerFrameValues frame_values =
+          ws_displays[i]
+              ->frame_decoration_values.To<views::WindowManagerFrameValues>();
+      views::WindowManagerFrameValues::SetInstance(frame_values);
+    }
+  }
+}
+
+void WindowManager::OnDisplayRemoved(int64_t id) {
+  // Shutdown the root window controller before removing the display.
+  for (auto& root_window_controller : root_window_controllers_) {
+    if (root_window_controller->display().id() == id) {
+      root_window_controller->Shutdown();
+      break;
+    }
+  }
+  screen_->display_list()->RemoveDisplay(id);
+}
+
 }  // namespace mus
 }  // namespace ash