WIP: Surface Synchronization System

services/ui/ws/server_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_WS_SERVER_WINDOW_H_
 #define SERVICES_UI_WS_SERVER_WINDOW_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 33 matching lines @@
 // parent and the window is deleted the deleted window is implicitly removed
 // from the parent.
 class ServerWindow {
  public:
   using Properties = std::map<std::string, std::vector<uint8_t>>;
   using Windows = std::vector<ServerWindow*>;
 
   ServerWindow(ServerWindowDelegate* delegate, const WindowId& id);
   ServerWindow(ServerWindowDelegate* delegate,
                const WindowId& id,
-               const Properties& properties);
+               const Properties& properties,
+               const cc::LocalFrameId& local_frame_id);
   ~ServerWindow();
 
   void AddObserver(ServerWindowObserver* observer);
   void RemoveObserver(ServerWindowObserver* observer);
   bool HasObserver(ServerWindowObserver* observer);
 
   // Creates a new CompositorFrameSink of the specified type, replacing the
   // existing.
   void CreateDisplayCompositorFrameSink(
       gfx::AcceleratedWidget widget,
       cc::mojom::MojoCompositorFrameSinkAssociatedRequest sink_request,
       cc::mojom::MojoCompositorFrameSinkClientPtr client,
       cc::mojom::DisplayPrivateAssociatedRequest display_request);
 
   void CreateOffscreenCompositorFrameSink(
       cc::mojom::MojoCompositorFrameSinkRequest request,
       cc::mojom::MojoCompositorFrameSinkClientPtr client);
 
   const WindowId& id() const { return id_; }
 
   void Add(ServerWindow* child);
   void Remove(ServerWindow* child);
   void Reorder(ServerWindow* relative, mojom::OrderDirection diretion);
   void StackChildAtBottom(ServerWindow* child);
   void StackChildAtTop(ServerWindow* child);
 
   const gfx::Rect& bounds() const { return bounds_; }
   // Sets the bounds. If the size changes this implicitly resets the client
   // area to fill the whole bounds.
-  void SetBounds(const gfx::Rect& bounds);
+  void SetBounds(const gfx::Rect& bounds,
+                 const cc::LocalFrameId& local_frame_id);
 
   const std::vector<gfx::Rect>& additional_client_areas() const {
     return additional_client_areas_;
   }
   const gfx::Insets& client_area() const { return client_area_; }
   void SetClientArea(const gfx::Insets& insets,
                      const std::vector<gfx::Rect>& additional_client_areas);
 
   const gfx::Rect* hit_test_mask() const { return hit_test_mask_.get(); }
   void SetHitTestMask(const gfx::Rect& mask);
@@ skipping 65 matching lines @@
   const ui::TextInputState& text_input_state() const {
     return text_input_state_;
   }
 
   void set_can_focus(bool can_focus) { can_focus_ = can_focus; }
   bool can_focus() const { return can_focus_; }
 
   void set_can_accept_events(bool value) { can_accept_events_ = value; }
   bool can_accept_events() const { return can_accept_events_; }
 
+  const cc::LocalFrameId& local_frame_id() const { return local_frame_id_; }
+
   // Returns true if this window is attached to a root and all ancestors are
   // visible.
   bool IsDrawn() const;
 
   const gfx::Insets& extended_hit_test_region() const {
     return extended_hit_test_region_;
   }
   void set_extended_hit_test_region(const gfx::Insets& insets) {
     extended_hit_test_region_ = insets;
   }
@@ skipping 37 matching lines @@
   static void ReorderImpl(ServerWindow* window,
                           ServerWindow* relative,
                           mojom::OrderDirection diretion);
 
   // Returns a pointer to the stacking target that can be used by
   // RestackTransientDescendants.
   static ServerWindow** GetStackingTarget(ServerWindow* window);
 
   ServerWindowDelegate* delegate_;
   const WindowId id_;
+  cc::LocalFrameId local_frame_id_;
   ServerWindow* parent_;
   Windows children_;
 
   // Transient window management.
   // If non-null we're actively restacking transient as the result of a
   // transient ancestor changing.
   ServerWindow* stacking_target_;
   ServerWindow* transient_parent_;
   Windows transient_children_;
 
@@ skipping 30 matching lines @@
 
   base::ObserverList<ServerWindowObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerWindow);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_SERVER_WINDOW_H_