Aura-Mus: Implement gutter in the embedder.

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"
@@ skipping 26 matching lines @@
 // 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() {
-  SetPrimarySurfaceInfo(cc::SurfaceInfo());
+  // SetPrimarySurfaceInfo(cc::SurfaceInfo());

[sadrul, 2017/04/07 13:07:33]

Remove

[Fady Samuel, 2017/04/07 15:27:25]

Done.

+  client_surface_embedder_.reset();
 
   // 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 263 matching lines @@
   return local_surface_id_;
 }
 
 void WindowPortMus::SetPrimarySurfaceInfo(const cc::SurfaceInfo& surface_info) {
   primary_surface_info_ = surface_info;
   UpdateClientSurfaceEmbedder();
 }
 
 void WindowPortMus::SetFallbackSurfaceInfo(
     const cc::SurfaceInfo& surface_info) {
-  DCHECK(client_surface_embedder_);
-  client_surface_embedder_->SetFallbackSurfaceInfo(surface_info);
+  fallback_surface_info_ = surface_info;
+  UpdateClientSurfaceEmbedder();
 }
 
 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 127 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);
-  // We should only embed a client if its visible.
-  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);
+  if (client_surface_embedder_)
+    client_surface_embedder_->UpdateSizeAndGutters();
 }
 
 std::unique_ptr<ui::PropertyData> WindowPortMus::OnWillChangeProperty(
     const void* key) {
   // |window_| is null if a property is set on the aura::Window before
   // Window::Init() is called. It's safe to ignore the change in this case as
   // once Window::Init() is called the Window is queried for the current set of
   // properties.
   if (!window_)
     return nullptr;
@@ skipping 29 matching lines @@
     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_);
+  bool embeds_surface = window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
+                        window_mus_type() == WindowMusType::EMBED_IN_OWNER;
+  if (!embeds_surface)
+    return;
 
-  if (primary_surface_info_.is_valid() && window_->IsVisible())
-    client_surface_embedder_->SetPrimarySurfaceInfo(primary_surface_info_);
-  else
-    client_surface_embedder_.reset();
+  if (!client_surface_embedder_) {
+    client_surface_embedder_ = base::MakeUnique<ClientSurfaceEmbedder>(
+        window_, window_tree_client_->normal_client_area_insets_);
+  }
+
+  client_surface_embedder_->SetPrimarySurfaceInfo(primary_surface_info_);
+  client_surface_embedder_->SetFallbackSurfaceInfo(fallback_surface_info_);
 }
 
 }  // namespace aura