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.
+  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);
+  }
 }
 
 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()) {
+    DCHECK(window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
+           window_mus_type() == WindowMusType::EMBED_IN_OWNER);
+    cc::SurfaceInfo surface_info(
+        cc::SurfaceId(frame_sink_id_, local_surface_id_),
+        ScaleFactorForDisplay(window_), surface_size);
+    SetPrimarySurfaceInfo(surface_info);
+  }

[sadrul, 2017/03/31 01:26:20]

Can we have a method that does this? e.g.

  void UpdatePrimarySurface() {
    bool embeds_surface =
        window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
        window_mus_type() == WindowMusType::EMBED_IN_OWNER;
    if (!embeds_surface)
      return;
    if (!local_surface_id_.is_valid() || !frame_sink_id_.is_valid())
      return;
    ...
  }

This makes it clear when reading the code that (1) the reason for ignoring the
other window types is that they don't actually embed surface (as opposed to,
say, they embed surface in a different manner, somewhere else), and (2) avoids
some code dup (... although like 3 lines, but I think that still makes it easier
to read)

[Fady Samuel, 2017/03/31 01:57:43]

Done.

 
   return local_surface_id_;
 }
 
 void WindowPortMus::SetPrimarySurfaceInfo(const cc::SurfaceInfo& surface_info) {
   primary_surface_info_ = surface_info;
   UpdatePrimarySurfaceInfoInternal();
 }
 
+void WindowPortMus::SetFallbackSurfaceInfo(
+    const cc::SurfaceInfo& surface_info) {
+  DCHECK(client_surface_embedder_);
+  client_surface_embedder_->SetFallbackSurfaceInfo(surface_info);

[sadrul, 2017/03/31 01:26:20]

What happens if the window is hidden + shown after this fallback surface is set?

[Fady Samuel, 2017/03/31 01:57:43]

The fallback surface is lost (it is no longer referenced by the embedder and may
have been garbage collected since. If the primary surface is available, we will
use it, if not the parent will block on visibility change.

+}
+
 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);
   }
   // NOTE: this can't use ScopedServerChange as |this| is destroyed before the
@@ skipping 178 matching lines @@
   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