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

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>
@@ skipping 326 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<ui::mojom::WindowDataPtr>& windows) {
+    const std::vector<ui::mojom::WindowDataPtr>& windows) {
   for (const auto& window_data : windows) {
     WindowMus* parent = window_data->parent_id == kInvalidServerId
                             ? nullptr
                             : GetWindowByServerId(window_data->parent_id);
     WindowMus* existing_window = GetWindowByServerId(window_data->window_id);
     if (!existing_window)
       NewWindowFromWindowData(parent, window_data);
     else if (parent)
       parent->AddChildFromServer(existing_window);
   }
 }
 
 std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortMus(
     const ui::mojom::WindowDataPtr& window_data,
     WindowMusType window_mus_type) {
   std::unique_ptr<WindowPortMus> window_port_mus(
       base::MakeUnique<WindowPortMus>(this, window_mus_type));
   window_port_mus->set_server_id(window_data->window_id);
   RegisterWindowMus(window_port_mus.get());
   return window_port_mus;
 }
 
 void WindowTreeClient::SetLocalPropertiesFromServerProperties(
     WindowMus* window,
     const ui::mojom::WindowDataPtr& window_data) {
-  for (auto& pair : window_data->properties) {
-    if (pair.second.is_null()) {
-      window->SetPropertyFromServer(pair.first, nullptr);
-    } else {
-      std::vector<uint8_t> stl_value = pair.second.To<std::vector<uint8_t>>();
-      window->SetPropertyFromServer(pair.first, &stl_value);
-    }
-  }
+  for (auto& pair : window_data->properties)
+    window->SetPropertyFromServer(pair.first, &pair.second);
 }
 
 std::unique_ptr<WindowTreeHostMus> WindowTreeClient::CreateWindowTreeHost(
     WindowMusType window_mus_type,
     const ui::mojom::WindowDataPtr& window_data,
     int64_t display_id) {
   std::unique_ptr<WindowPortMus> window_port =
       CreateWindowPortMus(window_data, window_mus_type);
   roots_.insert(window_port.get());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
@@ skipping 162 matching lines @@
 
 void WindowTreeClient::OnWindowMusCreated(WindowMus* window) {
   if (window->server_id() != kInvalidServerId)
     return;
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
   const bool create_top_level = !window_manager_delegate_ && IsRoot(window);
 
-  mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
+  std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
   std::set<const void*> property_keys =
       window->GetWindow()->GetAllPropertKeys();
   PropertyConverter* property_converter = delegate_->GetPropertyConverter();
   for (const void* key : property_keys) {
     std::string transport_name;
     std::unique_ptr<std::vector<uint8_t>> transport_value;
     if (!property_converter->ConvertPropertyForTransport(
             window->GetWindow(), key, &transport_name, &transport_value)) {
       continue;
     }
     if (!transport_value) {
-      transport_properties[transport_name] = mojo::Array<uint8_t>(nullptr);
+      transport_properties[transport_name] = std::vector<uint8_t>();
     } else {
-      transport_properties[transport_name] =
-          mojo::Array<uint8_t>::From(*transport_value);
+      transport_properties[transport_name] = std::move(*transport_value);
     }
   }
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           window, create_top_level ? ChangeType::NEW_TOP_LEVEL_WINDOW
                                    : ChangeType::NEW_WINDOW));
   if (create_top_level) {
     tree_->NewTopLevelWindow(change_id, window->server_id(),
-                             std::move(transport_properties));
+                             transport_properties);
   } else {
     tree_->NewWindow(change_id, window->server_id(),
                      std::move(transport_properties));
   }
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window) {
   if (focus_synchronizer_->focused_window() == window)
     focus_synchronizer_->OnFocusedWindowDestroyed();
 
@@ skipping 115 matching lines @@
       static_cast<WindowPortPropertyDataMus*>(data.get());
 
   std::string transport_name;
   std::unique_ptr<std::vector<uint8_t>> transport_value;
   if (!delegate_->GetPropertyConverter()->ConvertPropertyForTransport(
           window->GetWindow(), key, &transport_name, &transport_value)) {
     return;
   }
   DCHECK_EQ(transport_name, data_mus->transport_name);
 
-  mojo::Array<uint8_t> transport_value_mojo(nullptr);
-  if (transport_value) {
-    transport_value_mojo.resize(transport_value->size());
-    if (transport_value->size()) {
-      memcpy(&transport_value_mojo.front(), &(transport_value->front()),
-             transport_value->size());
-    }
-  }
+  base::Optional<std::vector<uint8_t>> transport_value_mojo;
+  if (transport_value)
+    transport_value_mojo.emplace(std::move(*transport_value));
+
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<InFlightPropertyChange>(
           window, transport_name, std::move(data_mus->transport_value)));
-  tree_->SetWindowProperty(change_id, window->server_id(),
-                           mojo::String(transport_name),
-                           std::move(transport_value_mojo));
+  tree_->SetWindowProperty(change_id, window->server_id(), transport_name,
+                           transport_value_mojo);
 }
 
 void WindowTreeClient::OnWmMoveLoopCompleted(uint32_t change_id,
                                              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;
@@ skipping 169 matching lines @@
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
     else if (window->GetWindow()->bounds() != bounds)
       SetWindowBoundsFromServer(window, bounds);
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
-  std::map<std::string, std::vector<uint8_t>> properties =
-      data->properties.To<std::map<std::string, std::vector<uint8_t>>>();
-  for (const auto& pair : properties) {
+  for (const auto& pair : data->properties) {
     std::unique_ptr<std::vector<uint8_t>> revert_value(
         base::MakeUnique<std::vector<uint8_t>>(pair.second));
     InFlightPropertyChange property_change(window, pair.first,
                                            std::move(revert_value));
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(property_change);
     if (current_change) {
       current_change->SetRevertValueFrom(property_change);
     } else {
       window->SetPropertyFromServer(pair.first, &pair.second);
@@ skipping 14 matching lines @@
   InFlightBoundsChange new_change(this, window, new_bounds);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   SetWindowBoundsFromServer(window, new_bounds);
 }
 
 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) {
   // TODO: client area.
   // TODO(riajiang): Convert from pixel to DIP. (http://crbug.com/600815)
   /*
   Window* window = GetWindowByServerId(window_id);
   if (window) {
     WindowPrivate(window).LocalSetClientArea(
         new_client_area,
-        new_additional_client_areas.To<std::vector<gfx::Rect>>());
+        new_additional_client_areas);
   }
   */
 }
 
 void WindowTreeClient::OnTransientWindowAdded(uint32_t window_id,
                                               uint32_t transient_window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   WindowMus* transient_window = GetWindowByServerId(transient_window_id);
   // window or transient_window or both may be null if a local delete occurs
   // with an in flight add from the server.
   if (window && transient_window)
     window->AddTransientChildFromServer(transient_window);
 }
 
 void WindowTreeClient::OnTransientWindowRemoved(uint32_t window_id,
                                                 uint32_t transient_window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   WindowMus* transient_window = GetWindowByServerId(transient_window_id);
   // 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)
     window->RemoveTransientChildFromServer(transient_window);
 }
 
 void WindowTreeClient::OnWindowHierarchyChanged(
     Id window_id,
     Id old_parent_id,
     Id new_parent_id,
-    mojo::Array<ui::mojom::WindowDataPtr> windows) {
+    std::vector<ui::mojom::WindowDataPtr> windows) {
   const bool was_window_known = GetWindowByServerId(window_id) != nullptr;
 
   BuildWindowTree(windows);
 
   // If the window was not known, then BuildWindowTree() will have created it
   // and parented the window.
   if (!was_window_known)
     return;
 
   WindowMus* new_parent = GetWindowByServerId(new_parent_id);
@@ skipping 54 matching lines @@
   // TODO: route to WindowTreeHost.
   /*
   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> transport_data) {
+    const std::string& name,
+    const base::Optional<std::vector<uint8_t>>& transport_data) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   std::unique_ptr<std::vector<uint8_t>> data;
-  if (!transport_data.is_null()) {
-    data = base::MakeUnique<std::vector<uint8_t>>(
-        transport_data.To<std::vector<uint8_t>>());
-  }
+  if (transport_data.has_value())
+    data = base::MakeUnique<std::vector<uint8_t>>(transport_data.value());
+
   InFlightPropertyChange new_change(window, name, std::move(data));
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  if (!transport_data.is_null()) {
-    data = base::MakeUnique<std::vector<uint8_t>>(
-        transport_data.To<std::vector<uint8_t>>());
-  }
-  window->SetPropertyFromServer(name, data.get());
+  window->SetPropertyFromServer(
+      name, transport_data.has_value() ? &transport_data.value() : nullptr);
 }
 
 void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
                                           Id window_id,
                                           std::unique_ptr<ui::Event> event,
                                           bool matches_pointer_watcher) {
   DCHECK(event);
 
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
@@ skipping 90 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;
   window->SetSurfaceIdFromServer(std::move(surface_info));
 }
 
 void WindowTreeClient::OnDragDropStart(
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) {
-  drag_drop_controller_->OnDragDropStart(
-      mime_data.To<std::map<std::string, std::vector<uint8_t>>>());
+    const std::unordered_map<std::string, std::vector<uint8_t>>& mime_data) {
+  drag_drop_controller_->OnDragDropStart(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) {
   callback.Run(drag_drop_controller_->OnDragEnter(
       GetWindowByServerId(window_id), key_state, position, effect_bitmask));
 }
@@ skipping 118 matching lines @@
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       result = bounds == transit_bounds;
       window->SetBoundsFromServer(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) {
   WindowMus* 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->GetWindow(),
                                                        name, &data);
     if (result) {
       delegate_->GetPropertyConverter()->SetPropertyFromTransportValue(
           window->GetWindow(), 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, WindowMus::Get(window)->server_id());
   }
 }
 
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
@@ skipping 171 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