WIP: simplified display management in ash

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>
 
@@ skipping 57 matching lines @@
   // An image representation of the contents of the current drag and drop
   // clipboard.
   std::unique_ptr<ash::DragImageView> view;
 
   // The cursor offset of the dragged item.
   gfx::Vector2d image_offset;
 };
 
 // TODO: need to register OSExchangeDataProviderMus. http://crbug.com/665077.
 WindowManager::WindowManager(service_manager::Connector* connector,
-                             Config config)
+                             Config config,
+                             bool show_primary_host_on_connect)
     : connector_(connector),
       config_(config),
+      show_primary_host_on_connect_(show_primary_host_on_connect),
       wm_state_(base::MakeUnique<::wm::WMState>()),
       property_converter_(base::MakeUnique<aura::PropertyConverter>()) {
+  LOG(WARNING) << "WindowManager!";
   property_converter_->RegisterProperty(
       kPanelAttachedKey, ui::mojom::WindowManager::kPanelAttached_Property,
       aura::PropertyConverter::CreateAcceptAnyValueCallback());
   property_converter_->RegisterProperty(
       kRenderTitleAreaProperty,
       ui::mojom::WindowManager::kRenderParentTitleArea_Property,
       aura::PropertyConverter::CreateAcceptAnyValueCallback());
   property_converter_->RegisterProperty(
       kShelfItemTypeKey, ui::mojom::WindowManager::kShelfItemType_Property,
       base::Bind(&IsValidShelfItemType));
@@ skipping 17 matching lines @@
     const scoped_refptr<base::SequencedWorkerPool>& blocking_pool,
     std::unique_ptr<ShellDelegate> shell_delegate) {
   blocking_pool_ = blocking_pool;
   DCHECK(window_manager_client_);
   DCHECK(!window_tree_client_);
   window_tree_client_ = std::move(window_tree_client);
 
   DCHECK_EQ(nullptr, ash::Shell::window_tree_client());
   ash::Shell::set_window_tree_client(window_tree_client_.get());
 
-  // |connector_| will be null in some tests.
-  if (connector_)
-    connector_->BindInterface(ui::mojom::kServiceName, &display_controller_);
+  LOG(WARNING) << "config is mash? " << (config_ == Config::MASH);
 
-  screen_ = base::MakeUnique<ScreenMus>(display_controller_.get());
-  display::Screen::SetScreenInstance(screen_.get());
+  // TODO(sky): remove and use MUS code.
+  if (config_ == Config::MASH) {
+    // |connector_| will be null in some tests.
+    if (connector_)
+      connector_->BindInterface(ui::mojom::kServiceName, &display_controller_);
+    screen_ = base::MakeUnique<ScreenMus>(display_controller_.get());
+    display::Screen::SetScreenInstance(screen_.get());
+  }
 
   pointer_watcher_event_router_ =
       base::MakeUnique<views::PointerWatcherEventRouter>(
           window_tree_client_.get());
 
   ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ui::mojom::FrameDecorationValues::New();
   const gfx::Insets client_area_insets =
       NonClientFrameController::GetPreferredClientAreaInsets();
   frame_decoration_values->normal_client_area_insets = client_area_insets;
@@ skipping 77 matching lines @@
   CreateAndRegisterRootWindowController(
       std::move(window_tree_host), screen_->GetAllDisplays()[0],
       RootWindowController::RootWindowType::PRIMARY);
 }
 
 void WindowManager::CreateShell(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   DCHECK(!created_shell_);
   created_shell_ = true;
   ShellInitParams init_params;
-  ShellPortMash* shell_port =
-      new ShellPortMash(WmWindow::Get(window_tree_host->window()), this,
-                        pointer_watcher_event_router_.get(),
-                        create_session_state_delegate_stub_for_test_);
+  ShellPortMash* shell_port = new ShellPortMash(
+      window_tree_host ? WmWindow::Get(window_tree_host->window()) : nullptr,
+      this, pointer_watcher_event_router_.get(),
+      create_session_state_delegate_stub_for_test_);
   // Shell::CreateInstance() takes ownership of ShellDelegate.
   init_params.delegate = shell_delegate_ ? shell_delegate_.release()
                                          : new ShellDelegateMus(connector_);
   init_params.primary_window_tree_host = window_tree_host.release();
   init_params.shell_port = shell_port;
   init_params.blocking_pool = blocking_pool_.get();
   Shell::CreateInstance(init_params);
 }
 
 void WindowManager::CreateAndRegisterRootWindowController(
@@ skipping 86 matching lines @@
 
 aura::PropertyConverter* WindowManager::GetPropertyConverter() {
   return property_converter_.get();
 }
 
 void WindowManager::SetWindowManagerClient(aura::WindowManagerClient* client) {
   window_manager_client_ = client;
   ash::Shell::set_window_manager_client(client);
 }
 
-void WindowManager::OnWmConnected() {}
+void WindowManager::OnWmConnected() {
+  if (config_ == Config::MUS) {
+    CreateShell(nullptr);
+    if (show_primary_host_on_connect_)
+      Shell::GetPrimaryRootWindow()->GetHost()->Show();
+  }
+}
 
 void WindowManager::OnWmSetBounds(aura::Window* window,
                                   const gfx::Rect& bounds) {
   // TODO(sky): this indirectly sets bounds, which is against what
   // OnWmSetBounds() recommends doing. Remove that restriction, or fix this.
   WmWindow::Get(window)->SetBounds(bounds);
 }
 
 bool WindowManager::OnWmSetProperty(
     aura::Window* window,
@@ skipping 141 matching lines @@
       DestroyRootWindowController(root_window_controller_ptr.get(),
                                   in_shutdown);
       break;
     }
   }
 }
 
 void WindowManager::OnWmDisplayModified(const display::Display& display) {
   // Ash relies on the Display being updated, then the WindowTreeHost's window,
   // and finally DisplayObservers.
+  // XXX make sure this isn't called for manually_created.
   display::DisplayList& display_list = screen_->display_list();
   std::unique_ptr<display::DisplayListObserverLock> display_lock =
       display_list.SuspendObserverUpdates();
   const bool is_primary = display_list.FindDisplayById(display.id()) ==
                           display_list.GetPrimaryDisplayIterator();
   uint32_t display_changed_values = display_list.UpdateDisplay(
       display, is_primary ? display::DisplayList::Type::PRIMARY
                           : display::DisplayList::Type::NOT_PRIMARY);
   RootWindowController* root_window_controller =
       ShellPortMash::Get()->GetRootWindowControllerWithDisplayId(display.id());
@@ skipping 57 matching lines @@
 bool WindowManager::IsWindowActive(aura::Window* window) {
   return Shell::Get()->activation_client()->GetActiveWindow() == window;
 }
 
 void WindowManager::OnWmDeactivateWindow(aura::Window* window) {
   Shell::Get()->activation_client()->DeactivateWindow(window);
 }
 
 }  // namespace mus
 }  // namespace ash