WIP: Propagate SurfaceID up window tree hierarchy

services/ui/public/cpp/window.h

 // 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.
 
 #ifndef SERVICES_UI_PUBLIC_CPP_WINDOW_H_
 #define SERVICES_UI_PUBLIC_CPP_WINDOW_H_
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
+#include "base/timer/timer.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "services/shell/public/interfaces/interface_provider.mojom.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/mus_constants.mojom.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gfx {
 class Size;
@@ skipping 36 matching lines @@
   // from other connections (except the roots), Destroy() does nothing. If the
   // destruction is allowed observers are notified and the Window is
   // immediately deleted.
   void Destroy();
 
   // Returns true if this client created and owns this window.
   bool WasCreatedByThisClient() const;
 
   WindowTreeClient* window_tree() { return client_; }
 
+  void SetIsContainer();
+
   // The local_id is provided for client code. The local_id is not set or
   // manipulated by mus. The default value is -1.
   void set_local_id(int id) { local_id_ = id; }
   int local_id() const { return local_id_; }
 
   int64_t display_id() const { return display_id_; }
 
   // Geometric disposition relative to parent window.
   const gfx::Rect& bounds() const { return bounds_; }
   void SetBounds(const gfx::Rect& bounds);
@@ skipping 177 matching lines @@
 
   // Tells the window manager to abort any current move initiated by
   // PerformWindowMove().
   void CancelWindowMove();
 
   // Returns an internal name, set by a client app when it creates a window.
   std::string GetName() const;
 
  protected:
   // This class is subclassed only by test classes that provide a public ctor.
-  Window();
+  Window(bool container = false);
   ~Window();
 
  private:
   friend class WindowPrivate;
   friend class WindowTreeClient;
   friend class WindowTreeClientPrivate;
 
-  Window(WindowTreeClient* client, Id id);
+  Window(WindowTreeClient* client, Id id, bool container = false);
+
+  void WantToDraw();
+  void Draw();
 
   // Used to identify this Window on the server. Clients can not change this
   // value.
   Id server_id() const { return server_id_; }
 
   // Applies a shared property change locally and forwards to the server. If
   // |data| is null, this property is deleted.
   void SetSharedPropertyInternal(const std::string& name,
                                  const std::vector<uint8_t>* data);
   // Called by the public {Set,Get,Clear}Property functions.
   int64_t SetLocalPropertyInternal(const void* key,
                                    const char* name,
                                    PropertyDeallocator deallocator,
                                    int64_t value,
                                    int64_t default_value);
   int64_t GetLocalPropertyInternal(const void* key,
                                    int64_t default_value) const;
 
   void LocalDestroy();
   void LocalAddChild(Window* child);
   void LocalRemoveChild(Window* child);
   void LocalAddTransientWindow(Window* transient_window);
   void LocalRemoveTransientWindow(Window* transient_window);
   void LocalSetModal();
   // Returns true if the order actually changed.
   bool LocalReorder(Window* relative, mojom::OrderDirection direction);
   void LocalSetBounds(const gfx::Rect& old_bounds, const gfx::Rect& new_bounds);
+  void LocalSetSurfaceId(const gfx::Size& size,
+                         float device_scale_factor,
+                         const cc::SurfaceId& surface_id,
+                         const cc::SurfaceSequence& surface_sequence);
   void LocalSetClientArea(
       const gfx::Insets& new_client_area,
       const std::vector<gfx::Rect>& additional_client_areas);
   void LocalSetParentDrawn(bool drawn);
   void LocalSetDisplay(int64_t display_id);
   void LocalSetVisible(bool visible);
   void LocalSetOpacity(float opacity);
   void LocalSetPredefinedCursor(mojom::Cursor cursor_id);
   void LocalSetSharedProperty(const std::string& name,
                               const std::vector<uint8_t>* data);
@@ skipping 23 matching lines @@
   static bool ReorderImpl(Window* window,
                           Window* relative,
                           mojom::OrderDirection direction,
                           OrderChangedNotifier* notifier);
 
   // Returns a pointer to the stacking target that can be used by
   // RestackTransientDescendants.
   static Window** GetStackingTarget(Window* window);
 
   WindowTreeClient* client_;
+  bool container_ = false;
   Id server_id_;
   int local_id_ = -1;
   Window* parent_;
   Children children_;
 
   Window* stacking_target_;
   Window* transient_parent_;
   Children transient_children_;
 
   bool is_modal_;
@@ skipping 30 matching lines @@
   // Key cannot be used for this purpose because it can be char* or
   // WindowProperty<>.
   struct Value {
     const char* name;
     int64_t value;
     PropertyDeallocator deallocator;
   };
 
   std::map<const void*, Value> prop_map_;
 
+  base::Timer draw_timer_;
+
+  struct SurfaceInfo {
+    gfx::Size size;
+    float device_scale_factor;
+    cc::SurfaceId surface_id;
+    cc::SurfaceSequence surface_sequence;
+  };
+  SurfaceInfo surface_info_;
+  std::unique_ptr<WindowSurface> container_surface_;
+
+  base::WeakPtrFactory<Window> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace ui
 
 #endif  // SERVICES_UI_PUBLIC_CPP_WINDOW_H_