Gets chrome --mus some what working

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/drag_drop/drag_image_view.h"
 #include "ash/common/session/session_controller.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_window.h"
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/bridge/wm_shell_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/screen_mus.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/top_level_window_factory.h"
 #include "ash/mus/window_properties.h"
+#include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shell.h"
 #include "ash/shell_init_params.h"
 #include "ash/wm/ash_focus_rules.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 28 matching lines @@
 struct WindowManager::DragState {
   // 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)
+WindowManager::WindowManager(service_manager::Connector* connector,
+                             Config config)
     : connector_(connector),
+      config_(config),
       wm_state_(base::MakeUnique<::wm::WMState>()),
       property_converter_(base::MakeUnique<aura::PropertyConverter>()) {
   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));
   property_converter_->RegisterProperty(
       ::wm::kShadowElevationKey,
       ui::mojom::WindowManager::kShadowElevation_Property,
       base::Bind(&::wm::IsValidShadowElevation));
 }
 
 WindowManager::~WindowManager() {
   Shutdown();
   ash::Shell::set_window_tree_client(nullptr);
   ash::Shell::set_window_manager_client(nullptr);
 }
 
 void WindowManager::Init(
     std::unique_ptr<aura::WindowTreeClient> window_tree_client,
-    const scoped_refptr<base::SequencedWorkerPool>& blocking_pool) {
+    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_)
@@ skipping 16 matching lines @@
       NonClientFrameController::GetMaxTitleBarButtonWidth();
   window_manager_client_->SetFrameDecorationValues(
       std::move(frame_decoration_values));
 
   // Notify PointerWatcherEventRouter and CaptureSynchronizer that the capture
   // client has been set.
   aura::client::CaptureClient* capture_client = wm_state_->capture_controller();
   pointer_watcher_event_router_->AttachToCaptureClient(capture_client);
   window_tree_client_->capture_synchronizer()->AttachToCaptureClient(
       capture_client);
+
+  if (shell_delegate)
+    shell_delegate_ = std::move(shell_delegate);
+}
+
+bool WindowManager::WaitForInitialDisplays() {
+  return window_manager_client_->WaitForInitialDisplays();
 }
 
 void WindowManager::DeleteAllRootWindowControllers() {
   // Primary RootWindowController must be destroyed last.
   RootWindowController* primary_root_window_controller =
       GetPrimaryRootWindowController();
   std::set<RootWindowController*> secondary_root_window_controllers;
   for (auto& root_window_controller_ptr : root_window_controllers_) {
     if (root_window_controller_ptr.get() != primary_root_window_controller) {
       secondary_root_window_controllers.insert(
@@ skipping 53 matching lines @@
 void WindowManager::CreateShell(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   DCHECK(!created_shell_);
   created_shell_ = true;
   ShellInitParams init_params;
   WmShellMus* wm_shell = new WmShellMus(
       WmWindow::Get(window_tree_host->window()),
       this, pointer_watcher_event_router_.get(),
       create_session_state_delegate_stub_for_test_);
   // Shell::CreateInstance() takes ownership of ShellDelegate.
-  init_params.delegate = shell_delegate_for_test_
-                             ? shell_delegate_for_test_.release()
-                             : new ShellDelegateMus(connector_);
+  init_params.delegate = shell_delegate_ ? shell_delegate_.release()
+                                         : new ShellDelegateMus(connector_);
   init_params.primary_window_tree_host = window_tree_host.release();
   init_params.wm_shell = wm_shell;
   init_params.blocking_pool = blocking_pool_.get();
   Shell::CreateInstance(init_params);
 }
 
 void WindowManager::CreateAndRegisterRootWindowController(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host,
     const display::Display& display,
     RootWindowController::RootWindowType root_window_type) {
@@ skipping 306 matching lines @@
 bool WindowManager::IsWindowActive(aura::Window* window) {
   return Shell::GetInstance()->activation_client()->GetActiveWindow() == window;
 }
 
 void WindowManager::OnWmDeactivateWindow(aura::Window* window) {
   Shell::GetInstance()->activation_client()->DeactivateWindow(window);
 }
 
 }  // namespace mus
 }  // namespace ash