WIP: Surface Synchronization System

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
+#include "base/debug/stack_trace.h"
 #include "base/memory/ptr_util.h"
+#include "cc/surfaces/frame_sink_id.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/public/cpp/gpu/gpu.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
@@ skipping 145 matching lines @@
     window_manager_delegate->SetWindowManagerClient(this);
   if (connector) {  // |connector| can be null in tests.
     gpu_ = ui::Gpu::Create(connector, std::move(io_task_runner));
     compositor_context_factory_ =
         base::MakeUnique<MusContextFactory>(gpu_.get());
     Env::GetInstance()->set_context_factory(compositor_context_factory_.get());
   }
 }
 
 WindowTreeClient::~WindowTreeClient() {
+  fprintf(stderr, ">>>%s\n", __PRETTY_FUNCTION__);
   in_destructor_ = true;
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
 
   std::vector<Window*> non_owned;
   WindowTracker tracker;
   while (!windows_.empty()) {
     IdToWindowMap::iterator it = windows_.begin();
     if (WasCreatedByThisClient(it->second)) {
@@ skipping 85 matching lines @@
   // Window::Init() must be called before Embed() (otherwise the server hasn't
   // been told about the window).
   DCHECK(window->layer());
   if (!window->children().empty()) {
     // The window server removes all children before embedding. In other words,
     // it's generally an error to Embed() with existing children. So, fail
     // early.
     callback.Run(false);
     return;
   }
-
-  tree_->Embed(WindowMus::Get(window)->server_id(), std::move(client), flags,
-               callback);
+  WindowMus* window_mus = WindowMus::Get(window);
+  tree_->Embed(window_mus->server_id(), std::move(client), flags, callback);
+  fprintf(stderr, ">>>>WindowTreeClient::Embed\n");
+  // window->SetLocalFrameIdFromServer(local_frame_id);
 }
 
 void WindowTreeClient::AttachCompositorFrameSink(
     Id window_id,
     cc::mojom::MojoCompositorFrameSinkRequest compositor_frame_sink,
     cc::mojom::MojoCompositorFrameSinkClientPtr client) {
   DCHECK(tree_);
   tree_->AttachCompositorFrameSink(window_id, std::move(compositor_frame_sink),
                                    std::move(client));
 }
@@ skipping 87 matching lines @@
   }
 }
 
 std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortMus(
     const ui::mojom::WindowData& window_data,
     WindowMusType window_mus_type) {
   std::unique_ptr<WindowPortMus> window_port_mus(
       base::MakeUnique<WindowPortMus>(this, window_mus_type));
   window_port_mus->set_server_id(window_data.window_id);
   RegisterWindowMus(window_port_mus.get());
+  // If (window_port_mus->server_id() == 65566)
+  //  base::debug::StackTrace().Print();
   return window_port_mus;
 }
 
 void WindowTreeClient::SetLocalPropertiesFromServerProperties(
     WindowMus* window,
     const ui::mojom::WindowData& window_data) {
   for (auto& pair : window_data.properties)
     window->SetPropertyFromServer(pair.first, &pair.second);
 }
 
 std::unique_ptr<WindowTreeHostMus> WindowTreeClient::CreateWindowTreeHost(
     WindowMusType window_mus_type,
     const ui::mojom::WindowData& window_data,
     int64_t display_id) {
   std::unique_ptr<WindowPortMus> window_port =
       CreateWindowPortMus(window_data, window_mus_type);
   roots_.insert(window_port.get());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       base::MakeUnique<WindowTreeHostMus>(std::move(window_port), this,
                                           display_id);
   window_tree_host->InitHost();
   SetLocalPropertiesFromServerProperties(
       WindowMus::Get(window_tree_host->window()), window_data);
   if (window_data.visible) {
     SetWindowVisibleFromServer(WindowMus::Get(window_tree_host->window()),
                                true);
   }
-  SetWindowBoundsFromServer(WindowMus::Get(window_tree_host->window()),
-                            window_data.bounds);
+  WindowMus* window = WindowMus::Get(window_tree_host->window());
+
+  SetWindowBoundsFromServer(window, window_data.bounds,
+                            window_data.local_frame_id);
+  fprintf(stderr, ">>>WindowTreeClient::CreateWindowTreeHost %s\n",
+          cc::SurfaceId(cc::FrameSinkId(window->server_id(), 0),
+                        window_data.local_frame_id)
+              .ToString()
+              .c_str());
   return window_tree_host;
 }
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowData& window_data) {
   // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data, WindowMusType::OTHER));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
   SetWindowTypeFromProperties(window, window_data.properties);
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
   window_mus->SetBoundsFromServer(
-      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window), window_data.bounds));
+      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window), window_data.bounds),
+      window_data.local_frame_id);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data.visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
 void WindowTreeClient::SetWindowTree(ui::mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
   WindowTreeConnectionEstablished(tree_ptr_.get());
@@ skipping 43 matching lines @@
   tree_->SetModal(change_id, window->server_id());
   return true;
 }
 
 void WindowTreeClient::OnEmbedImpl(ui::mojom::WindowTree* window_tree,
                                    ClientSpecificId client_id,
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
+  fprintf(stderr, ">>%s\n", __PRETTY_FUNCTION__);
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   client_id_ = client_id;
   WindowTreeConnectionEstablished(window_tree);
 
   DCHECK(roots_.empty());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::EMBED, *root_data, display_id);
 
   focus_synchronizer_->SetFocusFromServer(
@@ skipping 27 matching lines @@
 }
 
 void WindowTreeClient::OnReceivedCursorLocationMemory(
     mojo::ScopedSharedBufferHandle handle) {
   cursor_location_mapping_ = handle->Map(sizeof(base::subtle::Atomic32));
   DCHECK(cursor_location_mapping_);
 }
 
 void WindowTreeClient::SetWindowBoundsFromServer(
     WindowMus* window,
-    const gfx::Rect& revert_bounds_in_pixels) {
+    const gfx::Rect& revert_bounds_in_pixels,
+    const cc::LocalFrameId& local_frame_id) {
+  cc::FrameSinkId frame_sink_id(window->server_id(), 0);
+  cc::SurfaceId surface_id(frame_sink_id, local_frame_id);
+  fprintf(stderr,
+          ">>>>WindowTreeClient::SetWindowBoundsFromServer %s root? %d\n",
+          surface_id.ToString().c_str(), IsRoot(window));
+
   if (IsRoot(window)) {
     // WindowTreeHost expects bounds to be in pixels.
     GetWindowTreeHostMus(window)->SetBoundsFromServer(revert_bounds_in_pixels);
-    return;

[mfomitchev, 2017/01/25 21:41:18]

Removing this might be problematic. Not entirely sure if this could be causing
the problem you are seeing, but I wouldn't mess with the way root  client
windows are handled.

   }
 
-  window->SetBoundsFromServer(gfx::ConvertRectToDIP(
-      ScaleFactorForDisplay(window->GetWindow()), revert_bounds_in_pixels));
+  window->SetBoundsFromServer(
+      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window->GetWindow()),
+                            revert_bounds_in_pixels),
+      local_frame_id);
 }
 
 void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
                                                   bool visible) {
   if (!IsRoot(window)) {
     window->SetVisibleFromServer(visible);
     return;
   }
 
   std::unique_ptr<WindowMusChangeData> data =
       window->PrepareForServerVisibilityChange(visible);
   WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
   if (visible)
     window_tree_host->Show();
   else
     window_tree_host->Hide();
 }
 
 void WindowTreeClient::ScheduleInFlightBoundsChange(
     WindowMus* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
-  const uint32_t change_id = ScheduleInFlightChange(
-      base::MakeUnique<InFlightBoundsChange>(this, window, old_bounds));
-  tree_->SetWindowBounds(change_id, window->server_id(), new_bounds);
+  cc::FrameSinkId frame_sink_id(window->server_id(), 0);
+  std::unique_ptr<cc::SurfaceIdAllocator>& allocator =
+      local_frame_id_allocators_[frame_sink_id];
+  if (!allocator)
+    allocator.reset(new cc::SurfaceIdAllocator());
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<InFlightBoundsChange>(
+          this, window, old_bounds, allocator->GenerateId()));
+  cc::LocalFrameId local_frame_id;
+  if (!allocator->current_local_frame_id().is_valid() ||
+      new_bounds.size() != old_bounds.size()) {
+    local_frame_id = allocator->GenerateId();
+  } else {
+    local_frame_id = allocator->current_local_frame_id();
+  }
+
+  tree_->SetWindowBounds(change_id, window->server_id(), new_bounds,
+                         local_frame_id);
+  // fprintf(stderr, ">>>ScheduleInFlightBoundsChange window_type: %d\n",
+  //        window->window_mus_type());
+  // if (window->server_id() == 65566)
+  //  base::debug::StackTrace().Print();
+  if (window->GetLayerType() == ui::LAYER_SURFACE)
+    window->SetLocalFrameIdFromServer(local_frame_id);
 }
 
-void WindowTreeClient::OnWindowMusCreated(WindowMus* window) {
+void WindowTreeClient::OnWindowMusCreated(WindowMus* window,
+                                          ui::LayerType layer_type) {
   if (window->server_id() != kInvalidServerId)
     return;
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
   DCHECK(window_manager_delegate_ || !IsRoot(window));
 
   std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
   std::set<const void*> property_keys =
       window->GetWindow()->GetAllPropertKeys();
   PropertyConverter* property_converter = delegate_->GetPropertyConverter();
   for (const void* key : property_keys) {
     std::string transport_name;
     std::unique_ptr<std::vector<uint8_t>> transport_value;
     if (!property_converter->ConvertPropertyForTransport(
             window->GetWindow(), key, &transport_name, &transport_value)) {
       continue;
     }
     if (!transport_value) {
       transport_properties[transport_name] = std::vector<uint8_t>();
     } else {
       transport_properties[transport_name] = std::move(*transport_value);
     }
   }
 
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<CrashInFlightChange>(window, ChangeType::NEW_WINDOW));
+  cc::FrameSinkId frame_sink_id(window->server_id(), 0);
+  std::unique_ptr<cc::SurfaceIdAllocator>& allocator =
+      local_frame_id_allocators_[frame_sink_id];
+  if (!allocator)
+    allocator.reset(new cc::SurfaceIdAllocator());
+  cc::LocalFrameId local_frame_id = allocator->GenerateId();
   tree_->NewWindow(change_id, window->server_id(),
-                   std::move(transport_properties));
+                   std::move(transport_properties), local_frame_id);
+  window->SetLayerType(layer_type);
+  fprintf(stderr, ">>>New Window window_type: %d\n", window->window_mus_type());
+  // if (window->server_id() == 65566)
+  //  base::debug::StackTrace().Print();
+  if (layer_type == ui::LAYER_SURFACE)
+    window->SetLocalFrameIdFromServer(local_frame_id);
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window, Origin origin) {
   if (focus_synchronizer_->focused_window() == window)
     focus_synchronizer_->OnFocusedWindowDestroyed();
 
   // TODO: decide how to deal with windows not owned by this client.
   if (origin == Origin::CLIENT &&
       (WasCreatedByThisClient(window) || IsRoot(window))) {
     const uint32_t change_id =
@@ skipping 20 matching lines @@
   }
   for (auto change_id : in_flight_change_ids_to_remove)
     in_flight_map_.erase(change_id);
 
   roots_.erase(window);
 }
 
 void WindowTreeClient::OnWindowMusBoundsChanged(WindowMus* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
+  // Called from window->SetBounds in aura.
   // Changes to bounds of root windows are routed through
   // OnWindowTreeHostBoundsWillChange(). Any bounds that happen here are a side
   // effect of those and can be ignored.
   if (IsRoot(window))
     return;
 
   float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());
   ScheduleInFlightBoundsChange(
       window, gfx::ConvertRectToPixel(device_scale_factor, old_bounds),
       gfx::ConvertRectToPixel(device_scale_factor, new_bounds));
@@ skipping 240 matching lines @@
 
 void WindowTreeClient::OnTopLevelCreated(uint32_t change_id,
                                          ui::mojom::WindowDataPtr data,
                                          int64_t display_id,
                                          bool drawn) {
   // The server ack'd the top level window we created and supplied the state
   // of the window at the time the server created it. For properties we do not
   // have changes in flight for we can update them immediately. For properties
   // with changes in flight we set the revert value from the server.
 
+  const cc::LocalFrameId local_frame_id(data->local_frame_id);
   if (!in_flight_map_.count(change_id)) {
     // The window may have been destroyed locally before the server could finish
     // creating the window, and before the server received the notification that
     // the window has been destroyed.
+    fprintf(stderr,
+            ">>>WindowTreeClient::OnTopLevelCreated early exit server_id: %d, "
+            "localframeid: %s\n",
+            data->window_id, local_frame_id.ToString().c_str());
     return;
   }
   std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
 
   WindowMus* window = change->window();
   WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
 
   // Drawn state and display-id always come from the server (they can't be
   // modified locally).
   window_tree_host->set_display_id(display_id);
 
   // The default visibilty is false, we only need update visibility if it
   // differs from that.
   if (data->visible) {
     InFlightVisibleChange visible_change(this, window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
       SetWindowVisibleFromServer(window, true);
   }
 
   const gfx::Rect bounds(data->bounds);
+  fprintf(stderr,
+          ">>>WindowTreeClient::OnTopLevelCreated server_id: %d, localframeid: "
+          "%s\n",
+          window->server_id(), local_frame_id.ToString().c_str());
   {
-    InFlightBoundsChange bounds_change(this, window, bounds);
+    InFlightBoundsChange bounds_change(this, window, bounds, local_frame_id);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
+    // TODO(fsamuel): We need to inform the window even if bounds have not
+    // changed because the embedded LocalFrameId might have changed.
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
-    else if (gfx::ConvertRectToPixel(ScaleFactorForDisplay(window->GetWindow()),
+    else /*if
+            (gfx::ConvertRectToPixel(ScaleFactorForDisplay(window->GetWindow()),
                                      window->GetWindow()->bounds()) != bounds)
-      SetWindowBoundsFromServer(window, bounds);
+            */
+      SetWindowBoundsFromServer(window, bounds, local_frame_id);
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
   for (const auto& pair : data->properties) {
     std::unique_ptr<std::vector<uint8_t>> revert_value(
         base::MakeUnique<std::vector<uint8_t>>(pair.second));
     InFlightPropertyChange property_change(window, pair.first,
                                            std::move(revert_value));
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(property_change);
     if (current_change) {
       current_change->SetRevertValueFrom(property_change);
     } else {
       window->SetPropertyFromServer(pair.first, &pair.second);
     }
   }
 
   // Top level windows should not have a parent.
   DCHECK_EQ(0u, data->parent_id);
 }
 
-void WindowTreeClient::OnWindowBoundsChanged(Id window_id,
-                                             const gfx::Rect& old_bounds,
-                                             const gfx::Rect& new_bounds) {
+void WindowTreeClient::OnWindowBoundsChanged(
+    Id window_id,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds,
+    const cc::LocalFrameId& local_frame_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
-  InFlightBoundsChange new_change(this, window, new_bounds);
+  InFlightBoundsChange new_change(this, window, new_bounds, local_frame_id);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  SetWindowBoundsFromServer(window, new_bounds);
+  SetWindowBoundsFromServer(window, new_bounds, local_frame_id);
 }
 
 void WindowTreeClient::OnClientAreaChanged(
     uint32_t window_id,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
@@ skipping 367 matching lines @@
 }
 
 void WindowTreeClient::WmDisplayModified(const display::Display& display) {
   DCHECK(window_manager_delegate_);
   // TODO(sky): this should likely route to WindowTreeHost.
   window_manager_delegate_->OnWmDisplayModified(display);
 }
 
 void WindowTreeClient::WmSetBounds(uint32_t change_id,
                                    Id window_id,
-                                   const gfx::Rect& transit_bounds_in_pixels) {
+                                   const gfx::Rect& transit_bounds_in_pixels,
+                                   const cc::LocalFrameId& local_frame_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());
     DCHECK(window_manager_delegate_);
     gfx::Rect transit_bounds_in_dip =
         gfx::ConvertRectToDIP(device_scale_factor, transit_bounds_in_pixels);
     gfx::Rect bounds_in_dip = transit_bounds_in_dip;
     // TODO: this needs to trigger scheduling a bounds change on |window|.
     result = window_manager_delegate_->OnWmSetBounds(window->GetWindow(),
                                                      &bounds_in_dip);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       result = bounds_in_dip == transit_bounds_in_dip;
-      window->SetBoundsFromServer(bounds_in_dip);
+      window->SetBoundsFromServer(bounds_in_dip, local_frame_id);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmSetProperty(
     uint32_t change_id,
     Id window_id,
     const std::string& name,
@@ skipping 258 matching lines @@
   tree_->StackAtTop(change_id, window->server_id());
 }
 
 std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortForTopLevel(
     const std::map<std::string, std::vector<uint8_t>>* properties) {
   std::unique_ptr<WindowPortMus> window_port =
       base::MakeUnique<WindowPortMus>(this, WindowMusType::TOP_LEVEL);
   roots_.insert(window_port.get());
 
   window_port->set_server_id(MakeTransportId(client_id_, next_window_id_++));
+  fprintf(stderr,
+          ">>>WindowTreeClient::CreateWindowPortForTopLevel server_id: %d\n",
+          window_port->server_id());
   RegisterWindowMus(window_port.get());
 
   std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
   if (properties) {
     for (const auto& property_pair : *properties)
       transport_properties[property_pair.first] = property_pair.second;
   }
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           window_port.get(), ChangeType::NEW_TOP_LEVEL_WINDOW));
   tree_->NewTopLevelWindow(change_id, window_port->server_id(),
                            transport_properties);
+
+  // if (window_port->server_id() == 65566)
+  //  base::debug::StackTrace().Print();
   return window_port;
 }
 
 void WindowTreeClient::OnWindowTreeHostCreated(
     WindowTreeHostMus* window_tree_host) {
   // All WindowTreeHosts are destroyed before this, so we don't need to unset
   // the DragDropClient.
   client::SetDragDropClient(window_tree_host->window(),
                             drag_drop_controller_.get());
 }
@@ skipping 74 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura