Moves FrameDecorations from Display to WindowManagerState

components/mus/ws/connection_manager.cc

 // Copyright 2014 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 "components/mus/ws/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/connection_manager_delegate.h"
 #include "components/mus/ws/display.h"
@@ skipping 14 matching lines @@
 
 namespace mus {
 namespace ws {
 
 ConnectionManager::ConnectionManager(
     ConnectionManagerDelegate* delegate,
     const scoped_refptr<mus::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_connection_id_(1),
-      display_manager_(new ws::DisplayManager(this)),
+      display_manager_(new DisplayManager(this)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
-      got_valid_frame_decorations_(false),
       window_manager_factory_registry_(this, &user_id_tracker_) {}
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
   // Destroys the window trees results in querying for the display. Tear down
   // the displays first so that the trees are notified of the display going
   // away while the display is still valid.
   display_manager_->DestroyAllDisplays();
 
@@ skipping 14 matching lines @@
 ConnectionSpecificId ConnectionManager::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
   return id;
 }
 
 WindowTree* ConnectionManager::EmbedAtWindow(
     ServerWindow* root,
     uint32_t policy_bitmask,
     mojom::WindowTreeClientPtr client) {
-  scoped_ptr<WindowTree> tree_ptr(
-      new ws::WindowTree(this, root, policy_bitmask));
+  scoped_ptr<WindowTree> tree_ptr(new WindowTree(this, root, policy_bitmask));
   WindowTree* tree = tree_ptr.get();
 
   mojom::WindowTreePtr window_tree_ptr;
   scoped_ptr<WindowTreeBinding> binding =
       delegate_->CreateWindowTreeBindingForEmbedAtWindow(
           this, tree, GetProxy(&window_tree_ptr), std::move(client));
 
   AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
   OnTreeMessagedClient(tree->id());
   return tree;
 }
 
 WindowTree* ConnectionManager::AddTree(scoped_ptr<WindowTree> tree_impl_ptr,
                                        scoped_ptr<WindowTreeBinding> binding,
                                        mojom::WindowTreePtr tree_ptr) {
   CHECK_EQ(0u, tree_map_.count(tree_impl_ptr->id()));
   WindowTree* tree = tree_impl_ptr.get();
   tree_map_[tree->id()] = std::move(tree_impl_ptr);
   tree->Init(std::move(binding), std::move(tree_ptr));
   return tree;
 }
 
 WindowTree* ConnectionManager::CreateTreeForWindowManager(
     Display* display,
     mojom::WindowManagerFactory* factory,
     ServerWindow* root) {
-  mojom::DisplayPtr display_ptr = DisplayToMojomDisplay(display);
+  mojom::DisplayPtr display_ptr = display->ToMojomDisplay();
   mojom::WindowTreeClientPtr tree_client;
   factory->CreateWindowManager(std::move(display_ptr), GetProxy(&tree_client));
-  scoped_ptr<ws::WindowTree> tree_ptr(new ws::WindowTree(
-      this, root, mojom::WindowTree::kAccessPolicyEmbedRoot));
-  ws::WindowTree* tree = tree_ptr.get();
-  scoped_ptr<ws::DefaultWindowTreeBinding> binding(
-      new ws::DefaultWindowTreeBinding(tree_ptr.get(), this,
-                                       std::move(tree_client)));
+  scoped_ptr<WindowTree> tree_ptr(
+      new WindowTree(this, root, mojom::WindowTree::kAccessPolicyEmbedRoot));
+  WindowTree* tree = tree_ptr.get();
+  scoped_ptr<DefaultWindowTreeBinding> binding(new DefaultWindowTreeBinding(
+      tree_ptr.get(), this, std::move(tree_client)));
   mojom::WindowTreePtr window_tree_ptr = binding->CreateInterfacePtrAndBind();
   AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
   tree->ConfigureWindowManager();
   return tree;
 }
 
 void ConnectionManager::DestroyTree(WindowTree* tree) {
   scoped_ptr<WindowTree> tree_ptr;
   {
     auto iter = tree_map_.find(tree->id());
@@ skipping 86 matching lines @@
     const ServerWindow* window) const {
   if (!window)
     return nullptr;
   for (auto& pair : tree_map_) {
     if (pair.second->HasRoot(window))
       return pair.second.get();
   }
   return nullptr;
 }
 
-void ConnectionManager::AddDisplayManagerBinding(
-    mojo::InterfaceRequest<mojom::DisplayManager> request) {
-  display_manager_bindings_.AddBinding(this, std::move(request));
-}
-
 void ConnectionManager::OnFirstWindowManagerFactorySet() {
   if (display_manager_->has_active_or_pending_displays())
     return;
 
   // We've been supplied a WindowManagerFactory and no displays have been
   // created yet. Treat this as a signal to create a Display.
   // TODO(sky): we need a better way to determine this, most likely a switch.
   delegate_->CreateDefaultDisplays();
 }
 
@@ skipping 39 matching lines @@
       !window || window->id().connection_id != wm_tree->id() ||
       !window->children().empty() || GetTreeWithRoot(window)) {
     WindowManagerSentBogusMessage();
     return;
   }
 
   tree->OnWindowManagerCreatedTopLevelWindow(window_manager_change_id,
                                              change.client_change_id, window);
 }
 
-mojom::DisplayPtr ConnectionManager::DisplayToMojomDisplay(Display* display) {
-  size_t i = 0;
-  int next_x = 0;
-  for (Display* display2 : display_manager_->displays()) {
-    const ServerWindow* root = display->root_window();
-    if (display == display2) {
-      mojom::DisplayPtr display_ptr = mojom::Display::New();
-      display_ptr = mojom::Display::New();
-      display_ptr->id = display->id();
-      display_ptr->bounds = mojo::Rect::New();
-      display_ptr->bounds->x = next_x;
-      display_ptr->bounds->y = 0;
-      display_ptr->bounds->width = root->bounds().size().width();
-      display_ptr->bounds->height = root->bounds().size().height();
-      // TODO(sky): window manager needs an API to set the work area.
-      display_ptr->work_area = display_ptr->bounds.Clone();
-      display_ptr->device_pixel_ratio =
-          display->GetViewportMetrics().device_pixel_ratio;
-      display_ptr->rotation = display->GetRotation();
-      // TODO(sky): make this real.
-      display_ptr->is_primary = i == 0;
-      // TODO(sky): make this real.
-      display_ptr->touch_support = mojom::TouchSupport::UNKNOWN;
-      display_ptr->frame_decoration_values =
-          display->frame_decoration_values().Clone();
-      return display_ptr;
-    }
-    next_x += root->bounds().size().width();
-    ++i;
-  }
-  NOTREACHED();
-  return mojom::Display::New();
-}
-
 void ConnectionManager::ProcessWindowBoundsChanged(
     const ServerWindow* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessWindowBoundsChanged(window, old_bounds, new_bounds,
                                             IsOperationSource(pair.first));
   }
 }
 
@@ skipping 70 matching lines @@
 }
 
 void ConnectionManager::ProcessViewportMetricsChanged(
     Display* display,
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessViewportMetricsChanged(
         display, old_metrics, new_metrics, IsOperationSource(pair.first));
   }
-
-  if (!got_valid_frame_decorations_)
-    return;
-}
-
-void ConnectionManager::ProcessFrameDecorationValuesChanged(Display* display) {
-  if (!got_valid_frame_decorations_) {
-    got_valid_frame_decorations_ = true;
-    display_manager_observers_.ForAllPtrs([this](
-        mojom::DisplayManagerObserver* observer) { CallOnDisplays(observer); });
-    return;
-  }
-
-  display_manager_observers_.ForAllPtrs(
-      [this, &display](mojom::DisplayManagerObserver* observer) {
-        CallOnDisplayChanged(observer, display);
-      });
 }
 
 bool ConnectionManager::GetAndClearInFlightWindowManagerChange(
     uint32_t window_manager_change_id,
     InFlightWindowManagerChange* change) {
   // There are valid reasons as to why we wouldn't know about the id. The
   // most likely is the client disconnected before the response from the window
   // manager came back.
   auto iter = in_flight_wm_change_map_.find(window_manager_change_id);
   if (iter == in_flight_wm_change_map_.end())
@@ skipping 16 matching lines @@
   current_operation_ = nullptr;
 }
 
 void ConnectionManager::MaybeUpdateNativeCursor(ServerWindow* window) {
   // This can be null in unit tests.
   Display* display = display_manager_->GetDisplayContaining(window);
   if (display)
     display->MaybeChangeCursorOnWindowTreeChange();
 }
 
-void ConnectionManager::CallOnDisplays(
-    mojom::DisplayManagerObserver* observer) {
-  std::set<Display*> displays = display_manager_->displays();
-  mojo::Array<mojom::DisplayPtr> display_ptrs(displays.size());
-  {
-    size_t i = 0;
-    // TODO(sky): need ordering!
-    for (Display* display : displays) {
-      display_ptrs[i] = DisplayToMojomDisplay(display);
-      ++i;
-    }
-  }
-  observer->OnDisplays(std::move(display_ptrs));
-}
-
-void ConnectionManager::CallOnDisplayChanged(
-    mojom::DisplayManagerObserver* observer,
-    Display* display) {
-  mojo::Array<mojom::DisplayPtr> displays(1);
-  displays[0] = DisplayToMojomDisplay(display);
-  display_manager_observers_.ForAllPtrs(
-      [&displays](mojom::DisplayManagerObserver* observer) {
-        observer->OnDisplaysChanged(displays.Clone());
-      });
-}
-
 mus::SurfacesState* ConnectionManager::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
 void ConnectionManager::OnScheduleWindowPaint(ServerWindow* window) {
   if (!in_destructor_)
     SchedulePaint(window, gfx::Rect(window->bounds().size()));
 }
 
 const ServerWindow* ConnectionManager::GetRootWindow(
@@ skipping 156 matching lines @@
     ServerWindow* transient_child) {
   // If we're deleting a window, then this is a superfluous message.
   if (current_operation_type() == OperationType::DELETE_WINDOW)
     return;
   for (auto& pair : tree_map_) {
     pair.second->ProcessTransientWindowRemoved(window, transient_child,
                                                IsOperationSource(pair.first));
   }
 }
 
-void ConnectionManager::AddObserver(mojom::DisplayManagerObserverPtr observer) {
-  // TODO(sky): this needs to be per user.
-
-  // Many clients key off the frame decorations to size widgets. Wait for frame
-  // decorations before notifying so that we don't have to worry about clients
-  // resizing appropriately.
-  if (!got_valid_frame_decorations_) {
-    display_manager_observers_.AddInterfacePtr(std::move(observer));
-    return;
-  }
-  CallOnDisplays(observer.get());
-  display_manager_observers_.AddInterfacePtr(std::move(observer));
-}
-
 void ConnectionManager::OnWillDestroyDisplay(Display* display) {
   for (auto& pair : tree_map_)
     pair.second->OnWillDestroyDisplay(display);
 }
 
 void ConnectionManager::OnFirstDisplayReady() {
   delegate_->OnFirstDisplayReady();
 }
 
 void ConnectionManager::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 }  // namespace ws
 }  // namespace mus