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

services/ui/public/cpp/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 "services/ui/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 48 matching lines @@
                           Window* parent,
                           const mojom::WindowDataPtr& window_data) {
   // We don't use the ctor that takes a WindowTreeClient here, since it will
   // call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_client(client);
   private_window.set_server_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
   private_window.set_properties(
-      window_data->properties
-          .To<std::map<std::string, std::vector<uint8_t>>>());
+      mojo::UnorderedMapToMap(window_data->properties));
   client->AddWindow(window);
   private_window.LocalSetBounds(
       gfx::Rect(),
       gfx::ConvertRectToDIP(ScaleFactorForDisplay(window->display_id()),
                             window_data->bounds));
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
   return window;
 }
 
@@ skipping 257 matching lines @@
   tree_->SetWindowVisibility(change_id, server_id(window), visible);
 }
 
 void WindowTreeClient::SetOpacity(Window* window, float opacity) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightOpacityChange>(window, window->opacity()));
   tree_->SetWindowOpacity(change_id, server_id(window), opacity);
 }
 
-void WindowTreeClient::SetProperty(Window* window,
-                                       const std::string& name,
-                                       mojo::Array<uint8_t> data) {
+void WindowTreeClient::SetProperty(
+    Window* window,
+    const std::string& name,
+    const base::Optional<std::vector<uint8_t>>& data) {
   DCHECK(tree_);
 
-  mojo::Array<uint8_t> old_value(nullptr);
+  base::Optional<std::vector<uint8_t>> old_value;
   if (window->HasSharedProperty(name))
-    old_value = mojo::Array<uint8_t>::From(window->properties_[name]);
+    old_value.emplace(window->properties_[name]);
 
-  const uint32_t change_id = ScheduleInFlightChange(
-      base::MakeUnique<InFlightPropertyChange>(window, name, old_value));
-  tree_->SetWindowProperty(change_id, server_id(window), mojo::String(name),
-                           std::move(data));
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<InFlightPropertyChange>(
+          window, name, std::move(old_value)));
+  tree_->SetWindowProperty(change_id, server_id(window), name, data);
 }
 
 void WindowTreeClient::SetWindowTextInputState(
     Id window_id,
     mojo::TextInputStatePtr state) {
   DCHECK(tree_);
   tree_->SetWindowTextInputState(window_id, std::move(state));
 }
 
 void WindowTreeClient::SetImeVisibility(Id window_id,
@@ skipping 127 matching lines @@
     const InFlightChange& change) {
   InFlightChange* existing_change = GetOldestInFlightChangeMatching(change);
   if (!existing_change)
     return false;
 
   existing_change->SetRevertValueFrom(change);
   return true;
 }
 
 void WindowTreeClient::BuildWindowTree(
-    const mojo::Array<mojom::WindowDataPtr>& windows,
+    const std::vector<mojom::WindowDataPtr>& windows,
     Window* initial_parent) {
   for (const auto& window_data : windows) {
     Window* parent = window_data->parent_id == 0
                          ? nullptr
                          : GetWindowByServerId(window_data->parent_id);
     Window* existing_window = GetWindowByServerId(window_data->window_id);
     if (!existing_window)
       AddWindowToClient(this, parent, window_data);
     else if (parent)
       WindowPrivate(parent).LocalAddChild(existing_window);
   }
 }
 
 Window* WindowTreeClient::NewWindowImpl(
     NewWindowType type,
     const Window::SharedProperties* properties) {
   DCHECK(tree_);
   Window* window =
       new Window(this, MakeTransportId(client_id_, next_window_id_++));
   if (properties)
     window->properties_ = *properties;
   AddWindow(window);
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           window, type == NewWindowType::CHILD
                       ? ChangeType::NEW_WINDOW
                       : ChangeType::NEW_TOP_LEVEL_WINDOW));
-  mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
-  if (properties) {
-    transport_properties =
-        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(*properties);
-  }
+  std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
+  if (properties)
+    transport_properties = mojo::MapToUnorderedMap(*properties);
+
   if (type == NewWindowType::CHILD) {
     tree_->NewWindow(change_id, server_id(window),
                      std::move(transport_properties));
   } else {
     roots_.insert(window);
     tree_->NewTopLevelWindow(change_id, server_id(window),
-                             std::move(transport_properties));
+                             transport_properties);
   }
   return window;
 }
 
 void WindowTreeClient::SetWindowTree(mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
   tree_ = tree_ptr_.get();
 
   tree_ptr_->GetCursorLocationMemory(
       base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
@@ skipping 117 matching lines @@
     const std::map<std::string, std::vector<uint8_t>>& drag_data,
     int drag_operation,
     const gfx::Point& cursor_location,
     const SkBitmap& bitmap,
     const base::Callback<void(bool, uint32_t)>& callback) {
   DCHECK(!current_drag_state_);
 
   // TODO(erg): Pass |cursor_location| and |bitmap| in PerformDragDrop() when
   // we start showing an image representation of the drag under the cursor.
 
+  auto unordered_drag_data = mojo::MapToUnorderedMap(drag_data);
+
   if (window->drop_target()) {
     // To minimize the number of round trips, copy the drag drop data to our
     // handler here, instead of forcing mus to send this same data back.
-    OnDragDropStart(
-        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data));
+    OnDragDropStart(unordered_drag_data);
   }
 
   uint32_t current_drag_change = ScheduleInFlightChange(
       base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
   current_drag_state_.reset(new CurrentDragState{
       current_drag_change, ui::mojom::kDropEffectNone, callback});
 
-  tree_->PerformDragDrop(
-      current_drag_change, window->server_id(),
-      mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data),
-      drag_operation);
+  tree_->PerformDragDrop(current_drag_change, window->server_id(),
+                         unordered_drag_data, drag_operation);
 }
 
 void WindowTreeClient::CancelDragDrop(Window* window) {
   // Server will clean up drag and fail the in-flight change.
   tree_->CancelDragDrop(window->server_id());
 }
 
 void WindowTreeClient::PerformWindowMove(
     Window* window,
     ui::mojom::MoveLoopSource source,
@@ skipping 168 matching lines @@
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
     else if (window->bounds() != bounds)
       window_private.LocalSetBounds(window->bounds(), bounds);
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
   Window::SharedProperties properties =
-      data->properties.To<std::map<std::string, std::vector<uint8_t>>>();
+      mojo::UnorderedMapToMap(data->properties);
   for (const auto& pair : properties) {
-    InFlightPropertyChange property_change(
-        window, pair.first, mojo::Array<uint8_t>::From(pair.second));
+    InFlightPropertyChange property_change(window, pair.first, pair.second);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(property_change);
     if (current_change)
       current_change->SetRevertValueFrom(property_change);
     else
       window_private.LocalSetSharedProperty(pair.first, &(pair.second));
   }
 
   // Top level windows should not have a parent.
   DCHECK_EQ(0u, data->parent_id);
@@ skipping 14 matching lines @@
 
   InFlightBoundsChange new_change(window, new_bounds_in_dip);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
   WindowPrivate(window).LocalSetBounds(old_bounds_in_dip, new_bounds_in_dip);
 }
 
 void WindowTreeClient::OnClientAreaChanged(
     uint32_t window_id,
     const gfx::Insets& new_client_area,
-    mojo::Array<gfx::Rect> new_additional_client_areas) {
+    const std::vector<gfx::Rect>& new_additional_client_areas) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
     float device_scale_factor = ScaleFactorForDisplay(window->display_id());
     std::vector<gfx::Rect> new_additional_client_areas_in_dip;
     for (const gfx::Rect& area : new_additional_client_areas) {
       new_additional_client_areas_in_dip.push_back(
           gfx::ConvertRectToDIP(device_scale_factor, area));
     }
     WindowPrivate(window).LocalSetClientArea(
         gfx::ConvertInsetsToDIP(device_scale_factor, new_client_area),
@@ skipping 20 matching lines @@
   // window or transient_window or both may be null if a local delete occurs
   // with an in flight delete from the server.
   if (window && transient_window)
     WindowPrivate(window).LocalRemoveTransientWindow(transient_window);
 }
 
 void WindowTreeClient::OnWindowHierarchyChanged(
     Id window_id,
     Id old_parent_id,
     Id new_parent_id,
-    mojo::Array<mojom::WindowDataPtr> windows) {
+    std::vector<mojom::WindowDataPtr> windows) {
   Window* initial_parent =
       windows.size() ? GetWindowByServerId(windows[0]->parent_id) : NULL;
 
   const bool was_window_known = GetWindowByServerId(window_id) != nullptr;
 
   BuildWindowTree(windows, initial_parent);
 
   // If the window was not known, then BuildWindowTree() will have created it
   // and parented the window.
   if (!was_window_known)
@@ skipping 56 matching lines @@
 
 void WindowTreeClient::OnWindowParentDrawnStateChanged(Id window_id,
                                                            bool drawn) {
   Window* window = GetWindowByServerId(window_id);
   if (window)
     WindowPrivate(window).LocalSetParentDrawn(drawn);
 }
 
 void WindowTreeClient::OnWindowSharedPropertyChanged(
     Id window_id,
-    const mojo::String& name,
-    mojo::Array<uint8_t> new_data) {
+    const std::string& name,
+    const base::Optional<std::vector<uint8_t>>& new_data) {
   Window* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightPropertyChange new_change(window, name, new_data);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  WindowPrivate(window).LocalSetSharedProperty(name, std::move(new_data));
+  WindowPrivate(window).LocalSetSharedProperty(name, new_data);
 }
 
 void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
                                           Id window_id,
                                           std::unique_ptr<ui::Event> event,
                                           bool matches_pointer_watcher) {
   DCHECK(event);
   Window* window = GetWindowByServerId(window_id);  // May be null.
 
   if (matches_pointer_watcher && has_pointer_watcher_) {
@@ skipping 77 matching lines @@
   if (!window)
     return;
   std::unique_ptr<SurfaceInfo> surface_info(base::MakeUnique<SurfaceInfo>());
   surface_info->surface_id = surface_id;
   surface_info->frame_size = frame_size;
   surface_info->device_scale_factor = device_scale_factor;
   WindowPrivate(window).LocalSetSurfaceId(std::move(surface_info));
 }
 
 void WindowTreeClient::OnDragDropStart(
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) {
-  mime_drag_data_ = std::move(mime_data);
+    const std::unordered_map<std::string, std::vector<uint8_t>>& mime_data) {
+  mime_drag_data_ = mojo::UnorderedMapToMap(mime_data);
 }
 
 void WindowTreeClient::OnDragEnter(Id window_id,
                                    uint32_t key_state,
                                    const gfx::Point& position,
                                    uint32_t effect_bitmask,
                                    const OnDragEnterCallback& callback) {
   Window* window = GetWindowByServerId(window_id);
   if (!window || !window->drop_target()) {
     callback.Run(mojom::kDropEffectNone);
     return;
   }
 
   if (!base::ContainsKey(drag_entered_windows_, window_id)) {
-    window->drop_target()->OnDragDropStart(
-        mime_drag_data_.To<std::map<std::string, std::vector<uint8_t>>>());
+    window->drop_target()->OnDragDropStart(mime_drag_data_);
     drag_entered_windows_.insert(window_id);
   }
 
   uint32_t ret =
       window->drop_target()->OnDragEnter(key_state, position, effect_bitmask);
   callback.Run(ret);
 }
 
 void WindowTreeClient::OnDragOver(Id window_id,
                                   uint32_t key_state,
@@ skipping 143 matching lines @@
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       result = bounds == transit_bounds_in_dip;
       window->SetBounds(bounds);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
-void WindowTreeClient::WmSetProperty(uint32_t change_id,
-                                     Id window_id,
-                                     const mojo::String& name,
-                                     mojo::Array<uint8_t> transit_data) {
+void WindowTreeClient::WmSetProperty(
+    uint32_t change_id,
+    Id window_id,
+    const std::string& name,
+    const base::Optional<std::vector<uint8_t>>& transit_data) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
     std::unique_ptr<std::vector<uint8_t>> data;
-    if (!transit_data.is_null()) {
-      data.reset(
-          new std::vector<uint8_t>(transit_data.To<std::vector<uint8_t>>()));
-    }
+    if (transit_data.has_value())
+      data.reset(new std::vector<uint8_t>(transit_data.value()));
+
     result = window_manager_delegate_->OnWmSetProperty(window, name, &data);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       window->SetSharedPropertyInternal(name, data.get());
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmCreateTopLevelWindow(
     uint32_t change_id,
     ClientSpecificId requesting_client_id,
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
+    const std::unordered_map<std::string, std::vector<uint8_t>>&
+        transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties =
-      transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
+      mojo::UnorderedMapToMap(transport_properties);
   Window* window =
       window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
   embedded_windows_[requesting_client_id].insert(window);
   if (window_manager_internal_client_) {
     window_manager_internal_client_->OnWmCreatedTopLevelWindow(
         change_id, server_id(window));
   }
 }
 
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
@@ skipping 100 matching lines @@
     // TODO(riajiang): Figure out if |offset| needs to be converted.
     // (http://crbugs.com/646932)
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(),
         gfx::ConvertInsetsToDIP(ScaleFactorForDisplay(window->display_id()),
                                 hit_area));
   }
 }
 
 }  // namespace ui