Mus+Ash: propagate Surface ID to parents

services/ui/public/cpp/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/public/cpp/window.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "cc/surfaces/surface_id.h"
+#include "cc/surfaces/surface_sequence.h"
 #include "services/ui/common/transient_window_utils.h"
 #include "services/ui/public/cpp/property_type_converters.h"
+#include "services/ui/public/cpp/surface_id_handler.h"
 #include "services/ui/public/cpp/window_observer.h"
 #include "services/ui/public/cpp/window_private.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_surface.h"
 #include "services/ui/public/cpp/window_tracker.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/display/display.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 499 matching lines @@
     // advances focus. We don't want to randomly pick a Window to get focus, so
     // we update local state only, and wait for the next focus change from the
     // server.
     client_->LocalSetFocus(nullptr);
   }
 
   // Remove from transient parent.
   if (transient_parent_)
     transient_parent_->LocalRemoveTransientWindow(this);
 
+  // Return the surface reference if there is one.
+  if (!surface_info_.surface_id.is_null())
+    LocalSetSurfaceId(cc::SurfaceId(), cc::SurfaceSequence(), gfx::Size(),
+                      1.0f);
+
   // Remove transient children.
   while (!transient_children_.empty()) {
     Window* transient_child = transient_children_.front();
     LocalRemoveTransientWindow(transient_child);
     transient_child->LocalDestroy();
     DCHECK(transient_children_.empty() ||
            transient_children_.front() != transient_child);
   }
 
   if (parent_)
@@ skipping 29 matching lines @@
 Window::Window(WindowTreeClient* client, Id id)
     : client_(client),
       server_id_(id),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       is_modal_(false),
       // Matches aura, see aura::Window for details.
       observers_(base::ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY),
       input_event_handler_(nullptr),
+      surface_id_handler_(nullptr),
       visible_(false),
       opacity_(1.0f),
       display_id_(display::Display::kInvalidDisplayID),
       cursor_id_(mojom::Cursor::CURSOR_NULL),
       parent_drawn_(false) {}
 
 void Window::SetSharedPropertyInternal(const std::string& name,
                                        const std::vector<uint8_t>* value) {
   if (!WasCreatedByThisClientOrIsRoot(this))
     return;
@@ skipping 188 matching lines @@
     properties_[name] = *value;
   } else if (it != properties_.end()) {
     properties_.erase(it);
   }
 
   FOR_EACH_OBSERVER(
       WindowObserver, observers_,
       OnWindowSharedPropertyChanged(this, name, old_value_ptr, value));
 }
 
+void Window::LocalSetSurfaceId(const cc::SurfaceId& surface_id,
+                               const cc::SurfaceSequence& surface_sequence,
+                               const gfx::Size& frame_size,
+                               float device_scale_factor) {
+  const cc::SurfaceId& existing_surface_id = surface_info_.surface_id;
+  if (!existing_surface_id.is_null() && existing_surface_id != surface_id) {
+    // Return the existing surface sequence.
+    if (client_) {
+      client_->ReturnSurfaceReference(server_id_,
+                                      surface_info_.surface_sequence);
+    }
+  }
+  if (parent_ && parent_->surface_id_handler_) {
+    if (parent_->surface_id_handler_->OnChildWindowSurfaceCreated(
+            this, surface_id, surface_sequence, frame_size,
+            device_scale_factor)) {
+      // Don't store it on the window if the SurfaceIdHandler has picked it up.
+      surface_info_ = {cc::SurfaceId(), cc::SurfaceSequence(), gfx::Size(),
+                       1.0f};
+      return;
+    }
+  }
+  surface_info_ = {surface_id, surface_sequence, frame_size,
+                   device_scale_factor};
+}
+
 void Window::NotifyWindowStackingChanged() {
   if (stacking_target_) {
     Children::const_iterator window_i = std::find(
         parent()->children().begin(), parent()->children().end(), this);
     DCHECK(window_i != parent()->children().end());
     if (window_i != parent()->children().begin() &&
         (*(window_i - 1) == stacking_target_))
       return;
   }
   RestackTransientDescendants(this, &GetStackingTarget,
@@ skipping 126 matching lines @@
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace ui