WIP: Propagate SurfaceID up window tree hierarchy

services/ui/public/cpp/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 "services/ui/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 338 matching lines @@
 
 void WindowTreeClient::AttachSurface(
     Id window_id,
     mojom::SurfaceType type,
     mojo::InterfaceRequest<mojom::Surface> surface,
     mojom::SurfaceClientPtr client) {
   DCHECK(tree_);
   tree_->AttachSurface(window_id, type, std::move(surface), std::move(client));
 }
 
+void WindowTreeClient::SatisfySurfaceSequence(
+    Id window_id,
+    const cc::SurfaceSequence& sequence) {
+  DCHECK(tree_);
+  tree_->SatisfySurfaceSequence(window_id, sequence);
+}
+
 void WindowTreeClient::LocalSetCapture(Window* window) {
   if (capture_window_ == window)
     return;
   Window* lost_capture = capture_window_;
   capture_window_ = window;
   if (lost_capture) {
     FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(lost_capture).observers(),
                       OnWindowLostCapture(lost_capture));
   }
   FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
@@ skipping 113 matching lines @@
         this, !parents.empty() ? parents.back() : nullptr, windows[i]);
     if (!last_window)
       root = window;
     last_window = window;
   }
   return root;
 }
 
 Window* WindowTreeClient::NewWindowImpl(
     NewWindowType type,
-    const Window::SharedProperties* properties) {
+    const Window::SharedProperties* properties,
+    bool container) {
   DCHECK(tree_);
-  Window* window =
-      new Window(this, MakeTransportId(client_id_, next_window_id_++));
+  Window* window = new Window(
+      this, MakeTransportId(client_id_, next_window_id_++), container);
   if (properties)
     window->properties_ = *properties;
   AddWindow(window);
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           window, type == NewWindowType::CHILD
                       ? ChangeType::NEW_WINDOW
                       : ChangeType::NEW_TOP_LEVEL_WINDOW));
   mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
@@ skipping 181 matching lines @@
       base::MakeUnique<InFlightDragChange>(window, ChangeType::MOVE_LOOP));
   // Tell the window manager to take over moving us.
   tree_->PerformWindowMove(current_move_loop_change_, window->server_id(),
                            source, cursor_location);
 }
 
 void WindowTreeClient::CancelWindowMove(Window* window) {
   tree_->CancelWindowMove(window->server_id());
 }
 
-Window* WindowTreeClient::NewWindow(
-    const Window::SharedProperties* properties) {
-  return NewWindowImpl(NewWindowType::CHILD, properties);
+Window* WindowTreeClient::NewWindow(const Window::SharedProperties* properties,
+                                    bool container) {
+  return NewWindowImpl(NewWindowType::CHILD, properties, container);
 }
 
 Window* WindowTreeClient::NewTopLevelWindow(
     const Window::SharedProperties* properties) {
   Window* window = NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
   // Assume newly created top level windows are drawn by default, otherwise
   // requests to focus will fail. We will get the real value in
   // OnTopLevelCreated().
   window->LocalSetParentDrawn(true);
   return window;
@@ skipping 169 matching lines @@
   if (!window)
     return;
 
   InFlightBoundsChange new_change(window, new_bounds);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetBounds(old_bounds, new_bounds);
 }
 
+void WindowTreeClient::OnWindowSurfaceCreated(
+    Id window_id,
+    const gfx::Size& size,
+    float device_scale_factor,
+    const cc::SurfaceId& surface_id,
+    const cc::SurfaceSequence& surface_sequence) {
+  Window* window = GetWindowByServerId(window_id);
+  if (!window)
+    return;
+
+  // TODO(fsamuel): Figure out lifetime management.
+  WindowPrivate(window).LocalSetSurfaceId(size, device_scale_factor, surface_id,
+                                          surface_sequence);
+}
+
 void WindowTreeClient::OnClientAreaChanged(
     uint32_t window_id,
     const gfx::Insets& new_client_area,
     mojo::Array<gfx::Rect> new_additional_client_areas) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
     WindowPrivate(window).LocalSetClientArea(
         new_client_area,
         new_additional_client_areas.To<std::vector<gfx::Rect>>());
   }
@@ skipping 508 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace ui