WIP: Surface Synchronization System

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 64 matching lines @@
       next_window_id_(1),
       access_policy_(std::move(access_policy)),
       event_ack_id_(0),
       window_manager_internal_(nullptr) {
   if (root)
     roots_.insert(root);
   access_policy_->Init(id_, this);
 }
 
 WindowTree::~WindowTree() {
+  fprintf(stderr, ">>>%s\n", __PRETTY_FUNCTION__);
   DestroyWindows();
 
   // We alert the WindowManagerState that we're destroying this state here
   // because WindowManagerState would attempt to use things that wouldn't have
   // been cleaned up by OnWindowDestroyingTreeImpl().
   if (window_manager_state_)
     window_manager_state_->OnWillDestroyTree(this);
 }
 
 void WindowTree::Init(std::unique_ptr<WindowTreeBinding> binding,
@@ skipping 164 matching lines @@
       window != current_capture_window) {
     return false;
   }
   Operation op(this, window_server_, OperationType::RELEASE_CAPTURE);
   return display_root->window_manager_state()->SetCapture(nullptr,
                                                           kInvalidClientId);
 }
 
 bool WindowTree::NewWindow(
     const ClientWindowId& client_window_id,
-    const std::map<std::string, std::vector<uint8_t>>& properties) {
+    const std::map<std::string, std::vector<uint8_t>>& properties,
+    const cc::LocalFrameId& local_frame_id) {
   if (!IsValidIdForNewWindow(client_window_id))
     return false;
   const WindowId window_id = GenerateNewWindowId();
   DCHECK(!GetWindow(window_id));
   ServerWindow* window =
-      window_server_->CreateServerWindow(window_id, properties);
+      window_server_->CreateServerWindow(window_id, properties, local_frame_id);
   created_window_map_[window_id] = window;
   client_id_to_window_id_map_[client_window_id] = window_id;
   window_id_to_client_id_map_[window_id] = client_window_id;
   return true;
 }
 
 bool WindowTree::AddWindow(const ClientWindowId& parent_id,
                            const ClientWindowId& child_id) {
   ServerWindow* parent = GetWindowByClientId(parent_id);
   ServerWindow* child = GetWindowByClientId(child_id);
@@ skipping 193 matching lines @@
     const ServerWindow* window) {
   DCHECK(IsWaitingForNewTopLevelWindow(wm_change_id));
   std::unique_ptr<WaitingForTopLevelWindowInfo>
       waiting_for_top_level_window_info(
           std::move(waiting_for_top_level_window_info_));
   binding_->SetIncomingMethodCallProcessingPaused(false);
   // We were paused, so the id should still be valid.
   DCHECK(IsValidIdForNewWindow(
       waiting_for_top_level_window_info->client_window_id));
   if (!window) {
+    fprintf(stderr, ">>>LOST A WINDOW :S\n");
     client()->OnChangeCompleted(client_change_id, false);
     return;
   }
   client_id_to_window_id_map_[waiting_for_top_level_window_info
                                   ->client_window_id] = window->id();
   window_id_to_client_id_map_[window->id()] =
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
   Display* display = GetDisplay(window);
   int64_t display_id = display ? display->GetId() : display::kInvalidDisplayId;
   const bool drawn = window->parent() && window->parent()->IsDrawn();
+  fprintf(stderr,
+          ">>>>WindowTree::OnWindowManagerCreatedTopLevelWindow frame_sink_id: "
+          "%d\n",
+          WindowIdToTransportId(window->id()));
   client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
                               display_id, drawn);
 }
 
 void WindowTree::AddActivationParent(const ClientWindowId& window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
   if (window) {
     Display* display = GetDisplay(window);
     if (display)
       display->AddActivationParent(window);
@@ skipping 30 matching lines @@
 void WindowTree::ClientJankinessChanged(WindowTree* tree) {
   tree->janky_ = !tree->janky_;
   // Don't inform the client if it is the source of jank (which generally only
   // happens while debugging).
   if (window_manager_internal_ && tree != this) {
     window_manager_internal_->WmClientJankinessChanged(
         tree->id(), tree->janky());
   }
 }
 
-void WindowTree::ProcessWindowBoundsChanged(const ServerWindow* window,
-                                            const gfx::Rect& old_bounds,
-                                            const gfx::Rect& new_bounds,
-                                            bool originated_change) {
+void WindowTree::ProcessWindowBoundsChanged(
+    const ServerWindow* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds,
+    bool originated_change,
+    const cc::LocalFrameId& local_frame_id) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
-  client()->OnWindowBoundsChanged(client_window_id.id, old_bounds, new_bounds);
+  client()->OnWindowBoundsChanged(client_window_id.id, old_bounds, new_bounds,
+                                  local_frame_id);
 }
 
 void WindowTree::ProcessClientAreaChanged(
     const ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas,
     bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
@@ skipping 468 matching lines @@
   window_data->parent_id =
       parent ? ClientWindowIdForWindow(parent).id : ClientWindowId().id;
   window_data->window_id =
       window ? ClientWindowIdForWindow(window).id : ClientWindowId().id;
   window_data->transient_parent_id =
       transient_parent ? ClientWindowIdForWindow(transient_parent).id
                        : ClientWindowId().id;
   window_data->bounds = window->bounds();
   window_data->properties = mojo::MapToUnorderedMap(window->properties());
   window_data->visible = window->visible();
+  window_data->local_frame_id = window->local_frame_id();
   return window_data;
 }
 
 void WindowTree::GetWindowTreeImpl(
     const ServerWindow* window,
     std::vector<const ServerWindow*>* windows) const {
   DCHECK(window);
 
   if (!access_policy_->CanGetWindowTree(window))
     return;
@@ skipping 104 matching lines @@
     return true;
   return event.type() == ui::ET_POINTER_DOWN ||
          event.type() == ui::ET_POINTER_UP ||
          event.type() == ui::ET_POINTER_WHEEL_CHANGED;
 }
 
 void WindowTree::NewWindow(
     uint32_t change_id,
     Id transport_window_id,
     const base::Optional<std::unordered_map<std::string, std::vector<uint8_t>>>&
-        transport_properties) {
+        transport_properties,
+    const cc::LocalFrameId& local_frame_id) {
   std::map<std::string, std::vector<uint8_t>> properties;
   if (transport_properties.has_value())
     properties = mojo::UnorderedMapToMap(transport_properties.value());
 
   client()->OnChangeCompleted(
-      change_id, NewWindow(ClientWindowId(transport_window_id), properties));
+      change_id, NewWindow(ClientWindowId(transport_window_id), properties,
+                           local_frame_id));
 }
 
 void WindowTree::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
     const std::unordered_map<std::string, std::vector<uint8_t>>&
         transport_properties) {
   // TODO(sky): rather than DCHECK, have this kill connection.
   DCHECK(!window_manager_internal_);  // Not valid for the windowmanager.
   DCHECK(!waiting_for_top_level_window_info_);
@@ skipping 137 matching lines @@
   pointer_watcher_want_moves_ = want_moves;
 }
 
 void WindowTree::StopPointerWatcher() {
   has_pointer_watcher_ = false;
   pointer_watcher_want_moves_ = false;
 }
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
-                                 const gfx::Rect& bounds) {
+                                 const gfx::Rect& bounds,
+                                 const cc::LocalFrameId& local_frame_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
     WindowManagerDisplayRoot* display_root =
         GetWindowManagerDisplayRoot(window);
     WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
     wm_tree->window_manager_internal_->WmSetBounds(
         wm_change_id, wm_tree->ClientWindowIdForWindow(window).id,
-        std::move(bounds));
+        std::move(bounds), local_frame_id);
     return;
   }
 
   DVLOG(3) << "set window bounds client window_id=" << window_id
            << " global window_id="
            << (window ? WindowIdToTransportId(window->id()) : 0)
            << " bounds=" << bounds.ToString();
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_BOUNDS);
-    window->SetBounds(bounds);
+    window->SetBounds(bounds, local_frame_id);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetWindowVisibility(uint32_t change_id,
                                      Id transport_window_id,
                                      bool visible) {
   client()->OnChangeCompleted(
       change_id,
       SetWindowVisibility(ClientWindowId(transport_window_id), visible));
@@ skipping 522 matching lines @@
       if (display_root) {
         WindowManagerState* wms = display_root->window_manager_state();
         // Clear the implicit capture.
         wms->SetCapture(nullptr, false);
       }
     }
 
     if (!response && window) {
       // Our move loop didn't succeed, which means that we must restore the
       // original bounds of the window.
-      window->SetBounds(window_server_->GetCurrentMoveLoopRevertBounds());
+      // TODO(fsamuel): Figure out what to do here.
+      window->SetBounds(window_server_->GetCurrentMoveLoopRevertBounds(),
+                        cc::LocalFrameId());
     }
 
     window_server_->EndMoveLoop();
   }
 
   window_server_->WindowManagerChangeCompleted(change_id, response);
 }
 
 void WindowTree::WmRequestClose(Id transport_window_id) {
   ServerWindow* window =
@@ skipping 168 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui