BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

5 files changed, 87 insertions, 94 deletions

diff --git a/chromium/extensions/browser/api/serial/serial_api.cc b/chromium/extensions/browser/api/serial/serial_api.cc
index 096f736cba1..a0bfd248b16 100644
--- a/chromium/extensions/browser/api/serial/serial_api.cc
+++ b/chromium/extensions/browser/api/serial/serial_api.cc
@@ -81,8 +81,35 @@ ExtensionFunction::ResponseAction SerialGetDevicesFunction::Run() {
 
 void SerialGetDevicesFunction::OnGotDevices(
     std::vector<device::mojom::SerialPortInfoPtr> devices) {
-  Respond(ArgumentList(serial::GetDevices::Results::Create(
-      mojo::ConvertTo<std::vector<serial::DeviceInfo>>(devices))));
+  std::vector<extensions::api::serial::DeviceInfo> results;
+  for (const auto& device : devices) {
+    extensions::api::serial::DeviceInfo info;
+    info.path = device->path.AsUTF8Unsafe();
+    if (device->has_vendor_id)
+      info.vendor_id = std::make_unique<int>(device->vendor_id);
+    if (device->has_product_id)
+      info.product_id = std::make_unique<int>(device->product_id);
+    if (device->display_name)
+      info.display_name = std::make_unique<std::string>(*device->display_name);
+    results.push_back(std::move(info));
+
+#if defined(OS_MACOSX)
+    if (device->alternate_path) {
+      extensions::api::serial::DeviceInfo alternate_info;
+      alternate_info.path = device->alternate_path->AsUTF8Unsafe();
+      if (device->has_vendor_id)
+        alternate_info.vendor_id = std::make_unique<int>(device->vendor_id);
+      if (device->has_product_id)
+        alternate_info.product_id = std::make_unique<int>(device->product_id);
+      if (device->display_name) {
+        alternate_info.display_name =
+            std::make_unique<std::string>(*device->display_name);
+      }
+      results.push_back(std::move(alternate_info));
+    }
+#endif  // defined(OS_MACOSX)
+  }
+  Respond(ArgumentList(serial::GetDevices::Results::Create(results)));
 }
 
 SerialConnectFunction::SerialConnectFunction() {}
@@ -438,23 +465,3 @@ void SerialClearBreakFunction::OnClearBreak(bool success) {
 }  // namespace api
 
 }  // namespace extensions
-
-namespace mojo {
-
-// static
-extensions::api::serial::DeviceInfo
-TypeConverter<extensions::api::serial::DeviceInfo,
-              device::mojom::SerialPortInfoPtr>::
-    Convert(const device::mojom::SerialPortInfoPtr& device) {
-  extensions::api::serial::DeviceInfo info;
-  info.path = device->path.AsUTF8Unsafe();
-  if (device->has_vendor_id)
-    info.vendor_id.reset(new int(static_cast<int>(device->vendor_id)));
-  if (device->has_product_id)
-    info.product_id.reset(new int(static_cast<int>(device->product_id)));
-  if (device->display_name)
-    info.display_name.reset(new std::string(device->display_name.value()));
-  return info;
-}
-
-}  // namespace mojo
diff --git a/chromium/extensions/browser/api/serial/serial_apitest.cc b/chromium/extensions/browser/api/serial/serial_apitest.cc
index c268ac59e72..9aa02113827 100644
--- a/chromium/extensions/browser/api/serial/serial_apitest.cc
+++ b/chromium/extensions/browser/api/serial/serial_apitest.cc
@@ -86,8 +86,6 @@ class FakeSerialPort : public device::mojom::SerialPort {
  private:
   // device::mojom::SerialPort methods:
   void Open(device::mojom::SerialConnectionOptionsPtr options,
-            mojo::ScopedDataPipeConsumerHandle in_stream,
-            mojo::ScopedDataPipeProducerHandle out_stream,
             mojo::PendingRemote<device::mojom::SerialPortClient> client,
             OpenCallback callback) override {
     if (client_) {
@@ -99,22 +97,35 @@ class FakeSerialPort : public device::mojom::SerialPort {
     DoConfigurePort(*options);
     DCHECK(client);
     client_.Bind(std::move(client));
-    SetUpInStreamPipe(std::move(in_stream));
-    SetUpOutStreamPipe(std::move(out_stream));
     std::move(callback).Run(true);
   }
-  void ClearSendError(mojo::ScopedDataPipeConsumerHandle consumer) override {
-    if (in_stream_) {
+
+  void StartWriting(mojo::ScopedDataPipeConsumerHandle consumer) override {
+    if (in_stream_)
       return;
-    }
-    SetUpInStreamPipe(std::move(consumer));
+
+    in_stream_ = std::move(consumer);
+    in_stream_watcher_.Watch(
+        in_stream_.get(),
+        MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+        MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
+        base::BindRepeating(&FakeSerialPort::DoWrite, base::Unretained(this)));
+    in_stream_watcher_.ArmOrNotify();
   }
-  void ClearReadError(mojo::ScopedDataPipeProducerHandle producer) override {
-    if (out_stream_) {
+
+  void StartReading(mojo::ScopedDataPipeProducerHandle producer) override {
+    if (out_stream_)
       return;
-    }
-    SetUpOutStreamPipe(std::move(producer));
+
+    out_stream_ = std::move(producer);
+    out_stream_watcher_.Watch(
+        out_stream_.get(),
+        MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+        MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
+        base::BindRepeating(&FakeSerialPort::DoRead, base::Unretained(this)));
+    out_stream_watcher_.ArmOrNotify();
   }
+
   void Flush(FlushCallback callback) override { std::move(callback).Run(true); }
   void GetControlSignals(GetControlSignalsCallback callback) override {
     auto signals = device::mojom::SerialPortControlSignals::New();
@@ -152,16 +163,6 @@ class FakeSerialPort : public device::mojom::SerialPort {
     std::move(callback).Run();
   }
 
-  void SetUpInStreamPipe(mojo::ScopedDataPipeConsumerHandle consumer) {
-    in_stream_.swap(consumer);
-    in_stream_watcher_.Watch(
-        in_stream_.get(),
-        MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-        MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
-        base::BindRepeating(&FakeSerialPort::DoWrite, base::Unretained(this)));
-    in_stream_watcher_.ArmOrNotify();
-  }
-
   void DoWrite(MojoResult result, const mojo::HandleSignalsState& state) {
     const void* data;
     uint32_t num_bytes;
@@ -201,16 +202,6 @@ class FakeSerialPort : public device::mojom::SerialPort {
     NOTREACHED();
   }
 
-  void SetUpOutStreamPipe(mojo::ScopedDataPipeProducerHandle producer) {
-    out_stream_.swap(producer);
-    out_stream_watcher_.Watch(
-        out_stream_.get(),
-        MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-        MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
-        base::BindRepeating(&FakeSerialPort::DoRead, base::Unretained(this)));
-    out_stream_watcher_.ArmOrNotify();
-  }
-
   void DoRead(MojoResult result, const mojo::HandleSignalsState& state) {
     if (result != MOJO_RESULT_OK) {
       out_stream_.reset();
@@ -311,6 +302,7 @@ class FakeSerialPortManager : public device::mojom::SerialPortManager {
   }
 
   void GetPort(const base::UnguessableToken& token,
+               bool use_alternate_path,
                mojo::PendingReceiver<device::mojom::SerialPort> receiver,
                mojo::PendingRemote<device::mojom::SerialPortConnectionWatcher>
                    watcher) override {
diff --git a/chromium/extensions/browser/api/serial/serial_connection.cc b/chromium/extensions/browser/api/serial/serial_connection.cc
index f8fb970a6e5..5df8db36db8 100644
--- a/chromium/extensions/browser/api/serial/serial_connection.cc
+++ b/chromium/extensions/browser/api/serial/serial_connection.cc
@@ -209,13 +209,8 @@ void SerialConnection::SetPaused(bool paused) {
   } else {
     // If |receive_pipe_| is closed and there is no pending ReceiveError event,
     // try to reconnect the data pipe.
-    if (!receive_pipe_ && !read_error_) {
-      mojo::ScopedDataPipeProducerHandle producer;
-      mojo::ScopedDataPipeConsumerHandle consumer;
-      CreatePipe(&producer, &consumer);
-      SetUpReceiveDataPipe(std::move(consumer));
-      serial_port_->ClearReadError(std::move(producer));
-    }
+    if (!receive_pipe_ && !read_error_)
+      SetUpReceiveDataPipe();
     receive_pipe_watcher_.ArmOrNotify();
     receive_timeout_task_.Cancel();
     SetTimeoutCallback();
@@ -249,22 +244,12 @@ void SerialConnection::Open(const api::serial::ConnectionOptions& options,
   if (options.send_timeout.get())
     set_send_timeout(*options.send_timeout);
 
-  mojo::ScopedDataPipeProducerHandle receive_producer;
-  mojo::ScopedDataPipeConsumerHandle receive_consumer;
-  CreatePipe(&receive_producer, &receive_consumer);
-
-  mojo::ScopedDataPipeProducerHandle send_producer;
-  mojo::ScopedDataPipeConsumerHandle send_consumer;
-  CreatePipe(&send_producer, &send_consumer);
-
   mojo::PendingRemote<device::mojom::SerialPortClient> client;
   auto client_receiver = client.InitWithNewPipeAndPassReceiver();
   serial_port_->Open(
-      device::mojom::SerialConnectionOptions::From(options),
-      std::move(send_consumer), std::move(receive_producer), std::move(client),
+      device::mojom::SerialConnectionOptions::From(options), std::move(client),
       mojo::WrapCallbackWithDefaultInvokeIfNotRun(
           base::BindOnce(&SerialConnection::OnOpen, weak_factory_.GetWeakPtr(),
-                         std::move(receive_consumer), std::move(send_producer),
                          std::move(client_receiver), std::move(callback)),
           false));
 }
@@ -281,9 +266,12 @@ void SerialConnection::CreatePipe(
   CHECK_EQ(MOJO_RESULT_OK, mojo::CreateDataPipe(&options, producer, consumer));
 }
 
-void SerialConnection::SetUpReceiveDataPipe(
-    mojo::ScopedDataPipeConsumerHandle consumer) {
-  receive_pipe_ = std::move(consumer);
+void SerialConnection::SetUpReceiveDataPipe() {
+  mojo::ScopedDataPipeProducerHandle producer;
+  CreatePipe(&producer, &receive_pipe_);
+
+  serial_port_->StartReading(std::move(producer));
+
   receive_pipe_watcher_.Watch(
       receive_pipe_.get(),
       MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -292,9 +280,12 @@ void SerialConnection::SetUpReceiveDataPipe(
                           weak_factory_.GetWeakPtr()));
 }
 
-void SerialConnection::SetUpSendDataPipe(
-    mojo::ScopedDataPipeProducerHandle producer) {
-  send_pipe_ = std::move(producer);
+void SerialConnection::SetUpSendDataPipe() {
+  mojo::ScopedDataPipeConsumerHandle consumer;
+  CreatePipe(&send_pipe_, &consumer);
+
+  serial_port_->StartWriting(std::move(consumer));
+
   send_pipe_watcher_.Watch(
       send_pipe_.get(),
       MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
@@ -330,8 +321,6 @@ void SerialConnection::OnSendError(device::mojom::SerialSendError error) {
 }
 
 void SerialConnection::OnOpen(
-    mojo::ScopedDataPipeConsumerHandle consumer,
-    mojo::ScopedDataPipeProducerHandle producer,
     mojo::PendingReceiver<device::mojom::SerialPortClient> client_receiver,
     OpenCompleteCallback callback,
     bool success) {
@@ -340,8 +329,8 @@ void SerialConnection::OnOpen(
     return;
   }
 
-  SetUpReceiveDataPipe(std::move(consumer));
-  SetUpSendDataPipe(std::move(producer));
+  SetUpReceiveDataPipe();
+  SetUpSendDataPipe();
   client_receiver_.Bind(std::move(client_receiver));
   client_receiver_.set_disconnect_handler(base::BindOnce(
       &SerialConnection::OnClientReceiverClosed, weak_factory_.GetWeakPtr()));
@@ -419,13 +408,8 @@ bool SerialConnection::Send(const std::vector<uint8_t>& data,
   DCHECK(data_to_send_.empty());
   data_to_send_.assign(data.begin(), data.end());
 
-  if (!send_pipe_) {
-    mojo::ScopedDataPipeProducerHandle producer;
-    mojo::ScopedDataPipeConsumerHandle consumer;
-    CreatePipe(&producer, &consumer);
-    SetUpSendDataPipe(std::move(producer));
-    serial_port_->ClearSendError(std::move(consumer));
-  }
+  if (!send_pipe_)
+    SetUpSendDataPipe();
   send_pipe_watcher_.ArmOrNotify();
 
   send_timeout_task_.Cancel();
diff --git a/chromium/extensions/browser/api/serial/serial_connection.h b/chromium/extensions/browser/api/serial/serial_connection.h
index 9ee96ad3758..29cf85cb16e 100644
--- a/chromium/extensions/browser/api/serial/serial_connection.h
+++ b/chromium/extensions/browser/api/serial/serial_connection.h
@@ -146,8 +146,6 @@ class SerialConnection : public ApiResource,
   void OnSendError(device::mojom::SerialSendError error) override;
 
   void OnOpen(
-      mojo::ScopedDataPipeConsumerHandle consumer,
-      mojo::ScopedDataPipeProducerHandle producer,
       mojo::PendingReceiver<device::mojom::SerialPortClient> client_receiver,
       OpenCompleteCallback callback,
       bool success);
@@ -160,8 +158,8 @@ class SerialConnection : public ApiResource,
 
   void CreatePipe(mojo::ScopedDataPipeProducerHandle* producer,
                   mojo::ScopedDataPipeConsumerHandle* consumer);
-  void SetUpReceiveDataPipe(mojo::ScopedDataPipeConsumerHandle producer);
-  void SetUpSendDataPipe(mojo::ScopedDataPipeProducerHandle consumer);
+  void SetUpReceiveDataPipe();
+  void SetUpSendDataPipe();
 
   void SetTimeoutCallback();
 
diff --git a/chromium/extensions/browser/api/serial/serial_port_manager.cc b/chromium/extensions/browser/api/serial/serial_port_manager.cc
index 4194ea83be0..559eb121954 100644
--- a/chromium/extensions/browser/api/serial/serial_port_manager.cc
+++ b/chromium/extensions/browser/api/serial/serial_port_manager.cc
@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/no_destructor.h"
+#include "build/build_config.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/device_service.h"
@@ -188,10 +189,21 @@ void SerialPortManager::OnGotDevicesToGetPort(
 
   for (auto& device : devices) {
     if (device->path.AsUTF8Unsafe() == path) {
-      port_manager_->GetPort(device->token, std::move(receiver),
+      port_manager_->GetPort(device->token, /*use_alternate_path=*/false,
+                             std::move(receiver),
                              /*watcher=*/mojo::NullRemote());
       return;
     }
+
+#if defined(OS_MACOSX)
+    if (device->alternate_path &&
+        device->alternate_path->AsUTF8Unsafe() == path) {
+      port_manager_->GetPort(device->token, /*use_alternate_path=*/true,
+                             std::move(receiver),
+                             /*watcher=*/mojo::NullRemote());
+      return;
+    }
+#endif  // defined(OS_MACOSX)
   }
 }