Propagates window type properties during aura-mus window creation

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
+#include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/capture_synchronizer.h"
 #include "ui/aura/mus/drag_drop_controller_mus.h"
 #include "ui/aura/mus/focus_synchronizer.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/property_converter.h"
+#include "ui/aura/mus/property_utils.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tracker.h"
@@ skipping 74 matching lines @@
 }
 
 WindowTreeHostMus* GetWindowTreeHostMus(WindowMus* window) {
   return GetWindowTreeHostMus(window->GetWindow());
 }
 
 bool IsInternalProperty(const void* key) {
   return key == client::kModalKey;
 }
 
+void SetWindowTypeFromProperties(
+    Window* window,
+    const std::unordered_map<std::string, std::vector<uint8_t>>& properties) {
+  auto type_iter =
+      properties.find(ui::mojom::WindowManager::kWindowType_Property);
+  if (type_iter == properties.end())
+    return;
+
+  // TODO: need to validate type! http://crbug.com/654924.
+  ui::mojom::WindowType window_type = static_cast<ui::mojom::WindowType>(
+      mojo::ConvertTo<int32_t>(type_iter->second));
+  SetWindowType(window, window_type);
+}
+
 // Helper function to get the device_scale_factor() of the display::Display
 // with |display_id|.
 float ScaleFactorForDisplay(Window* window) {
   // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after
   // https://codereview.chromium.org/2361283002/ is landed.
   return display::Screen::GetScreen()
       ->GetDisplayNearestWindow(window)
       .device_scale_factor();
 }
 
@@ skipping 261 matching lines @@
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowDataPtr& window_data) {
   // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data, WindowMusType::OTHER));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
+  SetWindowTypeFromProperties(window, window_data->properties);
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
   window_mus->SetBoundsFromServer(window_data->bounds);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data->visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
@@ skipping 317 matching lines @@
                                              bool completed) {
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, completed);
 
   if (change_id == current_wm_move_loop_change_) {
     current_wm_move_loop_change_ = 0;
     current_wm_move_loop_window_id_ = 0;
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// WindowTreeClient, WindowTreeClient implementation:
-
 std::set<Window*> WindowTreeClient::GetRoots() {
   std::set<Window*> roots;
   for (WindowMus* window : roots_)
     roots.insert(window->GetWindow());
   return roots;
 }
 
 gfx::Point WindowTreeClient::GetCursorScreenPoint() {
   // We raced initialization. Return (0, 0).
   if (!cursor_location_memory())
@@ skipping 31 matching lines @@
       base::MakeUnique<InFlightDragChange>(window_mus, ChangeType::MOVE_LOOP));
   // Tell the window manager to take over moving us.
   tree_->PerformWindowMove(current_move_loop_change_, window_mus->server_id(),
                            source, cursor_location);
 }
 
 void WindowTreeClient::CancelWindowMove(Window* window) {
   tree_->CancelWindowMove(WindowMus::Get(window)->server_id());
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// WindowTreeClient, WindowTreeClient implementation:
-
 void WindowTreeClient::AddObserver(WindowTreeClientObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeClient::RemoveObserver(WindowTreeClientObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowTreeClient::SetCanAcceptDrops(Id window_id, bool can_accept_drops) {
   DCHECK(tree_);
@@ skipping 543 matching lines @@
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmCreateTopLevelWindow(
     uint32_t change_id,
     ClientSpecificId requesting_client_id,
     const std::unordered_map<std::string, std::vector<uint8_t>>&
         transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties =
       mojo::UnorderedMapToMap(transport_properties);
-  Window* window =
-      window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
+  ui::mojom::WindowType window_type = ui::mojom::WindowType::UNKNOWN;
+  auto type_iter =
+      properties.find(ui::mojom::WindowManager::kWindowType_Property);
+  if (type_iter != properties.end()) {
+    // TODO: validation! http://crbug.com/654924.
+    window_type = static_cast<ui::mojom::WindowType>(
+        mojo::ConvertTo<int32_t>(type_iter->second));
+  }
+  Window* window = window_manager_delegate_->OnWmCreateTopLevelWindow(
+      window_type, &properties);
   embedded_windows_[requesting_client_id].insert(window);
   if (window_manager_internal_client_) {
     window_manager_internal_client_->OnWmCreatedTopLevelWindow(
         change_id, WindowMus::Get(window)->server_id());
   }
 }
 
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
                                                 bool janky) {
   if (window_manager_delegate_) {
@@ skipping 187 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura