mash: wires up shadows for mash

ui/views/mus/mus_client.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/views/mus/mus_client.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread.h"
 #include "components/discardable_memory/client/client_discardable_shared_memory_manager.h"
@@ skipping 15 matching lines @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/views/mus/aura_init.h"
 #include "ui/views/mus/clipboard_mus.h"
 #include "ui/views/mus/desktop_window_tree_host_mus.h"
 #include "ui/views/mus/mus_property_mirror.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
 #include "ui/views/mus/screen_mus.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
+#include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/wm_state.h"
 
 // Widget::InitParams::Type must match that of ui::mojom::WindowType.
 #define WINDOW_TYPES_MATCH(NAME)                                      \
   static_assert(                                                      \
       static_cast<int32_t>(views::Widget::InitParams::TYPE_##NAME) == \
           static_cast<int32_t>(ui::mojom::WindowType::NAME),          \
       "Window type constants must match")
 
 WINDOW_TYPES_MATCH(WINDOW);
@@ skipping 25 matching lines @@
   if (!io_task_runner) {
     io_thread_ = base::MakeUnique<base::Thread>("IOThread");
     base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
     thread_options.priority = base::ThreadPriority::NORMAL;
     CHECK(io_thread_->StartWithOptions(thread_options));
     io_task_runner = io_thread_->task_runner();
   }
 
   // TODO(msw): Avoid this... use some default value? Allow clients to extend?
   property_converter_ = base::MakeUnique<aura::PropertyConverter>();
+  property_converter_->RegisterProperty(
+      wm::kShadowElevationKey,
+      ui::mojom::WindowManager::kShadowElevation_Property);
 
   if (create_wm_state)
     wm_state_ = base::MakeUnique<wm::WMState>();
 
   discardable_memory::mojom::DiscardableSharedMemoryManagerPtr manager_ptr;
   connector->BindInterface(ui::mojom::kServiceName, &manager_ptr);
 
   discardable_shared_memory_manager_ = base::MakeUnique<
       discardable_memory::ClientDiscardableSharedMemoryManager>(
       std::move(manager_ptr), io_task_runner);
@@ skipping 46 matching lines @@
   // TYPE_CONTROL and child widgets require a NativeWidgetAura.
   return init_params.type != Widget::InitParams::TYPE_CONTROL &&
          !init_params.child;
 }
 
 // static
 std::map<std::string, std::vector<uint8_t>>
 MusClient::ConfigurePropertiesFromParams(
     const Widget::InitParams& init_params) {
   using PrimitiveType = aura::PropertyConverter::PrimitiveType;
-  std::map<std::string, std::vector<uint8_t>> properties =
-      init_params.mus_properties;
+  using WindowManager = ui::mojom::WindowManager;
+  using TransportType = std::vector<uint8_t>;
+
+  std::map<std::string, TransportType> properties = init_params.mus_properties;
 
   // Widget::InitParams::Type matches ui::mojom::WindowType.
-  properties[ui::mojom::WindowManager::kWindowType_InitProperty] =
-      mojo::ConvertTo<std::vector<uint8_t>>(
-          static_cast<int32_t>(init_params.type));
+  properties[WindowManager::kWindowType_InitProperty] =
+      mojo::ConvertTo<TransportType>(static_cast<int32_t>(init_params.type));
 
-  properties[ui::mojom::WindowManager::kFocusable_InitProperty] =
-      mojo::ConvertTo<std::vector<uint8_t>>(init_params.CanActivate());
+  properties[WindowManager::kFocusable_InitProperty] =
+      mojo::ConvertTo<TransportType>(init_params.CanActivate());
 
   if (!init_params.bounds.IsEmpty()) {
-    properties[ui::mojom::WindowManager::kBounds_InitProperty] =
-        mojo::ConvertTo<std::vector<uint8_t>>(init_params.bounds);
+    properties[WindowManager::kBounds_InitProperty] =
+        mojo::ConvertTo<TransportType>(init_params.bounds);
   }
 
   if (!init_params.name.empty()) {
-    properties[ui::mojom::WindowManager::kName_Property] =
-        mojo::ConvertTo<std::vector<uint8_t>>(init_params.name);
+    properties[WindowManager::kName_Property] =
+        mojo::ConvertTo<TransportType>(init_params.name);
   }
 
-  properties[ui::mojom::WindowManager::kAlwaysOnTop_Property] =
-      mojo::ConvertTo<std::vector<uint8_t>>(
+  properties[WindowManager::kAlwaysOnTop_Property] =
+      mojo::ConvertTo<TransportType>(
           static_cast<PrimitiveType>(init_params.keep_on_top));
 
+  properties[WindowManager::kRemoveStandardFrame_InitProperty] =
+      mojo::ConvertTo<TransportType>(init_params.remove_standard_frame);
+
   if (!Widget::RequiresNonClientView(init_params.type))
     return properties;
 
   if (init_params.delegate) {
-    if (properties.count(ui::mojom::WindowManager::kResizeBehavior_Property) ==
-        0) {
-      properties[ui::mojom::WindowManager::kResizeBehavior_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(static_cast<PrimitiveType>(
+    if (properties.count(WindowManager::kResizeBehavior_Property) == 0) {
+      properties[WindowManager::kResizeBehavior_Property] =
+          mojo::ConvertTo<TransportType>(static_cast<PrimitiveType>(
               init_params.delegate->GetResizeBehavior()));
     }
 
     // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
     gfx::ImageSkia app_icon = init_params.delegate->GetWindowAppIcon();
     SkBitmap app_bitmap = app_icon.GetRepresentation(1.f).sk_bitmap();
     if (!app_bitmap.isNull()) {
-      properties[ui::mojom::WindowManager::kAppIcon_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(app_bitmap);
+      properties[WindowManager::kAppIcon_Property] =
+          mojo::ConvertTo<TransportType>(app_bitmap);
     }
     // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
     gfx::ImageSkia window_icon = init_params.delegate->GetWindowIcon();
     SkBitmap window_bitmap = window_icon.GetRepresentation(1.f).sk_bitmap();
     if (!window_bitmap.isNull()) {
-      properties[ui::mojom::WindowManager::kWindowIcon_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(window_bitmap);
+      properties[WindowManager::kWindowIcon_Property] =
+          mojo::ConvertTo<TransportType>(window_bitmap);
     }
   }
 
   return properties;
 }
 
 NativeWidget* MusClient::CreateNativeWidget(
     const Widget::InitParams& init_params,
     internal::NativeWidgetDelegate* delegate) {
   if (!ShouldCreateDesktopNativeWidgetAura(init_params)) {
@@ skipping 81 matching lines @@
       return root->GetTopWindowContainingPoint(relative_point);
   }
   return nullptr;
 }
 
 std::unique_ptr<OSExchangeData::Provider> MusClient::BuildProvider() {
   return base::MakeUnique<aura::OSExchangeDataProviderMus>();
 }
 
 }  // namespace views