Mustash: Ensure surfaces submitted to Mus by WM and embedders contain Surfaces with embeded content.

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 "cc/surfaces/surface_reference_factory.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.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_property.h"
 
 namespace aura {
+namespace {
+
+// TODO(mfomitchev, samans): Remove these stub classes once the SurfaceReference
+// work is complete.
+class StubSurfaceReference : public cc::SurfaceReferenceBase {
+ public:
+  StubSurfaceReference(scoped_refptr<const cc::SurfaceReferenceFactory> factory)
+      : cc::SurfaceReferenceBase(factory) {}
+
+  ~StubSurfaceReference() override { Destroy(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StubSurfaceReference);
+};
+
+class StubSurfaceReferenceFactory : public cc::SurfaceReferenceFactory {
+ public:
+  StubSurfaceReferenceFactory() = default;
+
+  // cc::SurfaceReferenceFactory:
+  std::unique_ptr<cc::SurfaceReferenceBase> CreateReference(
+      cc::SurfaceReferenceOwner* owner,
+      const cc::SurfaceId& surface_id) const override {
+    return base::MakeUnique<StubSurfaceReference>(make_scoped_refptr(this));
+  }
+
+ protected:
+  ~StubSurfaceReferenceFactory() override = default;
+
+ private:
+  // cc::SurfaceReferenceFactory:
+  void DestroyReference(cc::SurfaceReferenceBase* surface_ref) const override {}
+
+  DISALLOW_COPY_AND_ASSIGN(StubSurfaceReferenceFactory);
+};
+
+}  // namespace
 
 WindowPortMus::WindowMusChangeDataImpl::WindowMusChangeDataImpl() = default;
 
 WindowPortMus::WindowMusChangeDataImpl::~WindowMusChangeDataImpl() = default;
 
 // static
 WindowMus* WindowMus::Get(Window* window) {
   return WindowPortMus::Get(window);
 }
 
@@ skipping 134 matching lines @@
         break;
     }
   }
   return iter;
 }
 
 PropertyConverter* WindowPortMus::GetPropertyConverter() {
   return window_tree_client_->delegate_->GetPropertyConverter();
 }
 
+void WindowPortMus::UpdateSurfaceLayer(SurfaceInfo* surface_info) {

[sky, 2016/12/16 21:50:29]

const SurfaceInfo?

[mfomitchev, 2016/12/23 00:03:49]

Made it const reference.

+  if (!surface_info)

[sky, 2016/12/16 21:50:29]

When and why would null be passed in?

[mfomitchev, 2016/12/23 00:03:49]

It is called with null from WindowPortMus's destructor. I suppose we could also
do it when the surface is destroyed in low memory situations. I changed the
logic so that we handle null in SetSurfaceIdFromServer, and UpdateSurfaceLayer
is always called with non-null surface_info.

+    return;
+
+  if (!surface_layer_) {
+    surface_layer_ = base::MakeUnique<ui::Layer>(ui::LAYER_TEXTURED);
+    surface_layer_->SetVisible(true);
+    // The frame provided by the parent window->layer() needs to show through
+    // the surface layer.
+    surface_layer_->SetFillsBoundsOpaquely(false);
+
+    clipping_layer_ = base::MakeUnique<ui::Layer>(ui::LAYER_TEXTURED);
+    clipping_layer_->SetFillsBoundsOpaquely(false);
+
+    clipping_layer_->Add(surface_layer_.get());
+    window_->layer()->Add(clipping_layer_.get());
+
+    // Window's layer may contain content from this client (the embedder), e.g.
+    // this is the case with window decorations provided by Window Manager.
+    // This content should appear underneath the content of the embedded client.
+    window_->layer()->StackAtTop(clipping_layer_.get());
+
+    // We can't set this on window's layer, because that would clip the window
+    // shadow.
+    clipping_layer_->SetMasksToBounds(true);
+  }
+
+  // TODO(mfomitchev): Currently the frame size may not match the window size.
+  // In the future the surface id will be created by Ash (and used with the
+  // surface layer) when the window resize happens, which will ensure that the
+  // surface size matches the window size (unless a timeout occurs).
+  gfx::Size frame_size = surface_info->frame_size;
+  surface_layer_->SetBounds(
+      gfx::Rect(0, 0, frame_size.width(), frame_size.height()));
+  // Clip to window bounds.
+  clipping_layer_->SetBounds(
+      gfx::Rect(0, 0, window_->bounds().width(), window_->bounds().height()));
+
+  // TODO(mfomitchev, riajiang): Hopefully this is fixed after
+  // https://codereview.chromium.org/2547243002/ lands
+  float scale_factor = surface_info->device_scale_factor;
+  scale_factor = scale_factor ? scale_factor : 1;
+
+  // TODO(mfomitchev, samans): Get rid of Aura's SurfaceInfo.
+  cc::SurfaceInfo cc_surface_info(surface_info->surface_id, scale_factor,
+                                  frame_size);
+
+  surface_layer_->SetShowSurface(
+      cc_surface_info, make_scoped_refptr(new StubSurfaceReferenceFactory));
+}
+
 Window* WindowPortMus::GetWindow() {
   return window_;
 }
 
 void WindowPortMus::AddChildFromServer(WindowMus* window) {
   ServerChangeData data;
   data.child_id = window->server_id();
   ScopedServerChange change(this, ServerChangeType::ADD, data);
   window_->AddChild(window->GetWindow());
 }
@@ skipping 65 matching lines @@
   if (surface_info_) {
     const cc::SurfaceId& existing_surface_id = surface_info_->surface_id;
     cc::SurfaceId new_surface_id =
         surface_info ? surface_info->surface_id : cc::SurfaceId();
     if (existing_surface_id.is_valid() &&
         existing_surface_id != new_surface_id) {
       // TODO(kylechar): Start return reference here?
     }
   }
   WindowPortMus* parent = Get(window_->parent());
+  // TODO(mfomitchev): This is unused. We probably don't need this.
   if (parent && parent->surface_id_handler_) {
     parent->surface_id_handler_->OnChildWindowSurfaceChanged(window_,
                                                              &surface_info);
   }
+
+  // The fact that SetSurfaceIdFromServer was called means that this window
+  // corresponds to an embedded client. Update the surface layer dedicated to
+  // holding the client's content.
+  UpdateSurfaceLayer(surface_info.get());
+
   surface_info_ = std::move(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>(
@@ skipping 153 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, std::move(data));
 }
 
 }  // namespace aura