Moves FrameDecorations from Display to WindowManagerState

components/mus/ws/display.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 "components/mus/ws/display.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/connection_manager.h"
@@ skipping 36 matching lines @@
 }
 
 scoped_ptr<ui::Event> CoalesceEvents(scoped_ptr<ui::Event> first,
                                      scoped_ptr<ui::Event> second) {
   DCHECK(first->type() == ui::ET_POINTER_MOVED)
       << " Non-move events cannot be merged yet.";
   // For mouse moves, the new event just replaces the old event.
   return second;
 }
 
-uint32_t next_id = 1;
-
 }  // namespace
 
 class Display::ProcessedEventTarget {
  public:
   ProcessedEventTarget(ServerWindow* window, bool in_nonclient_area)
       : in_nonclient_area_(in_nonclient_area) {
     tracker_.Add(window);
   }
 
   ~ProcessedEventTarget() {}
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ProcessedEventTarget);
 };
 
 Display::QueuedEvent::QueuedEvent() {}
 Display::QueuedEvent::~QueuedEvent() {}
 
 Display::Display(ConnectionManager* connection_manager,
                  mojo::Connector* connector,
                  const scoped_refptr<GpuState>& gpu_state,
                  const scoped_refptr<SurfacesState>& surfaces_state)
-    : id_(next_id++),
+    : id_(connection_manager->display_manager()->GetAndAdvanceNextDisplayId()),
       connection_manager_(connection_manager),
       event_dispatcher_(this),
       platform_display_(
           PlatformDisplay::Create(connector, gpu_state, surfaces_state)),
       tree_awaiting_input_ack_(nullptr),
       last_cursor_(0) {
-  frame_decoration_values_ = mojom::FrameDecorationValues::New();
-  frame_decoration_values_->normal_client_area_insets = mojo::Insets::New();
-  frame_decoration_values_->maximized_client_area_insets = mojo::Insets::New();
-  frame_decoration_values_->max_title_bar_button_width = 0u;
-
   platform_display_->Init(this);
 
   connection_manager_->window_manager_factory_registry()->AddObserver(this);
 }
 
 Display::~Display() {
   connection_manager_->window_manager_factory_registry()->RemoveObserver(this);
 
   DestroyFocusController();
   for (ServerWindow* window : windows_needing_frame_destruction_)
     window->RemoveObserver(this);
 
   // Destroy any trees, which triggers destroying the WindowManagerState. Copy
   // off the WindowManagerStates as destruction mutates
   // |window_manager_state_map_|.
   std::set<WindowManagerState*> states;
   for (auto& pair : window_manager_state_map_)
     states.insert(pair.second.get());
   for (WindowManagerState* state : states)
     connection_manager_->DestroyTree(state->tree());
 }
 
 void Display::Init(scoped_ptr<DisplayBinding> binding) {
   init_called_ = true;
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
   InitWindowManagersIfNecessary();
 }
 
-void Display::SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values) {
-  // TODO(sky): this needs to be moved to WindowManagerState.
-  frame_decoration_values_ = values.Clone();
-  connection_manager_->ProcessFrameDecorationValuesChanged(this);
+DisplayManager* Display::display_manager() {
+  return connection_manager_->display_manager();
+}
+
+const DisplayManager* Display::display_manager() const {
+  return connection_manager_->display_manager();
+}
+
+mojom::DisplayPtr Display::ToMojomDisplay() const {
+  mojom::DisplayPtr display_ptr = mojom::Display::New();
+  display_ptr = mojom::Display::New();
+  display_ptr->id = id_;
+  display_ptr->bounds = mojo::Rect::New();
+  // TODO(sky): Display should know it's origin.
+  display_ptr->bounds->x = 0;
+  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 =
+      platform_display_->GetViewportMetrics().device_pixel_ratio;
+  display_ptr->rotation = platform_display_->GetRotation();
+  // TODO(sky): make this real.
+  display_ptr->is_primary = true;
+  // TODO(sky): make this real.
+  display_ptr->touch_support = mojom::TouchSupport::UNKNOWN;
+  display_ptr->frame_decoration_values = mojom::FrameDecorationValues::New();
+  display_ptr->frame_decoration_values->normal_client_area_insets =
+      mojo::Insets::New();
+  display_ptr->frame_decoration_values->maximized_client_area_insets =
+      mojo::Insets::New();
+  return display_ptr;
 }
 
 void Display::SchedulePaint(const ServerWindow* window,
                             const gfx::Rect& bounds) {
   DCHECK(root_->Contains(window));
   platform_display_->SchedulePaint(window, bounds);
 }
 
 void Display::ScheduleSurfaceDestruction(ServerWindow* window) {
   if (!platform_display_->IsFramePending()) {
@@ skipping 28 matching lines @@
   }
   return nullptr;
 }
 
 WindowManagerState* Display::GetFirstWindowManagerState() {
   return window_manager_state_map_.empty()
              ? nullptr
              : window_manager_state_map_.begin()->second.get();
 }
 
-WindowManagerState* Display::GetWindowManagerStateForUser(
-    const UserId& user_id) {
+const WindowManagerState* Display::GetWindowManagerStateForUser(
+    const UserId& user_id) const {
   auto iter = window_manager_state_map_.find(user_id);
   return iter == window_manager_state_map_.end() ? nullptr : iter->second.get();
 }
 
 void Display::SetCapture(ServerWindow* window, bool in_nonclient_area) {
   ServerWindow* capture_window = event_dispatcher_.capture_window();
   if (capture_window == window)
     return;
   event_dispatcher_.SetCaptureWindow(window, in_nonclient_area);
 }
@@ skipping 103 matching lines @@
     // For this case we never create additional WindowManagerStates, so any
     // id works.
     window_manager_state_map_[mojo::shell::mojom::kRootUserID] =
         std::move(wms_ptr);
     wms->tree_ = binding_->CreateWindowTree(wms->root());
   } else {
     CreateWindowManagerStatesFromRegistry();
   }
 }
 
-DisplayManager* Display::display_manager() {
-  return connection_manager_->display_manager();
-}
-
-const DisplayManager* Display::display_manager() const {
-  return connection_manager_->display_manager();
-}
-
 void Display::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
   OnEventAck(tree_awaiting_input_ack_);
 }
 
 void Display::QueueEvent(
     const ui::Event& event,
     scoped_ptr<ProcessedEventTarget> processed_event_target) {
   scoped_ptr<QueuedEvent> queued_event(new QueuedEvent);
@@ skipping 125 matching lines @@
     focus_controller_.reset(new FocusController(this, root_.get()));
     focus_controller_->AddObserver(this);
     InitWindowManagersIfNecessary();
     event_dispatcher_.set_root(root_.get());
   } else {
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
     const gfx::Rect wm_bounds(root_->bounds().size());
     for (auto& pair : window_manager_state_map_)
       pair.second->root()->SetBounds(wm_bounds);
   }
+  // TODO(sky): if bounds changed, then need to update
+  // Display/WindowManagerState appropriately (e.g. notify observers).
   connection_manager_->ProcessViewportMetricsChanged(this, old_metrics,
                                                      new_metrics);
 }
 
 void Display::OnTopLevelSurfaceChanged(cc::SurfaceId surface_id) {
   event_dispatcher_.set_surface_id(surface_id);
 }
 
 void Display::OnCompositorFrameDrawn() {
   std::set<ServerWindow*> windows;
@@ skipping 163 matching lines @@
   if (!state)
     return;
 
   // DestroyTree() calls back to OnWillDestroyTree() and the WindowManagerState
   // is destroyed (and removed).
   connection_manager_->DestroyTree(state->tree());
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
 void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
-  CreateWindowManagerStateFromService(service);
+  if (!binding_)
+    CreateWindowManagerStateFromService(service);
 }
 
 }  // namespace ws
 }  // namespace mus