Roll Fuchsia SDK from 497d151e24e6 to 3b3374c29e5c

This CL includes sergeyu@'s fixes for compatibility with new FIDL, from
https://chromium-review.googlesource.com/c/chromium/src/+/1391849

In future FIDL will use std::string and std::vector for non-nullable
strings and vectors. This change updates files that depend on FIDL
to use the new types.

The AutoRoll server is located here: https://autoroll.skia.org/r/fuchsia-sdk-chromium-autoroll

Documentation for the AutoRoller is here:
https://skia.googlesource.com/buildbot/+/master/autoroll/README.md

If the roll is causing failures, please contact the current sheriff, who should
be CC'd on the roll, and stop the roller if necessary.


CQ_INCLUDE_TRYBOTS=luci.chromium.try:fuchsia-arm64-cast;luci.chromium.try:fuchsia-x64-cast
TBR=sergeyu

Change-Id: Ib8565264e2820d86fda0e1a755e18f78addf2342
Reviewed-on: https://chromium-review.googlesource.com/c/1408352
Reviewed-by: Wez <wez@chromium.org>
Commit-Queue: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#622334}

build/fuchsia/fidlgen_js/test/fidlgen_js_unittest.cc

@@ -226,19 +226,14 @@ class TestolaImpl : public fidljstest::Testola {
 
   void PrintInt(int32_t number) override { received_int_ = number; }
 
-  void PrintMsg(fidl::StringPtr message) override {
+  void PrintMsg(std::string message) override { received_msg_ = message; }
-    std::string as_str = message.get();
-    received_msg_ = as_str;
-  }
 
   void VariousArgs(fidljstest::Blorp blorp,
-                   fidl::StringPtr msg,
+                   std::string msg,
-                   fidl::VectorPtr<uint32_t> stuff) override {
+                   std::vector<uint32_t> stuff) override {
-    std::string msg_as_str = msg.get();
-    std::vector<uint32_t> stuff_as_vec = stuff.get();
     various_blorp_ = blorp;
-    various_msg_ = msg_as_str;
+    various_msg_ = msg;
-    various_stuff_ = stuff_as_vec;
+    various_stuff_ = stuff;
   }
 
   void WithResponse(int32_t a,
@@ -277,15 +272,15 @@ class TestolaImpl : public fidljstest::Testola {
       sat.arrrr[i] = static_cast<int32_t>(i * 5) - 10;
     }
     sat.nullable_vector_of_string0 = nullptr;
-    fidl::VectorPtr<fidl::StringPtr> vector_of_str;
+    std::vector<std::string> vector_of_str;
     vector_of_str.push_back("passed_str0");
     vector_of_str.push_back("passed_str1");
-    sat.nullable_vector_of_string1 = std::move(vector_of_str);
+    sat.nullable_vector_of_string1.reset(std::move(vector_of_str));
-    fidl::VectorPtr<fidljstest::Blorp> vector_of_blorp;
+    std::vector<fidljstest::Blorp> vector_of_blorp;
-    vector_of_blorp->push_back(fidljstest::Blorp::GAMMA);
+    vector_of_blorp.push_back(fidljstest::Blorp::GAMMA);
-    vector_of_blorp->push_back(fidljstest::Blorp::BETA);
+    vector_of_blorp.push_back(fidljstest::Blorp::BETA);
-    vector_of_blorp->push_back(fidljstest::Blorp::BETA);
+    vector_of_blorp.push_back(fidljstest::Blorp::BETA);
-    vector_of_blorp->push_back(fidljstest::Blorp::ALPHA);
+    vector_of_blorp.push_back(fidljstest::Blorp::ALPHA);
     sat.vector_of_blorp = std::move(vector_of_blorp);
 
     resp(std::move(sat));
@@ -330,37 +325,36 @@ class TestolaImpl : public fidljstest::Testola {
     callback(std::move(resp));
   }
 
-  void SendVectorsOfString(
+  void SendVectorsOfString(std::vector<std::string> unsized,
-      fidl::VectorPtr<fidl::StringPtr> unsized,
+                           std::vector<fidl::StringPtr> nullable,
-      fidl::VectorPtr<fidl::StringPtr> nullable,
+                           std::vector<std::string> max_strlen) override {
-      fidl::VectorPtr<fidl::StringPtr> max_strlen) override {
+    ASSERT_EQ(unsized.size(), 3u);
-    ASSERT_EQ(unsized->size(), 3u);
+    EXPECT_EQ(unsized[0], "str0");
-    EXPECT_EQ((*unsized)[0], "str0");
+    EXPECT_EQ(unsized[1], "str1");
-    EXPECT_EQ((*unsized)[1], "str1");
+    EXPECT_EQ(unsized[2], "str2");
-    EXPECT_EQ((*unsized)[2], "str2");
 
-    ASSERT_EQ(nullable->size(), 5u);
+    ASSERT_EQ(nullable.size(), 5u);
-    EXPECT_EQ((*nullable)[0], "str3");
+    EXPECT_EQ(nullable[0], "str3");
-    EXPECT_TRUE((*nullable)[1].is_null());
+    EXPECT_TRUE(nullable[1].is_null());
-    EXPECT_TRUE((*nullable)[2].is_null());
+    EXPECT_TRUE(nullable[2].is_null());
-    EXPECT_TRUE((*nullable)[3].is_null());
+    EXPECT_TRUE(nullable[3].is_null());
-    EXPECT_EQ((*nullable)[4], "str4");
+    EXPECT_EQ(nullable[4], "str4");
 
-    ASSERT_EQ(max_strlen->size(), 1u);
+    ASSERT_EQ(max_strlen.size(), 1u);
-    EXPECT_EQ((*max_strlen)[0], "0123456789");
+    EXPECT_EQ(max_strlen[0], "0123456789");
 
     did_get_vectors_of_string_ = true;
   }
 
-  void VectorOfStruct(fidl::VectorPtr<fidljstest::StructWithUint> stuff,
+  void VectorOfStruct(std::vector<fidljstest::StructWithUint> stuff,
                       VectorOfStructCallback callback) override {
-    ASSERT_EQ(stuff->size(), 4u);
+    ASSERT_EQ(stuff.size(), 4u);
-    EXPECT_EQ((*stuff)[0].num, 456u);
+    EXPECT_EQ(stuff[0].num, 456u);
-    EXPECT_EQ((*stuff)[1].num, 789u);
+    EXPECT_EQ(stuff[1].num, 789u);
-    EXPECT_EQ((*stuff)[2].num, 123u);
+    EXPECT_EQ(stuff[2].num, 123u);
-    EXPECT_EQ((*stuff)[3].num, 0xfffffu);
+    EXPECT_EQ(stuff[3].num, 0xfffffu);
 
-    fidl::VectorPtr<fidljstest::StructWithUint> response;
+    std::vector<fidljstest::StructWithUint> response;
     fidljstest::StructWithUint a;
     a.num = 369;
     response.push_back(a);
@@ -373,99 +367,99 @@ class TestolaImpl : public fidljstest::Testola {
   void PassVectorOfPrimitives(
       fidljstest::VectorsOfPrimitives input,
       PassVectorOfPrimitivesCallback callback) override {
-    ASSERT_EQ(input.v_bool->size(), 1u);
+    ASSERT_EQ(input.v_bool.size(), 1u);
-    ASSERT_EQ(input.v_uint8->size(), 2u);
+    ASSERT_EQ(input.v_uint8.size(), 2u);
-    ASSERT_EQ(input.v_uint16->size(), 3u);
+    ASSERT_EQ(input.v_uint16.size(), 3u);
-    ASSERT_EQ(input.v_uint32->size(), 4u);
+    ASSERT_EQ(input.v_uint32.size(), 4u);
-    ASSERT_EQ(input.v_uint64->size(), 5u);
+    ASSERT_EQ(input.v_uint64.size(), 5u);
-    ASSERT_EQ(input.v_int8->size(), 6u);
+    ASSERT_EQ(input.v_int8.size(), 6u);
-    ASSERT_EQ(input.v_int16->size(), 7u);
+    ASSERT_EQ(input.v_int16.size(), 7u);
-    ASSERT_EQ(input.v_int32->size(), 8u);
+    ASSERT_EQ(input.v_int32.size(), 8u);
-    ASSERT_EQ(input.v_int64->size(), 9u);
+    ASSERT_EQ(input.v_int64.size(), 9u);
-    ASSERT_EQ(input.v_float32->size(), 10u);
+    ASSERT_EQ(input.v_float32.size(), 10u);
-    ASSERT_EQ(input.v_float64->size(), 11u);
+    ASSERT_EQ(input.v_float64.size(), 11u);
 
-    EXPECT_EQ((*input.v_bool)[0], true);
+    EXPECT_EQ(input.v_bool[0], true);
 
-    EXPECT_EQ((*input.v_uint8)[0], 2u);
+    EXPECT_EQ(input.v_uint8[0], 2u);
-    EXPECT_EQ((*input.v_uint8)[1], 3u);
+    EXPECT_EQ(input.v_uint8[1], 3u);
 
-    EXPECT_EQ((*input.v_uint16)[0], 4u);
+    EXPECT_EQ(input.v_uint16[0], 4u);
-    EXPECT_EQ((*input.v_uint16)[1], 5u);
+    EXPECT_EQ(input.v_uint16[1], 5u);
-    EXPECT_EQ((*input.v_uint16)[2], 6u);
+    EXPECT_EQ(input.v_uint16[2], 6u);
 
-    EXPECT_EQ((*input.v_uint32)[0], 7u);
+    EXPECT_EQ(input.v_uint32[0], 7u);
-    EXPECT_EQ((*input.v_uint32)[1], 8u);
+    EXPECT_EQ(input.v_uint32[1], 8u);
-    EXPECT_EQ((*input.v_uint32)[2], 9u);
+    EXPECT_EQ(input.v_uint32[2], 9u);
-    EXPECT_EQ((*input.v_uint32)[3], 10u);
+    EXPECT_EQ(input.v_uint32[3], 10u);
 
-    EXPECT_EQ((*input.v_uint64)[0], 11u);
+    EXPECT_EQ(input.v_uint64[0], 11u);
-    EXPECT_EQ((*input.v_uint64)[1], 12u);
+    EXPECT_EQ(input.v_uint64[1], 12u);
-    EXPECT_EQ((*input.v_uint64)[2], 13u);
+    EXPECT_EQ(input.v_uint64[2], 13u);
-    EXPECT_EQ((*input.v_uint64)[3], 14u);
+    EXPECT_EQ(input.v_uint64[3], 14u);
-    EXPECT_EQ((*input.v_uint64)[4], 0xffffffffffffff00ULL);
+    EXPECT_EQ(input.v_uint64[4], 0xffffffffffffff00ULL);
 
-    EXPECT_EQ((*input.v_int8)[0], -16);
+    EXPECT_EQ(input.v_int8[0], -16);
-    EXPECT_EQ((*input.v_int8)[1], -17);
+    EXPECT_EQ(input.v_int8[1], -17);
-    EXPECT_EQ((*input.v_int8)[2], -18);
+    EXPECT_EQ(input.v_int8[2], -18);
-    EXPECT_EQ((*input.v_int8)[3], -19);
+    EXPECT_EQ(input.v_int8[3], -19);
-    EXPECT_EQ((*input.v_int8)[4], -20);
+    EXPECT_EQ(input.v_int8[4], -20);
-    EXPECT_EQ((*input.v_int8)[5], -21);
+    EXPECT_EQ(input.v_int8[5], -21);
 
-    EXPECT_EQ((*input.v_int16)[0], -22);
+    EXPECT_EQ(input.v_int16[0], -22);
-    EXPECT_EQ((*input.v_int16)[1], -23);
+    EXPECT_EQ(input.v_int16[1], -23);
-    EXPECT_EQ((*input.v_int16)[2], -24);
+    EXPECT_EQ(input.v_int16[2], -24);
-    EXPECT_EQ((*input.v_int16)[3], -25);
+    EXPECT_EQ(input.v_int16[3], -25);
-    EXPECT_EQ((*input.v_int16)[4], -26);
+    EXPECT_EQ(input.v_int16[4], -26);
-    EXPECT_EQ((*input.v_int16)[5], -27);
+    EXPECT_EQ(input.v_int16[5], -27);
-    EXPECT_EQ((*input.v_int16)[6], -28);
+    EXPECT_EQ(input.v_int16[6], -28);
 
-    EXPECT_EQ((*input.v_int32)[0], -29);
+    EXPECT_EQ(input.v_int32[0], -29);
-    EXPECT_EQ((*input.v_int32)[1], -30);
+    EXPECT_EQ(input.v_int32[1], -30);
-    EXPECT_EQ((*input.v_int32)[2], -31);
+    EXPECT_EQ(input.v_int32[2], -31);
-    EXPECT_EQ((*input.v_int32)[3], -32);
+    EXPECT_EQ(input.v_int32[3], -32);
-    EXPECT_EQ((*input.v_int32)[4], -33);
+    EXPECT_EQ(input.v_int32[4], -33);
-    EXPECT_EQ((*input.v_int32)[5], -34);
+    EXPECT_EQ(input.v_int32[5], -34);
-    EXPECT_EQ((*input.v_int32)[6], -35);
+    EXPECT_EQ(input.v_int32[6], -35);
-    EXPECT_EQ((*input.v_int32)[7], -36);
+    EXPECT_EQ(input.v_int32[7], -36);
 
-    EXPECT_EQ((*input.v_int64)[0], -37);
+    EXPECT_EQ(input.v_int64[0], -37);
-    EXPECT_EQ((*input.v_int64)[1], -38);
+    EXPECT_EQ(input.v_int64[1], -38);
-    EXPECT_EQ((*input.v_int64)[2], -39);
+    EXPECT_EQ(input.v_int64[2], -39);
-    EXPECT_EQ((*input.v_int64)[3], -40);
+    EXPECT_EQ(input.v_int64[3], -40);
-    EXPECT_EQ((*input.v_int64)[4], -41);
+    EXPECT_EQ(input.v_int64[4], -41);
-    EXPECT_EQ((*input.v_int64)[5], -42);
+    EXPECT_EQ(input.v_int64[5], -42);
-    EXPECT_EQ((*input.v_int64)[6], -43);
+    EXPECT_EQ(input.v_int64[6], -43);
-    EXPECT_EQ((*input.v_int64)[7], -44);
+    EXPECT_EQ(input.v_int64[7], -44);
-    EXPECT_EQ((*input.v_int64)[8], -0x7fffffffffffffffLL);
+    EXPECT_EQ(input.v_int64[8], -0x7fffffffffffffffLL);
 
-    EXPECT_EQ((*input.v_float32)[0], 46.f);
+    EXPECT_EQ(input.v_float32[0], 46.f);
-    EXPECT_EQ((*input.v_float32)[1], 47.f);
+    EXPECT_EQ(input.v_float32[1], 47.f);
-    EXPECT_EQ((*input.v_float32)[2], 48.f);
+    EXPECT_EQ(input.v_float32[2], 48.f);
-    EXPECT_EQ((*input.v_float32)[3], 49.f);
+    EXPECT_EQ(input.v_float32[3], 49.f);
-    EXPECT_EQ((*input.v_float32)[4], 50.f);
+    EXPECT_EQ(input.v_float32[4], 50.f);
-    EXPECT_EQ((*input.v_float32)[5], 51.f);
+    EXPECT_EQ(input.v_float32[5], 51.f);
-    EXPECT_EQ((*input.v_float32)[6], 52.f);
+    EXPECT_EQ(input.v_float32[6], 52.f);
-    EXPECT_EQ((*input.v_float32)[7], 53.f);
+    EXPECT_EQ(input.v_float32[7], 53.f);
-    EXPECT_EQ((*input.v_float32)[8], 54.f);
+    EXPECT_EQ(input.v_float32[8], 54.f);
-    EXPECT_EQ((*input.v_float32)[9], 55.f);
+    EXPECT_EQ(input.v_float32[9], 55.f);
 
-    EXPECT_EQ((*input.v_float64)[0], 56.0);
+    EXPECT_EQ(input.v_float64[0], 56.0);
-    EXPECT_EQ((*input.v_float64)[1], 57.0);
+    EXPECT_EQ(input.v_float64[1], 57.0);
-    EXPECT_EQ((*input.v_float64)[2], 58.0);
+    EXPECT_EQ(input.v_float64[2], 58.0);
-    EXPECT_EQ((*input.v_float64)[3], 59.0);
+    EXPECT_EQ(input.v_float64[3], 59.0);
-    EXPECT_EQ((*input.v_float64)[4], 60.0);
+    EXPECT_EQ(input.v_float64[4], 60.0);
-    EXPECT_EQ((*input.v_float64)[5], 61.0);
+    EXPECT_EQ(input.v_float64[5], 61.0);
-    EXPECT_EQ((*input.v_float64)[6], 62.0);
+    EXPECT_EQ(input.v_float64[6], 62.0);
-    EXPECT_EQ((*input.v_float64)[7], 63.0);
+    EXPECT_EQ(input.v_float64[7], 63.0);
-    EXPECT_EQ((*input.v_float64)[8], 64.0);
+    EXPECT_EQ(input.v_float64[8], 64.0);
-    EXPECT_EQ((*input.v_float64)[9], 65.0);
+    EXPECT_EQ(input.v_float64[9], 65.0);
-    EXPECT_EQ((*input.v_float64)[10], 66.0);
+    EXPECT_EQ(input.v_float64[10], 66.0);
 
     fidljstest::VectorsOfPrimitives output = std::move(input);
-#define INC_OUTPUT_ARRAY(v)                       \
+#define INC_OUTPUT_ARRAY(v)                      \
-  for (size_t i = 0; i < output.v->size(); ++i) { \
+  for (size_t i = 0; i < output.v.size(); ++i) { \
-    (*output.v)[i] += 10;                         \
+    output.v[i] += 10;                           \
   }
     INC_OUTPUT_ARRAY(v_uint8);
     INC_OUTPUT_ARRAY(v_uint16);

build/fuchsia/linux.sdk.sha1

@@ -1 +1 @@
-497d151e24e6a0911a9aa326ed148eb7a2f09782
+3b3374c29e5c1fa60be4d5a0f3f3e09dc9c13c56

build/fuchsia/mac.sdk.sha1

@@ -1 +1 @@
-2cc78a4b2803532aa6bf0f2fbea69a6a6e42efdb
+87fb54d489d2d61e4d08fd4f088decd90d018cc5

net/base/network_change_notifier_fuchsia.cc

@@ -51,18 +51,18 @@ NetworkChangeNotifierFuchsia::NetworkChangeNotifierFuchsia(
     ZX_LOG(ERROR, status) << "Lost connection to netstack.";
   });
   netstack_.events().OnInterfacesChanged =
-      [this](fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces) {
+      [this](std::vector<fuchsia::netstack::NetInterface> interfaces) {
         ProcessInterfaceList(base::OnceClosure(), std::move(interfaces));
       };
 
   // Fetch the interface list synchronously, so that an initial ConnectionType
   // is available before we return.
   base::RunLoop wait_for_interfaces;
-  netstack_->GetInterfaces([
+  netstack_->GetInterfaces(
-    this, quit_closure = wait_for_interfaces.QuitClosure()
+      [this, quit_closure = wait_for_interfaces.QuitClosure()](
-  ](fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces) {
+          std::vector<fuchsia::netstack::NetInterface> interfaces) {
-    ProcessInterfaceList(quit_closure, std::move(interfaces));
+        ProcessInterfaceList(quit_closure, std::move(interfaces));
-  });
+      });
   wait_for_interfaces.Run();
 }
 
@@ -79,7 +79,7 @@ NetworkChangeNotifierFuchsia::GetCurrentConnectionType() const {
 
 void NetworkChangeNotifierFuchsia::ProcessInterfaceList(
     base::OnceClosure on_initialized_cb,
-    fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces) {
+    std::vector<fuchsia::netstack::NetInterface> interfaces) {
   netstack_->GetRouteTable(WrapCallbackAsFunction(base::BindRepeating(
       &NetworkChangeNotifierFuchsia::OnRouteTableReceived,
       base::Unretained(this), base::Passed(std::move(on_initialized_cb)),
@@ -88,11 +88,11 @@ void NetworkChangeNotifierFuchsia::ProcessInterfaceList(
 
 void NetworkChangeNotifierFuchsia::OnRouteTableReceived(
     base::OnceClosure on_initialized_cb,
-    fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces,
+    std::vector<fuchsia::netstack::NetInterface> interfaces,
-    fidl::VectorPtr<fuchsia::netstack::RouteTableEntry> route_table) {
+    std::vector<fuchsia::netstack::RouteTableEntry> route_table) {
   // Find the default interface in the routing table.
   auto default_route_interface = std::find_if(
-      route_table->begin(), route_table->end(),
+      route_table.begin(), route_table.end(),
       [](const fuchsia::netstack::RouteTableEntry& rt) {
         return MaskPrefixLength(
                    internal::FuchsiaIpAddressToIPAddress(rt.netmask)) == 0;
@@ -100,8 +100,8 @@ void NetworkChangeNotifierFuchsia::OnRouteTableReceived(
 
   // Find the default interface in the NetInterface list.
   const fuchsia::netstack::NetInterface* default_interface = nullptr;
-  if (default_route_interface != route_table->end()) {
+  if (default_route_interface != route_table.end()) {
-    for (const auto& cur_interface : *interfaces) {
+    for (const auto& cur_interface : interfaces) {
       if (cur_interface.id == default_route_interface->nicid) {
         default_interface = &cur_interface;
       }

net/base/network_change_notifier_fuchsia.h

@@ -40,7 +40,7 @@ class NET_EXPORT_PRIVATE NetworkChangeNotifierFuchsia
   // GetRouteTable() to OnRouteTableReceived().
   void ProcessInterfaceList(
       base::OnceClosure on_initialized_cb,
-      fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces);
+      std::vector<fuchsia::netstack::NetInterface> interfaces);
 
   // Computes network change notification state change from the list of
   // interfaces and routing table data, sending observer events if IP or
@@ -51,8 +51,8 @@ class NET_EXPORT_PRIVATE NetworkChangeNotifierFuchsia
   // finished executing.
   void OnRouteTableReceived(
       base::OnceClosure on_initialized_cb,
-      fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces,
+      std::vector<fuchsia::netstack::NetInterface> interfaces,
-      fidl::VectorPtr<fuchsia::netstack::RouteTableEntry> table);
+      std::vector<fuchsia::netstack::RouteTableEntry> table);
 
   // NetworkChangeNotifier implementation.
   ConnectionType GetCurrentConnectionType() const override;

net/base/network_change_notifier_fuchsia_unittest.cc

@@ -81,11 +81,9 @@ fuchsia::netstack::NetInterface CreateNetInterface(
   output.features = features;
   output.addr = std::move(address);
   output.netmask = std::move(netmask);
-  output.hwaddr = fidl::VectorPtr<uint8_t>::New(0);
 
   output.addr.Clone(&output.broadaddr);
 
-  output.ipv6addrs = fidl::VectorPtr<fuchsia::net::Subnet>::New(0);
   for (auto& x : ipv6) {
     output.ipv6addrs.push_back(std::move(x));
   }
@@ -107,17 +105,17 @@ class FakeNetstack : public fuchsia::netstack::testing::Netstack_TestBase {
 
   // Adds |interface| to the interface query response list.
   void PushInterface(fuchsia::netstack::NetInterface&& interface) {
-    interfaces_->push_back(std::move(interface));
+    interfaces_.push_back(std::move(interface));
   }
 
   void PushRouteTableEntry(fuchsia::netstack::RouteTableEntry&& interface) {
-    route_table_->push_back(std::move(interface));
+    route_table_.push_back(std::move(interface));
   }
 
   // Sends the accumulated |interfaces_| to the OnInterfacesChanged event.
   void NotifyInterfaces() {
     binding_.events().OnInterfacesChanged(std::move(interfaces_));
-    interfaces_ = fidl::VectorPtr<fuchsia::netstack::NetInterface>::New(0);
+    interfaces_.clear();
   }
 
   fidl::Binding<fuchsia::netstack::Netstack>& binding() { return binding_; }
@@ -128,11 +126,9 @@ class FakeNetstack : public fuchsia::netstack::testing::Netstack_TestBase {
   }
 
   void GetRouteTable(GetRouteTableCallback callback) override {
-    fidl::VectorPtr<fuchsia::netstack::RouteTableEntry> table =
+    std::vector<fuchsia::netstack::RouteTableEntry> table(2);
-        fidl::VectorPtr<fuchsia::netstack::RouteTableEntry>::New(2);
+    table[0] = CreateRouteTableEntry(kDefaultNic, true);
-    (*table)[0] = CreateRouteTableEntry(kDefaultNic, true);
+    table[1] = CreateRouteTableEntry(kSecondaryNic, true);
-    (*table)[1] = CreateRouteTableEntry(kSecondaryNic, true);
-
     callback(std::move(table));
   }
 
@@ -140,10 +136,8 @@ class FakeNetstack : public fuchsia::netstack::testing::Netstack_TestBase {
     LOG(FATAL) << "Unimplemented function called: " << name;
   }
 
-  ::fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces_ =
+  std::vector<fuchsia::netstack::NetInterface> interfaces_;
-      fidl::VectorPtr<fuchsia::netstack::NetInterface>::New(0);
+  std::vector<fuchsia::netstack::RouteTableEntry> route_table_;
-  ::fidl::VectorPtr<fuchsia::netstack::RouteTableEntry> route_table_ =
-      fidl::VectorPtr<fuchsia::netstack::RouteTableEntry>::New(0);
 
   fidl::Binding<fuchsia::netstack::Netstack> binding_;
 

net/base/network_interfaces_fuchsia.cc

@@ -52,13 +52,13 @@ NetworkInterface NetworkInterfaceFromAddress(
     prefix_length =
         MaskPrefixLength(FuchsiaIpAddressToIPAddress(interface.netmask));
   } else {
-    CHECK_LE(address_index, interface.ipv6addrs->size());
+    CHECK_LE(address_index, interface.ipv6addrs.size());
     address = FuchsiaIpAddressToIPAddress(
-        interface.ipv6addrs->at(address_index - 1).addr);
+        interface.ipv6addrs.at(address_index - 1).addr);
-    prefix_length = interface.ipv6addrs->at(address_index - 1).prefix_len;
+    prefix_length = interface.ipv6addrs.at(address_index - 1).prefix_len;
   }
 
-  return NetworkInterface(*interface.name, interface.name, interface.id,
+  return NetworkInterface(interface.name, interface.name, interface.id,
                           ConvertConnectionType(interface), address,
                           prefix_length, attributes);
 }
@@ -90,7 +90,7 @@ std::vector<NetworkInterface> NetInterfaceToNetworkInterfaces(
   output.push_back(NetworkInterfaceFromAddress(iface_in, 0));
 
   // Append interface entries for all additional IPv6 addresses.
-  for (size_t i = 0; i < iface_in.ipv6addrs->size(); ++i) {
+  for (size_t i = 0; i < iface_in.ipv6addrs.size(); ++i) {
     output.push_back(NetworkInterfaceFromAddress(iface_in, i + 1));
   }
 
@@ -107,14 +107,14 @@ bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
           ->ConnectToServiceSync<fuchsia::netstack::Netstack>();
 
   // TODO(kmarshall): Use NetworkChangeNotifier's cached interface list.
-  fidl::VectorPtr<fuchsia::netstack::NetInterface> interfaces;
+  std::vector<fuchsia::netstack::NetInterface> interfaces;
   zx_status_t status = netstack->GetInterfaces(&interfaces);
   if (status != ZX_OK) {
     ZX_LOG(ERROR, status) << "fuchsia::netstack::GetInterfaces()";
     return false;
   }
 
-  for (auto& interface : interfaces.get()) {
+  for (auto& interface : interfaces) {
     auto converted = internal::NetInterfaceToNetworkInterfaces(interface);
     std::move(converted.begin(), converted.end(),
               std::back_inserter(*networks));

ui/ozone/platform/scenic/scenic_window.cc

@@ -224,8 +224,8 @@ void ScenicWindow::OnScenicError(zx_status_t status) {
 }
 
 void ScenicWindow::OnScenicEvents(
-    fidl::VectorPtr<fuchsia::ui::scenic::Event> events) {
+    std::vector<fuchsia::ui::scenic::Event> events) {
-  for (const auto& event : *events) {
+  for (const auto& event : events) {
     if (event.is_gfx()) {
       if (!event.gfx().is_metrics())
         continue;

ui/ozone/platform/scenic/scenic_window.h

@@ -71,7 +71,7 @@ class OZONE_EXPORT ScenicWindow : public PlatformWindow,
 
   // Callbacks for |scenic_session_|.
   void OnScenicError(zx_status_t status);
-  void OnScenicEvents(fidl::VectorPtr<fuchsia::ui::scenic::Event> events);
+  void OnScenicEvents(std::vector<fuchsia::ui::scenic::Event> events);
 
   // InputEventDispatcher::Delegate interface.
   void DispatchEvent(ui::Event* event) override;

webrunner/app/cast/application_config_manager/application_config_manager.cc

@@ -11,20 +11,18 @@ namespace castrunner {
 ApplicationConfigManager::ApplicationConfigManager() = default;
 ApplicationConfigManager::~ApplicationConfigManager() = default;
 
-void ApplicationConfigManager::GetConfig(fidl::StringPtr id,
+void ApplicationConfigManager::GetConfig(std::string id,
                                          GetConfigCallback callback) {
-  DCHECK(id);
-
   constexpr char kTestCastAppId[] = "00000000";
-  if (*id != kTestCastAppId) {
+  if (id != kTestCastAppId) {
-    LOG(ERROR) << "Unknown Cast app Id: " << *id;
+    LOG(ERROR) << "Unknown Cast app Id: " << id;
     callback(chromium::cast::ApplicationConfigPtr());
     return;
   }
 
   chromium::cast::ApplicationConfigPtr app_config =
       chromium::cast::ApplicationConfig::New();
-  app_config->id = *id;
+  app_config->id = id;
   app_config->display_name = "Dummy test app";
   app_config->web_url = "https://www.google.com";
   callback(std::move(app_config));

webrunner/app/cast/application_config_manager/application_config_manager.h

@@ -21,8 +21,7 @@ class ApplicationConfigManager
   ~ApplicationConfigManager() override;
 
   // chromium::cast::ApplicationConfigManager interface.
-  void GetConfig(fidl::StringPtr id,
+  void GetConfig(std::string id, GetConfigCallback config_callback) override;
-                 GetConfigCallback config_callback) override;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationConfigManager);
 };

webrunner/app/cast/application_config_manager/test/fake_application_config_manager.cc

@@ -16,19 +16,17 @@ FakeApplicationConfigManager::FakeApplicationConfigManager(
     : embedded_test_server_(embedded_test_server) {}
 FakeApplicationConfigManager::~FakeApplicationConfigManager() = default;
 
-void FakeApplicationConfigManager::GetConfig(fidl::StringPtr id,
+void FakeApplicationConfigManager::GetConfig(std::string id,
                                              GetConfigCallback callback) {
-  DCHECK(id);
+  if (id != kTestCastAppId) {
-
+    LOG(ERROR) << "Unknown Cast app Id: " << id;
-  if (*id != kTestCastAppId) {
-    LOG(ERROR) << "Unknown Cast app Id: " << *id;
     callback(chromium::cast::ApplicationConfigPtr());
     return;
   }
 
   chromium::cast::ApplicationConfigPtr app_config =
       chromium::cast::ApplicationConfig::New();
-  app_config->id = *id;
+  app_config->id = id;
   app_config->display_name = "Dummy test app";
   app_config->web_url = embedded_test_server_->base_url().spec();
   callback(std::move(app_config));

webrunner/app/cast/application_config_manager/test/fake_application_config_manager.h

@@ -25,8 +25,7 @@ class FakeApplicationConfigManager
   ~FakeApplicationConfigManager() override;
 
   // chromium::cast::ApplicationConfigManager interface.
-  void GetConfig(fidl::StringPtr id,
+  void GetConfig(std::string id, GetConfigCallback config_callback) override;
-                 GetConfigCallback config_callback) override;
 
  private:
   net::EmbeddedTestServer* embedded_test_server_;

webrunner/app/cast/cast_runner.cc

@@ -34,7 +34,7 @@ void CastRunner::StartComponent(
   constexpr char kCastPresentationUrlScheme[] = "cast";
   constexpr char kCastSecurePresentationUrlScheme[] = "casts";
 
-  GURL cast_url(*package.resolved_url);
+  GURL cast_url(package.resolved_url);
   if (!cast_url.is_valid() ||
       (!cast_url.SchemeIs(kCastPresentationUrlScheme) &&
        !cast_url.SchemeIs(kCastSecurePresentationUrlScheme)) ||
@@ -70,7 +70,7 @@ void CastRunner::GetConfigCallback(
   }
 
   // If a config was returned then use it to launch a component.
-  GURL cast_app_url(*app_config->web_url);
+  GURL cast_app_url(app_config->web_url);
   RegisterComponent(webrunner::WebComponent::ForUrlRequest(
       this, std::move(cast_app_url), std::move(startup_info),
       std::move(controller_request)));

webrunner/app/cast/test_common.cc

@@ -14,7 +14,7 @@ zx::channel StartCastComponent(
     fidl::InterfaceRequest<fuchsia::sys::ComponentController>
         component_controller_request) {
   fuchsia::sys::LaunchInfo launch_info;
-  launch_info.url.reset(cast_url.as_string());
+  launch_info.url = cast_url.as_string();
 
   // Create a channel to pass to the Runner, through which to expose the new
   // component's ServiceDirectory.
@@ -31,7 +31,7 @@ zx::channel StartCastComponent(
   startup_info.flat_namespace.directories.resize(0);
 
   fuchsia::sys::Package package;
-  package.resolved_url.reset(cast_url.as_string());
+  package.resolved_url = cast_url.as_string();
 
   sys_runner->get()->StartComponent(std::move(package), std::move(startup_info),
                                     std::move(component_controller_request));

webrunner/app/common/web_content_runner.cc

@@ -69,7 +69,7 @@ void WebContentRunner::StartComponent(
     fuchsia::sys::StartupInfo startup_info,
     fidl::InterfaceRequest<fuchsia::sys::ComponentController>
         controller_request) {
-  GURL url(*package.resolved_url);
+  GURL url(package.resolved_url);
   if (!url.is_valid()) {
     LOG(ERROR) << "Rejected invalid URL: " << url;
     return;

webrunner/browser/frame_impl.cc

@@ -284,11 +284,11 @@ void FrameImpl::SetJavaScriptLogLevel(chromium::web::LogLevel level) {
   log_level_ = level;
 }
 
-void FrameImpl::LoadUrl(fidl::StringPtr url,
+void FrameImpl::LoadUrl(std::string url,
                         std::unique_ptr<chromium::web::LoadUrlParams> params) {
-  GURL validated_url(*url);
+  GURL validated_url(url);
   if (!validated_url.is_valid()) {
-    DLOG(WARNING) << "Invalid URL: " << *url;
+    DLOG(WARNING) << "Invalid URL: " << url;
     return;
   }
 
@@ -358,7 +358,7 @@ void FrameImpl::SetNavigationEventObserver(
   }
 }
 
-void FrameImpl::ExecuteJavaScript(fidl::VectorPtr<::fidl::StringPtr> origins,
+void FrameImpl::ExecuteJavaScript(std::vector<std::string> origins,
                                   fuchsia::mem::Buffer script,
                                   chromium::web::ExecuteMode mode,
                                   ExecuteJavaScriptCallback callback) {
@@ -367,13 +367,13 @@ void FrameImpl::ExecuteJavaScript(fidl::VectorPtr<::fidl::StringPtr> origins,
     return;
   }
 
-  if (origins->empty()) {
+  if (origins.empty()) {
     callback(false);
     return;
   }
 
   std::vector<std::string> origins_strings;
-  for (const auto& origin : *origins)
+  for (const auto& origin : origins)
     origins_strings.push_back(origin);
 
   base::string16 script_utf16;
@@ -529,18 +529,18 @@ FrameImpl::OriginScopedScript::OriginScopedScript(
 FrameImpl::OriginScopedScript::~OriginScopedScript() = default;
 
 void FrameImpl::PostMessage(chromium::web::WebMessage message,
-                            fidl::StringPtr target_origin,
+                            std::string target_origin,
                             PostMessageCallback callback) {
   constexpr char kWildcardOrigin[] = "*";
 
-  if (target_origin->empty()) {
+  if (target_origin.empty()) {
     callback(false);
     return;
   }
 
   base::Optional<base::string16> target_origin_utf16;
-  if (*target_origin != kWildcardOrigin)
+  if (target_origin != kWildcardOrigin)
-    target_origin_utf16 = base::UTF8ToUTF16(*target_origin);
+    target_origin_utf16 = base::UTF8ToUTF16(target_origin);
 
   base::string16 data_utf16;
   if (!ReadUTF8FromVMOAsUTF16(message.data, &data_utf16)) {

webrunner/browser/frame_impl.h

@@ -67,12 +67,12 @@ class FrameImpl : public chromium::web::Frame,
   void SetNavigationEventObserver(
       fidl::InterfaceHandle<chromium::web::NavigationEventObserver> observer)
       override;
-  void ExecuteJavaScript(fidl::VectorPtr<::fidl::StringPtr> origins,
+  void ExecuteJavaScript(std::vector<std::string> origins,
                          fuchsia::mem::Buffer script,
                          chromium::web::ExecuteMode mode,
                          ExecuteJavaScriptCallback callback) override;
   void PostMessage(chromium::web::WebMessage message,
-                   fidl::StringPtr targetOrigin,
+                   std::string target_origin,
                    PostMessageCallback callback) override;
 
  private:
@@ -97,7 +97,7 @@ class FrameImpl : public chromium::web::Frame,
   };
 
   // chromium::web::NavigationController implementation.
-  void LoadUrl(fidl::StringPtr url,
+  void LoadUrl(std::string url,
                std::unique_ptr<chromium::web::LoadUrlParams> params) override;
   void GoBack() override;
   void GoForward() override;

webrunner/browser/frame_impl_browsertest.cc

@@ -390,9 +390,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavaScriptImmediate) {
   chromium::web::NavigationControllerPtr controller;
   frame->GetNavigationController(controller.NewRequest());
   CheckLoadUrl(title1.spec(), kPage1Title, controller.get());
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {title1.GetOrigin().spec()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back(title1.GetOrigin().spec());
 
   frame->ExecuteJavaScript(
       std::move(origins),
@@ -414,9 +412,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavaScriptOnLoad) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {url.GetOrigin().spec()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back(url.GetOrigin().spec());
 
   frame->ExecuteJavaScript(std::move(origins),
                            MemBufferFromString("stashed_title = 'hello';"),
@@ -433,9 +429,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavaScriptOnLoadVmoDestroyed) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {url.GetOrigin().spec()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back(url.GetOrigin().spec());
 
   frame->ExecuteJavaScript(std::move(origins),
                            MemBufferFromString("stashed_title = 'hello';"),
@@ -452,9 +446,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavascriptOnLoadWrongOrigin) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {"http://example.com"};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back("http://example.com");
 
   frame->ExecuteJavaScript(std::move(origins),
                            MemBufferFromString("stashed_title = 'hello';"),
@@ -475,9 +467,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavaScriptOnLoadWildcardOrigin) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {"*"};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back("*");
 
   frame->ExecuteJavaScript(std::move(origins),
                            MemBufferFromString("stashed_title = 'hello';"),
@@ -504,10 +494,8 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteMultipleJavaScriptsOnLoad) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {url.GetOrigin().spec()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
+  frame->ExecuteJavaScript(origins,
-  origins.push_back(url.GetOrigin().spec());
-  frame->ExecuteJavaScript(origins.Clone(),
                            MemBufferFromString("stashed_title = 'hello';"),
                            chromium::web::ExecuteMode::ON_PAGE_LOAD,
                            [](bool success) { EXPECT_TRUE(success); });
@@ -527,11 +515,9 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteOnLoadEarlyAndLateRegistrations) {
   GURL url(embedded_test_server()->GetURL(kDynamicTitlePath));
   chromium::web::FramePtr frame = CreateFrame();
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {url.GetOrigin().spec()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back(url.GetOrigin().spec());
 
-  frame->ExecuteJavaScript(origins.Clone(),
+  frame->ExecuteJavaScript(origins,
                            MemBufferFromString("stashed_title = 'hello';"),
                            chromium::web::ExecuteMode::ON_PAGE_LOAD,
                            [](bool success) { EXPECT_TRUE(success); });
@@ -565,9 +551,7 @@ IN_PROC_BROWSER_TEST_F(FrameImplTest, ExecuteJavaScriptBadEncoding) {
   base::RunLoop run_loop;
 
   // 0xFE is an illegal UTF-8 byte; it should cause UTF-8 conversion to fail.
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {url.host()};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back(url.host());
   frame->ExecuteJavaScript(std::move(origins), MemBufferFromString("true;\xfe"),
                            chromium::web::ExecuteMode::IMMEDIATE_ONCE,
                            [&run_loop](bool success) {

webrunner/common/named_message_port_connector.cc

@@ -110,9 +110,7 @@ void NamedMessagePortConnector::NotifyPageLoad(chromium::web::Frame* frame) {
 void NamedMessagePortConnector::InjectBindings(chromium::web::Frame* frame) {
   DCHECK(frame);
 
-  fidl::VectorPtr<fidl::StringPtr> origins =
+  std::vector<std::string> origins = {"*"};
-      fidl::VectorPtr<fidl::StringPtr>::New(0);
-  origins.push_back("*");
   frame->ExecuteJavaScript(
       std::move(origins), CloneBuffer(bindings_script_),
       chromium::web::ExecuteMode::ON_PAGE_LOAD,

webrunner/net_http/http_service_unittest.cc

@@ -192,8 +192,8 @@ void CheckResponseBuffer(const oldhttp::URLResponse& response,
 void CheckResponseHeaders(const oldhttp::URLResponse& response,
                           ResponseHeaders* expected_headers) {
   for (auto& header : response.headers.get()) {
-    const std::string header_name = header.name->data();
+    const std::string header_name = header.name.data();
-    const std::string header_value = header.value->data();
+    const std::string header_value = header.value.data();
     auto iter = std::find_if(expected_headers->begin(), expected_headers->end(),
                              [&header_name, &header_value](auto& elt) -> bool {
                                return elt.first.compare(header_name) == 0 &&

webrunner/net_http/url_loader_impl.cc

@@ -146,7 +146,7 @@ void URLLoaderImpl::Start(oldhttp::URLRequest request, Callback callback) {
   net_error_ = net::OK;
 
   // Create the URLRequest and set this object as the delegate.
-  net_request_ = context_->CreateRequest(GURL(request.url.get()),
+  net_request_ = context_->CreateRequest(GURL(request.url),
                                          net::RequestPriority::MEDIUM, this);
   net_request_->set_method(request.method);