WIP: Surface Synchronization System

services/ui/ws/window_tree.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_WINDOW_TREE_H_
 #define SERVICES_UI_WS_WINDOW_TREE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 149 matching lines @@
   void OnWindowDestroyingTreeImpl(WindowTree* tree);
 
   // Sends updated display information.
   void OnWmDisplayModified(const display::Display& display);
 
   // These functions are synchronous variants of those defined in the mojom. The
   // WindowTree implementations all call into these. See the mojom for details.
   bool SetCapture(const ClientWindowId& client_window_id);
   bool ReleaseCapture(const ClientWindowId& client_window_id);
   bool NewWindow(const ClientWindowId& client_window_id,
-                 const std::map<std::string, std::vector<uint8_t>>& properties);
+                 const std::map<std::string, std::vector<uint8_t>>& properties,
+                 const cc::LocalFrameId& local_frame_id);
   bool AddWindow(const ClientWindowId& parent_id,
                  const ClientWindowId& child_id);
   bool AddTransientWindow(const ClientWindowId& window_id,
                           const ClientWindowId& transient_window_id);
   bool DeleteWindow(const ClientWindowId& window_id);
   bool SetModal(const ClientWindowId& window_id);
   std::vector<const ServerWindow*> GetWindowTree(
       const ClientWindowId& window_id) const;
   bool SetWindowVisibility(const ClientWindowId& window_id, bool visible);
   bool SetWindowOpacity(const ClientWindowId& window_id, float opacity);
@@ skipping 26 matching lines @@
   // Notifies the window manager client so it can update UI for the affected
   // window(s).
   void ClientJankinessChanged(WindowTree* tree);
 
   // The following methods are invoked after the corresponding change has been
   // processed. They do the appropriate bookkeeping and update the client as
   // necessary.
   void ProcessWindowBoundsChanged(const ServerWindow* window,
                                   const gfx::Rect& old_bounds,
                                   const gfx::Rect& new_bounds,
-                                  bool originated_change);
+                                  bool originated_change,
+                                  const cc::LocalFrameId& local_frame_id);
   void ProcessClientAreaChanged(
       const ServerWindow* window,
       const gfx::Insets& new_client_area,
       const std::vector<gfx::Rect>& new_additional_client_areas,
       bool originated_change);
   void ProcessWillChangeWindowHierarchy(const ServerWindow* window,
                                         const ServerWindow* new_parent,
                                         const ServerWindow* old_parent,
                                         bool originated_change);
   void ProcessWindowPropertyChanged(const ServerWindow* window,
@@ skipping 139 matching lines @@
 
   // Calls OnChangeCompleted() on the client.
   void NotifyChangeCompleted(uint32_t change_id,
                              mojom::WindowManagerErrorCode error_code);
 
   // WindowTree:
   void NewWindow(uint32_t change_id,
                  Id transport_window_id,
                  const base::Optional<
                      std::unordered_map<std::string, std::vector<uint8_t>>>&
-                     transport_properties) override;
+                     transport_properties,
+                 const cc::LocalFrameId& local_frame_id) override;
   void NewTopLevelWindow(
       uint32_t change_id,
       Id transport_window_id,
       const std::unordered_map<std::string, std::vector<uint8_t>>&
           transport_properties) override;
   void DeleteWindow(uint32_t change_id, Id transport_window_id) override;
   void AddWindow(uint32_t change_id, Id parent_id, Id child_id) override;
   void RemoveWindowFromParent(uint32_t change_id, Id window_id) override;
   void AddTransientWindow(uint32_t change_id,
                           Id window,
                           Id transient_window) override;
   void RemoveTransientWindowFromParent(uint32_t change_id,
                                        Id transient_window_id) override;
   void SetModal(uint32_t change_id, Id window_id) override;
   void ReorderWindow(uint32_t change_Id,
                      Id window_id,
                      Id relative_window_id,
                      mojom::OrderDirection direction) override;
   void GetWindowTree(
       Id window_id,
       const base::Callback<void(std::vector<mojom::WindowDataPtr>)>& callback)
       override;
   void SetCapture(uint32_t change_id, Id window_id) override;
   void ReleaseCapture(uint32_t change_id, Id window_id) override;
   void StartPointerWatcher(bool want_moves) override;
   void StopPointerWatcher() override;
   void SetWindowBounds(uint32_t change_id,
                        Id window_id,
-                       const gfx::Rect& bounds) override;
+                       const gfx::Rect& bounds,
+                       const cc::LocalFrameId& local_frame_id) override;
   void SetWindowVisibility(uint32_t change_id,
                            Id window_id,
                            bool visible) override;
   void SetWindowProperty(
       uint32_t change_id,
       Id transport_window_id,
       const std::string& name,
       const base::Optional<std::vector<uint8_t>>& value) override;
   void SetWindowOpacity(uint32_t change_id,
                         Id window_id,
@@ skipping 163 matching lines @@
       waiting_for_top_level_window_info_;
   bool embedder_intercepts_events_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTree);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_WINDOW_TREE_H_