Mojo C++ bindings: switch services/ui/public/interfaces mojom target to use STL types.

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "mojo/public/cpp/bindings/stl_converters.h"
 #include "services/ui/ws/default_access_policy.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/event_matcher.h"
 #include "services/ui/ws/focus_controller.h"
 #include "services/ui/ws/operation.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_observer.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/display/display.h"
 #include "ui/platform_window/mojo/ime_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
-using mojo::Array;
 using mojo::InterfaceRequest;
-using mojo::String;
 
 namespace ui {
 namespace ws {
 
 class TargetedEvent : public ServerWindowObserver {
  public:
   TargetedEvent(ServerWindow* target, const ui::Event& event)
       : target_(target), event_(ui::Event::Clone(event)) {
     target_->AddObserver(this);
   }
@@ skipping 519 matching lines @@
     const std::string& name,
     const std::vector<uint8_t>* new_data,
     bool originated_change) {
   if (originated_change)
     return;
 
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id))
     return;
 
-  Array<uint8_t> data(nullptr);
+  base::Optional<std::vector<uint8_t>> data;
   if (new_data)
-    data = Array<uint8_t>::From(*new_data);
+    data.emplace(*new_data);
 
-  client()->OnWindowSharedPropertyChanged(client_window_id.id, String(name),
-                                          std::move(data));
+  client()->OnWindowSharedPropertyChanged(client_window_id.id, name, data);
 }
 
 void WindowTree::ProcessWindowHierarchyChanged(const ServerWindow* window,
                                                const ServerWindow* new_parent,
                                                const ServerWindow* old_parent,
                                                bool originated_change) {
   const bool knows_new = new_parent && IsWindowKnown(new_parent);
   if (originated_change || (window_server_->current_operation_type() ==
                             OperationType::DELETE_WINDOW) ||
       (window_server_->current_operation_type() == OperationType::EMBED) ||
@@ skipping 384 matching lines @@
     if (owning_tree) {
       DCHECK(owning_tree && owning_tree != this);
       owning_tree->client()->OnEmbeddedAppDisconnected(
           owning_tree->ClientWindowIdForWindow(window).id);
     }
 
     window->OnEmbeddedAppDisconnected();
   }
 }
 
-Array<mojom::WindowDataPtr> WindowTree::WindowsToWindowDatas(
+std::vector<mojom::WindowDataPtr> WindowTree::WindowsToWindowDatas(
     const std::vector<const ServerWindow*>& windows) {
-  Array<mojom::WindowDataPtr> array(windows.size());
+  std::vector<mojom::WindowDataPtr> array(windows.size());
   for (size_t i = 0; i < windows.size(); ++i)
     array[i] = WindowToWindowData(windows[i]);
   return array;
 }
 
 mojom::WindowDataPtr WindowTree::WindowToWindowData(
     const ServerWindow* window) {
   DCHECK(IsWindowKnown(window));
   const ServerWindow* parent = window->parent();
   // If the parent isn't known, it means the parent is not visible to us (not
   // in roots), and should not be sent over.
   if (parent && !IsWindowKnown(parent))
     parent = nullptr;
   mojom::WindowDataPtr window_data(mojom::WindowData::New());
   window_data->parent_id =
       parent ? ClientWindowIdForWindow(parent).id : ClientWindowId().id;
   window_data->window_id =
       window ? ClientWindowIdForWindow(window).id : ClientWindowId().id;
   window_data->bounds = window->bounds();
-  window_data->properties =
-      mojo::Map<String, Array<uint8_t>>::From(window->properties());
+  window_data->properties = mojo::MapToUnorderedMap(window->properties());
   window_data->visible = window->visible();
   return window_data;
 }
 
 void WindowTree::GetWindowTreeImpl(
     const ServerWindow* window,
     std::vector<const ServerWindow*>* windows) const {
   DCHECK(window);
 
   if (!access_policy_->CanGetWindowTree(window))
@@ skipping 104 matching lines @@
   if (pointer_watcher_want_moves_ && event.type() == ui::ET_POINTER_MOVED)
     return true;
   return event.type() == ui::ET_POINTER_DOWN ||
          event.type() == ui::ET_POINTER_UP ||
          event.type() == ui::ET_POINTER_WHEEL_CHANGED;
 }
 
 void WindowTree::NewWindow(
     uint32_t change_id,
     Id transport_window_id,
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
+    const base::Optional<std::unordered_map<std::string, std::vector<uint8_t>>>&
+        transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties;
-  if (!transport_properties.is_null()) {
-    properties =
-        transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
-  }
+  if (transport_properties.has_value())
+    properties = mojo::UnorderedMapToMap(transport_properties.value());
+
   client()->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTree::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
+    const std::unordered_map<std::string, std::vector<uint8_t>>&
+        transport_properties) {
   // TODO(sky): rather than DCHECK, have this kill connection.
   DCHECK(!window_manager_internal_);  // Not valid for the windowmanager.
   DCHECK(!waiting_for_top_level_window_info_);
   const ClientWindowId client_window_id(transport_window_id);
   // TODO(sky): need a way for client to provide context to figure out display.
   Display* display = display_manager()->displays().empty()
                          ? nullptr
                          : *(display_manager()->displays().begin());
   // TODO(sky): move checks to accesspolicy.
   WindowManagerDisplayRoot* display_root =
@@ skipping 14 matching lines @@
   binding_->SetIncomingMethodCallProcessingPaused(true);
 
   const uint32_t wm_change_id =
       window_server_->GenerateWindowManagerChangeId(this, change_id);
 
   waiting_for_top_level_window_info_.reset(
       new WaitingForTopLevelWindowInfo(client_window_id, wm_change_id));
 
   display_root->window_manager_state()
       ->window_tree()
-      ->window_manager_internal_->WmCreateTopLevelWindow(
-          wm_change_id, id_, std::move(transport_properties));
+      ->window_manager_internal_->WmCreateTopLevelWindow(wm_change_id, id_,
+                                                         transport_properties);
 }
 
 void WindowTree::DeleteWindow(uint32_t change_id, Id transport_window_id) {
   client()->OnChangeCompleted(
       change_id, DeleteWindow(ClientWindowId(transport_window_id)));
 }
 
 void WindowTree::AddWindow(uint32_t change_id, Id parent_id, Id child_id) {
   client()->OnChangeCompleted(change_id, AddWindow(ClientWindowId(parent_id),
                                                    ClientWindowId(child_id)));
@@ skipping 52 matching lines @@
     success = true;
     Operation op(this, window_server_, OperationType::REORDER_WINDOW);
     window->Reorder(relative_window, direction);
     window_server_->ProcessWindowReorder(window, relative_window, direction);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::GetWindowTree(
     Id window_id,
-    const base::Callback<void(Array<mojom::WindowDataPtr>)>& callback) {
+    const base::Callback<void(std::vector<mojom::WindowDataPtr>)>& callback) {
   std::vector<const ServerWindow*> windows(
       GetWindowTree(ClientWindowId(window_id)));
   callback.Run(WindowsToWindowDatas(windows));
 }
 
 void WindowTree::SetCapture(uint32_t change_id, Id window_id) {
   client()->OnChangeCompleted(change_id, SetCapture(ClientWindowId(window_id)));
 }
 
 void WindowTree::ReleaseCapture(uint32_t change_id, Id window_id) {
@@ skipping 39 matching lines @@
 }
 
 void WindowTree::SetWindowVisibility(uint32_t change_id,
                                      Id transport_window_id,
                                      bool visible) {
   client()->OnChangeCompleted(
       change_id,
       SetWindowVisibility(ClientWindowId(transport_window_id), visible));
 }
 
-void WindowTree::SetWindowProperty(uint32_t change_id,
-                                   Id transport_window_id,
-                                   const mojo::String& name,
-                                   mojo::Array<uint8_t> value) {
+void WindowTree::SetWindowProperty(
+    uint32_t change_id,
+    Id transport_window_id,
+    const std::string& name,
+    const base::Optional<std::vector<uint8_t>>& value) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
     WindowManagerDisplayRoot* display_root =
         GetWindowManagerDisplayRoot(window);
     WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
     wm_tree->window_manager_internal_->WmSetProperty(
-        wm_change_id, wm_tree->ClientWindowIdForWindow(window).id, name,
-        std::move(value));
+        wm_change_id, wm_tree->ClientWindowIdForWindow(window).id, name, value);
     return;
   }
   const bool success = window && access_policy_->CanSetWindowProperties(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_PROPERTY);
-    if (value.is_null()) {
+    if (!value.has_value()) {
       window->SetProperty(name, nullptr);
     } else {
-      std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
-      window->SetProperty(name, &data);
+      window->SetProperty(name, &value.value());
     }
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetWindowOpacity(uint32_t change_id,
                                   Id window_id,
                                   float opacity) {
   client()->OnChangeCompleted(
       change_id, SetWindowOpacity(ClientWindowId(window_id), opacity));
@@ skipping 69 matching lines @@
           std::move(event_queue_.front());
       event_queue_.pop();
       target = targeted_event->target();
       event = targeted_event->TakeEvent();
     } while (!event_queue_.empty() && !GetDisplay(target));
     if (target)
       DispatchInputEventImpl(target, *event);
   }
 }
 
-void WindowTree::SetClientArea(
-    Id transport_window_id,
-    const gfx::Insets& insets,
-    mojo::Array<gfx::Rect> transport_additional_client_areas) {
+void WindowTree::SetClientArea(Id transport_window_id,
+                               const gfx::Insets& insets,
+                               const base::Optional<std::vector<gfx::Rect>>&
+                                   transport_additional_client_areas) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (!window || !access_policy_->CanSetClientArea(window))
     return;
 
-  std::vector<gfx::Rect> additional_client_areas =
-      transport_additional_client_areas.To<std::vector<gfx::Rect>>();
-  window->SetClientArea(insets, additional_client_areas);
+  window->SetClientArea(insets, transport_additional_client_areas.value_or(
+                                    std::vector<gfx::Rect>()));
 }
 
 void WindowTree::SetHitTestMask(Id transport_window_id,
                                 const base::Optional<gfx::Rect>& mask) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (!window || !access_policy_->CanSetHitTestMask(window)) {
     DVLOG(1) << "SetHitTestMask failed";
     return;
   }
@@ skipping 75 matching lines @@
 void WindowTree::GetCursorLocationMemory(
     const GetCursorLocationMemoryCallback& callback) {
   callback.Run(
       window_server_->display_manager()->GetUserDisplayManager(user_id_)->
       GetCursorLocationMemory());
 }
 
 void WindowTree::PerformDragDrop(
     uint32_t change_id,
     Id source_window_id,
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> drag_data,
+    const std::unordered_map<std::string, std::vector<uint8_t>>& drag_data,
     uint32_t drag_operation) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(source_window_id));
   bool success = window && access_policy_->CanInitiateDragLoop(window);
   if (!success || !ShouldRouteToWindowManager(window)) {
     // We need to fail this move loop change, otherwise the client will just be
     // waiting for |change_id|.
     DVLOG(1) << "PerformDragDrop failed (access denied).";
     OnChangeCompleted(change_id, false);
     return;
   }
@@ skipping 15 matching lines @@
   }
 
   // TODO(erg): Dealing with |drag_representation| is hard, so we're going to
   // deal with that later.
 
   // Here, we need to dramatically change how the mouse pointer works. Once
   // we've started a drag drop operation, cursor events don't go to windows as
   // normal.
   WindowManagerState* wms = display_root->window_manager_state();
   window_server_->StartDragLoop(change_id, window, this);
-  wms->SetDragDropSourceWindow(this, window, this, std::move(drag_data),
-                               drag_operation);
+  wms->SetDragDropSourceWindow(
+      this, window, this, mojo::WrapSTLType(mojo::UnorderedMapToMap(drag_data)),
+      drag_operation);
 }
 
 void WindowTree::CancelDragDrop(Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (!window) {
     DVLOG(1) << "CancelDragDrop failed (no window)";
     return;
   }
 
   if (window != window_server_->GetCurrentDragLoopWindow()) {
@@ skipping 284 matching lines @@
   if (!window)
     return nullptr;
   DragTargetConnection* connection = window_server_->GetTreeWithRoot(window);
   if (connection)
     return connection;
   return window_server_->GetTreeWithId(window->id().client_id);
 }
 
 void WindowTree::PerformOnDragDropStart(
     mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) {
-  client()->OnDragDropStart(std::move(mime_data));
+  client()->OnDragDropStart(
+      mojo::MapToUnorderedMap(mojo::UnwrapToSTLType(std::move(mime_data))));
 }
 
 void WindowTree::PerformOnDragEnter(
     const ServerWindow* window,
     uint32_t event_flags,
     const gfx::Point& cursor_offset,
     uint32_t effect_bitmask,
     const base::Callback<void(uint32_t)>& callback) {
   ClientWindowId client_window_id;
   if (!IsWindowKnown(window, &client_window_id)) {
@@ skipping 45 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui