Aura-Mus: Enable Surface Synchronization behind flag

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/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();
+}
+}  // namespace
+
 WindowPortMus::WindowMusChangeDataImpl::WindowMusChangeDataImpl() = default;
 
 WindowPortMus::WindowMusChangeDataImpl::~WindowMusChangeDataImpl() = default;
 
 // static
 WindowMus* WindowMus::Get(Window* window) {
   return WindowPortMus::Get(window);
 }
 
 WindowPortMus::WindowPortMus(WindowTreeClient* client,
@@ skipping 246 matching lines @@
 
 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.
+  UpdatePrimarySurfaceInfo();
 }
 
 const cc::LocalSurfaceId& WindowPortMus::GetOrAllocateLocalSurfaceId(
     const gfx::Size& surface_size) {
   if (last_surface_size_ == surface_size && local_surface_id_.is_valid())
     return local_surface_id_;
 
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
   last_surface_size_ = surface_size;
 
-  // TODO(fsamuel): If surface synchronization is enabled and the FrameSinkId
-  // is available, then immediately embed the SurfaceId. The newly generated
-  // frame by the embedder will block in the display compositor until the
-  // child submits a corresponding CompositorFrame or a deadline hits.
+  // If surface synchronization is enabled and the FrameSinkId is available,
+  // then immediately embed the SurfaceId. The newly generated frame by the
+  // embedder will block in the display compositor until the child submits a
+  // corresponding CompositorFrame or a deadline hits.
+  if (window_tree_client_->enable_surface_synchronization_ &&
+      frame_sink_id_.is_valid()) {
+    UpdatePrimarySurfaceInfo();
+  }
 
   return local_surface_id_;
 }
 
 void WindowPortMus::SetPrimarySurfaceInfo(const cc::SurfaceInfo& surface_info) {
   primary_surface_info_ = surface_info;
-  UpdatePrimarySurfaceInfoInternal();
+  UpdateClientSurfaceEmbedder();
+}
+
+void WindowPortMus::SetFallbackSurfaceInfo(
+    const cc::SurfaceInfo& surface_info) {
+  DCHECK(client_surface_embedder_);
+  client_surface_embedder_->SetFallbackSurfaceInfo(surface_info);
 }
 
 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 128 matching lines @@
     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);
   // We should only embed a client if its visible.
-  UpdatePrimarySurfaceInfoInternal();
+  UpdateClientSurfaceEmbedder();
 }
 
 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 20 matching lines @@
   change_data.property_name =
       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));
 }
 
-void WindowPortMus::UpdatePrimarySurfaceInfoInternal() {
+void WindowPortMus::UpdatePrimarySurfaceInfo() {
+  bool embeds_surface = window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
+                        window_mus_type() == WindowMusType::EMBED_IN_OWNER;
+  if (!embeds_surface)
+    return;
+
+  if (!frame_sink_id_.is_valid() || !local_surface_id_.is_valid())
+    return;
+
+  primary_surface_info_ =
+      cc::SurfaceInfo(cc::SurfaceId(frame_sink_id_, local_surface_id_),
+                      ScaleFactorForDisplay(window_), last_surface_size_);
+
+  UpdateClientSurfaceEmbedder();
+}
+
+void WindowPortMus::UpdateClientSurfaceEmbedder() {
   if (!client_surface_embedder_ && primary_surface_info_.is_valid())
     client_surface_embedder_ = base::MakeUnique<ClientSurfaceEmbedder>(window_);
 
   if (primary_surface_info_.is_valid() && window_->IsVisible())
     client_surface_embedder_->SetPrimarySurfaceInfo(primary_surface_info_);
   else
     client_surface_embedder_.reset();
 }
 
 }  // namespace aura