WIP: Surface Synchronization System

ui/aura/mus/window_port_mus.cc

 // Copyright 2016 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 "ui/aura/mus/window_port_mus.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/client_surface_embedder.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
+#include "ui/aura/window_tree_host.h"
 #include "ui/base/class_property.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 
 namespace aura {
 
+namespace {
+// Helper function to get the device_scale_factor() of the display::Display
+// nearest to |window|.
+float ScaleFactorForDisplay(Window* window) {
+  return display::Screen::GetScreen()
+      ->GetDisplayNearestWindow(window)
+      .device_scale_factor();
+}
+}
+
 WindowPortMus::WindowMusChangeDataImpl::WindowMusChangeDataImpl() = default;
 
 WindowPortMus::WindowMusChangeDataImpl::~WindowMusChangeDataImpl() = default;
 
 // static
 WindowMus* WindowMus::Get(Window* window) {
   return WindowPortMus::Get(window);
 }
 
 WindowPortMus::WindowPortMus(WindowTreeClient* client,
                              WindowMusType window_mus_type)
     : WindowMus(window_mus_type), window_tree_client_(client) {}
 
 WindowPortMus::~WindowPortMus() {
   if (surface_info_.is_valid())
-    SetSurfaceInfoFromServer(cc::SurfaceInfo());
+    SetPrimarySurfaceInfo(cc::SurfaceInfo());
 
   // DESTROY is only scheduled from DestroyFromServer(), meaning if DESTROY is
   // present then the server originated the change.
   const WindowTreeClient::Origin origin =
       RemoveChangeByTypeAndData(ServerChangeType::DESTROY, ServerChangeData())
           ? WindowTreeClient::Origin::SERVER
           : WindowTreeClient::Origin::CLIENT;
   window_tree_client_->OnWindowMusDestroyed(this, origin);
 }
 
@@ skipping 214 matching lines @@
 void WindowPortMus::SetPropertyFromServer(
     const std::string& property_name,
     const std::vector<uint8_t>* property_data) {
   ServerChangeData data;
   data.property_name = property_name;
   ScopedServerChange change(this, ServerChangeType::PROPERTY, data);
   GetPropertyConverter()->SetPropertyFromTransportValue(window_, property_name,
                                                         property_data);
 }
 
+void WindowPortMus::SetPrimarySurfaceInfo(const cc::SurfaceInfo& surface_info) {
+  // The fact that SetSurfaceIdFromServer was called means that this window
+  // corresponds to an embedded client.
+  if (!client_surface_embedder && window_ && surface_info.is_valid())
+    client_surface_embedder = base::MakeUnique<ClientSurfaceEmbedder>(window_);
+
+  if (surface_info.is_valid() && window_->IsVisible())
+    client_surface_embedder->UpdateSurface(surface_info);
+  else
+    client_surface_embedder.reset();
+
+  surface_info_ = surface_info;
+}
+
+void WindowPortMus::SetFallbackSurfaceInfo(
+    const cc::SurfaceInfo& surface_info) {
+  // The fact that SetSurfaceIdFromServer was called means that this window
+  // corresponds to an embedded client.
+  if (!client_surface_embedder)
+    client_surface_embedder = base::MakeUnique<ClientSurfaceEmbedder>(window_);
+
+  client_surface_embedder->SetFallbackSurfaceInfo(surface_info);
+}
+
 void WindowPortMus::SetFrameSinkIdFromServer(
     const cc::FrameSinkId& frame_sink_id) {
   frame_sink_id_ = frame_sink_id;
   if (!pending_compositor_frame_sink_request_.is_null()) {
     // TOP_LEVEL_IN_WM, and EMBED_IN_OWNER windows should not be requesting
     // CompositorFrameSinks.
     DCHECK_NE(WindowMusType::TOP_LEVEL_IN_WM, window_mus_type());
     DCHECK_NE(WindowMusType::EMBED_IN_OWNER, window_mus_type());
     base::ResetAndReturn(&pending_compositor_frame_sink_request_).Run();
+    return;
   }
   // TODO(fsamuel): If the window type is TOP_LEVEL_IN_WM or EMBED_IN_OWNER then
   // we should check if we have a cc::LocalSurfaeId ready as well. If we do,
   // then we are ready to embed.
+  if ((window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
+       window_mus_type() == WindowMusType::EMBED_IN_OWNER) &&
+      local_surface_id_.is_valid()) {
+    cc::SurfaceInfo surface_info(
+        cc::SurfaceId(frame_sink_id_, local_surface_id_),
+        ScaleFactorForDisplay(window_), window_->bounds().size());
+    SetPrimarySurfaceInfo(surface_info);
+  }
 }
 
-void WindowPortMus::SetSurfaceInfoFromServer(
-    const cc::SurfaceInfo& surface_info) {
-  if (surface_info_.is_valid()) {
-    const cc::SurfaceId& existing_surface_id = surface_info_.id();
-    const cc::SurfaceId& new_surface_id = surface_info.id();
-    if (existing_surface_id.is_valid() &&
-        existing_surface_id != new_surface_id) {
-      // TODO(kylechar): Start return reference here?
-    }
+const cc::LocalSurfaceId& WindowPortMus::GetLocalSurfaceId() {
+  return local_surface_id_;
+}
+
+const cc::LocalSurfaceId& WindowPortMus::AllocateLocalSurfaceIdForSize(
+    const gfx::Size& new_size) {
+  if (last_size_ == new_size && local_surface_id_.is_valid())
+    return local_surface_id_;
+
+  local_surface_id_ = local_surface_id_allocator_.GenerateId();
+  last_size_ = new_size;
+
+  // If we have a valid FrameSinkId and LocalSurfaceId then we can embed
+  // the content of the window now.
+  if (frame_sink_id_.is_valid()) {
+    // TODO(fsamuel): DCHECK That we have the right window type.
+    cc::SurfaceInfo surface_info(
+        cc::SurfaceId(frame_sink_id_, local_surface_id_),
+        ScaleFactorForDisplay(window_), new_size);
+    SetPrimarySurfaceInfo(surface_info);
   }
-
-  // The fact that SetSurfaceIdFromServer was called means that this window
-  // corresponds to an embedded client.
-  if (!client_surface_embedder && surface_info.is_valid())
-    client_surface_embedder = base::MakeUnique<ClientSurfaceEmbedder>(window_);
-
-  if (surface_info.is_valid())
-    client_surface_embedder->UpdateSurface(surface_info);
-  else
-    client_surface_embedder.reset();
-
-  surface_info_ = surface_info;
+  return local_surface_id_;
 }
 
 void WindowPortMus::DestroyFromServer() {
   std::unique_ptr<ScopedServerChange> remove_from_parent_change;
   if (window_->parent()) {
     ServerChangeData data;
     data.child_id = server_id();
     WindowPortMus* parent = Get(window_->parent());
     remove_from_parent_change = base::MakeUnique<ScopedServerChange>(
         parent, ServerChangeType::REMOVE, data);
@@ skipping 123 matching lines @@
                               change_data) == server_changes_.end()) {
     window_tree_client_->OnWindowMusMoveChild(this, current_index, dest_index);
   }
 }
 
 void WindowPortMus::OnVisibilityChanged(bool visible) {
   ServerChangeData change_data;
   change_data.visible = visible;
   if (!RemoveChangeByTypeAndData(ServerChangeType::VISIBLE, change_data))
     window_tree_client_->OnWindowMusSetVisible(this, visible);
+  // Update the ClientSurfaceEmbedder on visibility change.
+  if (surface_info_.is_valid())
+    SetPrimarySurfaceInfo(surface_info_);
 }
 
 void WindowPortMus::OnDidChangeBounds(const gfx::Rect& old_bounds,
                                       const gfx::Rect& new_bounds) {
   ServerChangeData change_data;
   change_data.bounds_in_dip = new_bounds;
   if (!RemoveChangeByTypeAndData(ServerChangeType::BOUNDS, change_data))
     window_tree_client_->OnWindowMusBoundsChanged(this, old_bounds, new_bounds);
 }
 
@@ skipping 21 matching lines @@
       GetPropertyConverter()->GetTransportNameForPropertyKey(key);
   // TODO(sky): investigate to see if we need to compare data. In particular do
   // we ever have a case where changing a property cascades into changing the
   // same property?
   if (!RemoveChangeByTypeAndData(ServerChangeType::PROPERTY, change_data))
     window_tree_client_->OnWindowMusPropertyChanged(this, key, old_value,
                                                     std::move(data));
 }
 
 }  // namespace aura