WIP: Surface Synchronization System

services/ui/ws/server_window.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/server_window.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
+#include "base/debug/stack_trace.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "services/ui/common/transient_window_utils.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/server_window_observer.h"
 
 namespace ui {
 namespace ws {
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate, const WindowId& id)
-    : ServerWindow(delegate, id, Properties()) {}
+    : ServerWindow(delegate, id, Properties(), cc::LocalFrameId()) {}
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate,
                            const WindowId& id,
-                           const Properties& properties)
+                           const Properties& properties,
+                           const cc::LocalFrameId& local_frame_id)
     : delegate_(delegate),
       id_(id),
+      local_frame_id_(local_frame_id),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       is_modal_(false),
       visible_(false),
       cursor_id_(mojom::Cursor::CURSOR_NULL),
       non_client_cursor_id_(mojom::Cursor::CURSOR_NULL),
       opacity_(1),
       can_focus_(true),
       can_accept_events_(true),
       properties_(properties),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as ServerWindowDrawTracker).
       observers_(
           base::ObserverList<ServerWindowObserver>::NOTIFY_EXISTING_ONLY) {
   DCHECK(delegate);  // Must provide a delegate.
+  fprintf(stderr, ">>>ServerWindow creation: %d\n", WindowIdToTransportId(id));
+  // if (WindowIdToTransportId(id) == 65566)
+  //  base::debug::StackTrace().Print();
 }
 
 ServerWindow::~ServerWindow() {
+  fprintf(stderr, ">>>~ServerWindow %s\n", GetDebugWindowInfo().c_str());
   for (auto& observer : observers_)
     observer.OnWindowDestroying(this);
 
   if (transient_parent_)
     transient_parent_->RemoveTransientWindow(this);
 
   // Destroy transient children, only after we've removed ourselves from our
   // parent, as destroying an active transient child may otherwise attempt to
   // refocus us.
   Windows transient_children(transient_children_);
@@ skipping 109 matching lines @@
   child->Reorder(children_.front(), mojom::OrderDirection::BELOW);
 }
 
 void ServerWindow::StackChildAtTop(ServerWindow* child) {
   // There's nothing to do if the child is already at the top.
   if (children_.size() <= 1 || child == children_.back())
     return;
   child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
 }
 
-void ServerWindow::SetBounds(const gfx::Rect& bounds) {
-  if (bounds_ == bounds)
-    return;
-
-  // TODO(fsamuel): figure out how will this work with CompositorFrames.
+void ServerWindow::SetBounds(const gfx::Rect& bounds,
+                             const cc::LocalFrameId& local_frame_id) {
+  // if (bounds_ == bounds)
+  //  return;
 
   const gfx::Rect old_bounds = bounds_;
   bounds_ = bounds;
+  local_frame_id_ = local_frame_id;
+  fprintf(stderr, ">>>ServerWindow::SetBounds(Rect(%d, %d, %d, %d), %s\n",
+          bounds.x(), bounds.y(), bounds.width(), bounds.height(),
+          cc::SurfaceId(cc::FrameSinkId(WindowIdToTransportId(id()), 0),
+                        local_frame_id)
+              .ToString()
+              .c_str());
   for (auto& observer : observers_)
-    observer.OnWindowBoundsChanged(this, old_bounds, bounds);
+    observer.OnWindowBoundsChanged(this, old_bounds, bounds, local_frame_id);
 }
 
 void ServerWindow::SetClientArea(
     const gfx::Insets& insets,
     const std::vector<gfx::Rect>& additional_client_areas) {
   if (client_area_ == insets &&
       additional_client_areas == additional_client_areas_) {
     return;
   }
 
@@ skipping 202 matching lines @@
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 std::string ServerWindow::GetDebugWindowHierarchy() const {
   std::string result;
   BuildDebugInfo(std::string(), &result);
   return result;
 }
 
 std::string ServerWindow::GetDebugWindowInfo() const {
   std::string name = GetName();
   return base::StringPrintf(
-      "id=%s visible=%s bounds=%d,%d %dx%d %s", id_.ToString().c_str(),
+      "server_id: %d id=%s visible=%s bounds=%d,%d %dx%d %s",
+      WindowIdToTransportId(id_), id_.ToString().c_str(),
       visible_ ? "true" : "false", bounds_.x(), bounds_.y(), bounds_.width(),
       bounds_.height(), !name.empty() ? name.c_str() : "(no name)");
 }
 
 void ServerWindow::BuildDebugInfo(const std::string& depth,
                                   std::string* result) const {
   *result +=
       base::StringPrintf("%s%s\n", depth.c_str(), GetDebugWindowInfo().c_str());
   for (const ServerWindow* child : children_)
     child->BuildDebugInfo(depth + "  ", result);
@@ skipping 55 matching lines @@
   window->OnStackingChanged();
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
 }  // namespace ui