WIP: Propagate SurfaceID up window tree hierarchy

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/containers/adapters.h"
 #include "base/macros.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/quads/render_pass.h"
+#include "cc/quads/render_pass_draw_quad.h"
+#include "cc/quads/shared_quad_state.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "services/ui/common/transient_window_utils.h"
 #include "services/ui/public/cpp/property_type_converters.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"
@@ skipping 483 matching lines @@
 std::string Window::GetName() const {
   if (HasSharedProperty(mojom::WindowManager::kName_Property))
     return GetSharedProperty<std::string>(mojom::WindowManager::kName_Property);
 
   return std::string();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window, protected:
 
-Window::Window() : Window(nullptr, static_cast<Id>(-1)) {}
+Window::Window(bool container)
+    : Window(nullptr, static_cast<Id>(-1), container) {}
 
 Window::~Window() {
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
+  if (!surface_info_.surface_id.is_null()) {
+    // If the existing surface ID is non-null, then we should return the
+    // existing SurfaceSequence.
+    if (client_) {
+      client_->SatisfySurfaceSequence(
+          server_id_, surface_info_.surface_sequence);
+    }
+  }
+
   if (client_)
     client_->OnWindowDestroying(this);
 
   if (HasFocus()) {
     // The focused window is being removed. When this happens the server
     // 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);
   }
@@ skipping 33 matching lines @@
 
   // Invoke after observers so that can clean up any internal state observers
   // may have changed.
   if (window_tree())
     window_tree()->OnWindowDestroyed(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window, private:
 
-Window::Window(WindowTreeClient* client, Id id)
+Window::Window(WindowTreeClient* client, Id id, bool container)
     : client_(client),
+      container_(container),
       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),
       visible_(false),
       opacity_(1.0f),
       display_id_(display::Display::kInvalidDisplayID),
       cursor_id_(mojom::Cursor::CURSOR_NULL),
-      parent_drawn_(false) {}
+      parent_drawn_(false),
+      draw_timer_(false, false),
+      weak_factory_(this) {
+  if (container) {
+    WantToDraw();
+  }
+}
+
+void Window::WantToDraw() {
+  if (draw_timer_.IsRunning())
+    return;
+
+  // TODO(rjkroege): Use vblank to kick off Draw.
+  draw_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(16),
+                    base::Bind(&Window::Draw, weak_factory_.GetWeakPtr()));
+}
+
+void Window::Draw() {
+  if (!visible_)
+    return;
+
+  const cc::RenderPassId render_pass_id(1, 1);
+  std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  render_pass->SetNew(render_pass_id, bounds_, bounds_, gfx::Transform());
+
+  uint32_t children_drawn = 0;
+  for (Window* child : base::Reversed(children_)) {
+    if (child->surface_info_.surface_id.is_null())
+      continue;
+    children_drawn++;
+    gfx::Transform quad_to_target_transform;
+    quad_to_target_transform.Translate(child->bounds().x(),
+                                       child->bounds().y());
+    cc::SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+    const gfx::Rect bounds_at_origin(child->bounds().size());
+    // TODO(fsamuel): These clipping and visible rects are incorrect. They need
+    // to be populated from CompositorFrame structs.
+    sqs->SetAll(quad_to_target_transform,
+                bounds_at_origin.size() /* layer_bounds */,
+                bounds_at_origin /* visible_layer_bounds */,
+                bounds_at_origin /* clip_rect */, false /* is_clipped */,
+                1.f /* opacity */, SkXfermode::kSrcOver_Mode,
+                0 /* sorting-context_id */);
+    auto* quad = render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
+    quad->SetAll(sqs, child->bounds() /* rect */, gfx::Rect() /* opaque_rect */,
+                 bounds_at_origin /* visible_rect */, true /* needs_blending*/,
+                 child->surface_info_.surface_id);
+  }
+  if (children_drawn) {
+    std::unique_ptr<cc::DelegatedFrameData> frame_data(
+        new cc::DelegatedFrameData);
+    frame_data->render_pass_list.push_back(std::move(render_pass));
+    cc::CompositorFrame frame;
+    frame.delegated_frame_data = std::move(frame_data);
+    if (!container_surface_) {
+      SetSharedProperty<bool>(
+          ui::mojom::WindowManager::kContainer_Property, true);
+      container_surface_ = RequestSurface(mojom::SurfaceType::DEFAULT);
+      container_surface_->BindToThread();
+    }
+    container_surface_->SubmitCompositorFrame(
+        std::move(frame), base::Bind(&base::DoNothing));
+  }
+
+  WantToDraw();
+}
+
+void Window::SetIsContainer() {
+  if (!container_) {
+    container_ = true;
+    WantToDraw();
+  }
+}
 
 void Window::SetSharedPropertyInternal(const std::string& name,
                                        const std::vector<uint8_t>* value) {
   if (!WasCreatedByThisClientOrIsRoot(this))
     return;
 
   if (client_) {
     mojo::Array<uint8_t> transport_value(nullptr);
     if (value) {
       transport_value.resize(value->size());
@@ skipping 87 matching lines @@
 
 void Window::LocalSetBounds(const gfx::Rect& old_bounds,
                             const gfx::Rect& new_bounds) {
   // If this client owns the window, then it should be the only one to change
   // the bounds.
   DCHECK(!WasCreatedByThisClient() || old_bounds == bounds_);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
+void Window::LocalSetSurfaceId(const gfx::Size& size,
+                               float device_scale_factor,
+                               const cc::SurfaceId& surface_id,
+                               const cc::SurfaceSequence& surface_sequence) {
+  const cc::SurfaceId& existing_surface_id = surface_info_.surface_id;
+  if (!existing_surface_id.is_null() && existing_surface_id != surface_id) {
+    // If the existing surface ID is non-null, then we should return the
+    // existing SurfaceSequence.
+    if (client_) {
+      client_->SatisfySurfaceSequence(
+          server_id_, surface_info_.surface_sequence);
+    }
+  }
+  surface_info_ = {size, device_scale_factor, surface_id, surface_sequence};
+  if (parent_) {
+    FOR_EACH_OBSERVER(
+        WindowObserver, observers_,
+        OnChildWindowSurfaceCreated(this, size, device_scale_factor, surface_id,
+                                    surface_sequence));
+  }
+}
+
 void Window::LocalSetClientArea(
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   const std::vector<gfx::Rect> old_additional_client_areas =
       additional_client_areas_;
   const gfx::Insets old_client_area = client_area_;
   client_area_ = new_client_area;
   additional_client_areas_ = additional_client_areas;
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowClientAreaChanged(this, old_client_area,
@@ skipping 217 matching lines @@
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace ui