Index: patch-services_device_hid_hid__connection__freebsd.cc =================================================================== --- patch-services_device_hid_hid__connection__freebsd.cc (revision 542828) +++ patch-services_device_hid_hid__connection__freebsd.cc (working copy) @@ -1,5 +1,5 @@ ---- services/device/hid/hid_connection_freebsd.cc.orig 2019-05-04 09:19:19 UTC -+++ services/device/hid/hid_connection_freebsd.cc +--- services/device/hid/hid_connection_freebsd.cc.orig 2020-07-18 19:40:14.410523000 -0700 ++++ services/device/hid/hid_connection_freebsd.cc 2020-07-21 19:49:59.569331000 -0700 @@ -0,0 +1,240 @@ +// Copyright (c) 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be @@ -26,9 +26,9 @@ + +namespace device { + -+class HidConnectionFreeBSD::BlockingTaskHelper { ++class HidConnectionFreeBSD::BlockingTaskRunnerHelper { + public: -+ BlockingTaskHelper(base::ScopedFD fd, ++ BlockingTaskRunnerHelper(base::ScopedFD fd, + scoped_refptr device_info, + base::WeakPtr connection) + : fd_(std::move(fd)), @@ -40,7 +40,7 @@ + has_report_id_ = device_info->has_report_id(); + } + -+ ~BlockingTaskHelper() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); } ++ ~BlockingTaskRunnerHelper() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); } + + // Starts the FileDescriptorWatcher that reads input events from the device. + // Must be called on a thread that has a base::MessageLoopForIO. @@ -49,7 +49,7 @@ + base::internal::AssertBlockingAllowed(); + + file_watcher_ = base::FileDescriptorWatcher::WatchReadable( -+ fd_.get(), base::Bind(&BlockingTaskHelper::OnFileCanReadWithoutBlocking, ++ fd_.get(), base::Bind(&BlockingTaskRunnerHelper::OnFileCanReadWithoutBlocking, + base::Unretained(this))); + } + @@ -176,7 +176,7 @@ + const scoped_refptr origin_task_runner_; + std::unique_ptr file_watcher_; + -+ DISALLOW_COPY_AND_ASSIGN(BlockingTaskHelper); ++ DISALLOW_COPY_AND_ASSIGN(BlockingTaskRunnerHelper); +}; + +HidConnectionFreeBSD::HidConnectionFreeBSD( @@ -184,12 +184,12 @@ + base::ScopedFD fd, + scoped_refptr blocking_task_runner) + : HidConnection(device_info), -+ blocking_task_runner_(std::move(blocking_task_runner)), -+ weak_factory_(this) { -+ helper_ = std::make_unique(std::move(fd), device_info, -+ weak_factory_.GetWeakPtr()); ++ helper_(nullptr, base::OnTaskRunnerDeleter(blocking_task_runner)), ++ blocking_task_runner_(std::move(blocking_task_runner)) { ++ helper_.reset(new BlockingTaskRunnerHelper(std::move(fd), device_info, ++ weak_factory_.GetWeakPtr())); + blocking_task_runner_->PostTask( -+ FROM_HERE, base::BindOnce(&BlockingTaskHelper::Start, ++ FROM_HERE, base::BindOnce(&BlockingTaskRunnerHelper::Start, + base::Unretained(helper_.get()))); +} + @@ -208,7 +208,7 @@ + + blocking_task_runner_->PostTask( + FROM_HERE, -+ base::BindOnce(&BlockingTaskHelper::Write, base::Unretained(helper_.get()), ++ base::BindOnce(&BlockingTaskRunnerHelper::Write, base::Unretained(helper_.get()), + buffer, std::move(callback))); +} + @@ -224,7 +224,7 @@ + + blocking_task_runner_->PostTask( + FROM_HERE, -+ base::BindOnce(&BlockingTaskHelper::GetFeatureReport, ++ base::BindOnce(&BlockingTaskRunnerHelper::GetFeatureReport, + base::Unretained(helper_.get()), report_id, + buffer, std::move(callback))); +} @@ -236,7 +236,7 @@ + FROM_HERE, base::BlockingType::MAY_BLOCK); + blocking_task_runner_->PostTask( + FROM_HERE, -+ base::BindOnce(&BlockingTaskHelper::SendFeatureReport, ++ base::BindOnce(&BlockingTaskRunnerHelper::SendFeatureReport, + base::Unretained(helper_.get()), buffer, std::move(callback))); +} + Index: patch-services_device_hid_hid__connection__freebsd.h =================================================================== --- patch-services_device_hid_hid__connection__freebsd.h (revision 542828) +++ patch-services_device_hid_hid__connection__freebsd.h (working copy) @@ -1,6 +1,6 @@ ---- services/device/hid/hid_connection_freebsd.h.orig 2019-05-01 15:21:27 UTC -+++ services/device/hid/hid_connection_freebsd.h -@@ -0,0 +1,68 @@ +--- services/device/hid/hid_connection_freebsd.h.orig 2020-07-18 19:40:14.412550000 -0700 ++++ services/device/hid/hid_connection_freebsd.h 2020-07-21 19:15:28.613027000 -0700 +@@ -0,0 +1,65 @@ +// Copyright (c) 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. @@ -13,10 +13,9 @@ + +#include "base/files/scoped_file.h" +#include "base/macros.h" -+#include "base/memory/ptr_util.h" ++#include "base/memory/weak_ptr.h" +#include "base/memory/ref_counted_memory.h" -+#include "base/memory/weak_ptr.h" -+#include "base/sequence_checker.h" ++#include "base/sequenced_task_runner.h" +#include "services/device/hid/hid_connection.h" + +namespace base { @@ -38,7 +37,7 @@ + + private: + friend class base::RefCountedThreadSafe; -+ class BlockingTaskHelper; ++ class BlockingTaskRunnerHelper; + + ~HidConnectionFreeBSD() override; + @@ -54,15 +53,13 @@ + // |helper_| lives on the sequence to which |blocking_task_runner_| posts + // tasks so all calls must be posted there including this object's + // destruction. -+ std::unique_ptr helper_; ++ std::unique_ptr helper_; + + const scoped_refptr blocking_task_runner_; + const scoped_refptr task_runner_; + -+ SEQUENCE_CHECKER(sequence_checker_); ++ base::WeakPtrFactory weak_factory_{this}; + -+ base::WeakPtrFactory weak_factory_; -+ + DISALLOW_COPY_AND_ASSIGN(HidConnectionFreeBSD); +}; + Index: patch-services_device_hid_hid__service__freebsd.cc =================================================================== --- patch-services_device_hid_hid__service__freebsd.cc (revision 542828) +++ patch-services_device_hid_hid__service__freebsd.cc (working copy) @@ -1,6 +1,6 @@ ---- services/device/hid/hid_service_freebsd.cc.orig 2020-03-17 15:11:01 UTC -+++ services/device/hid/hid_service_freebsd.cc -@@ -0,0 +1,383 @@ +--- services/device/hid/hid_service_freebsd.cc.orig 2020-07-18 19:40:14.415772000 -0700 ++++ services/device/hid/hid_service_freebsd.cc 2020-07-21 20:00:55.322907000 -0700 +@@ -0,0 +1,382 @@ +// 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. @@ -48,7 +48,7 @@ + callback(std::move(callback)), + task_runner(base::ThreadTaskRunnerHandle::Get()), + blocking_task_runner( -+ base::CreateSequencedTaskRunner(kBlockingTaskTraits)) {} ++ base::ThreadPool::CreateSequencedTaskRunner(kBlockingTaskTraits)) {} + ~ConnectParams() {} + + scoped_refptr device_info; @@ -58,9 +58,9 @@ + base::ScopedFD fd; +}; + -+class HidServiceFreeBSD::BlockingTaskHelper { ++class HidServiceFreeBSD::BlockingTaskRunnerHelper { + public: -+ BlockingTaskHelper(base::WeakPtr service) ++ BlockingTaskRunnerHelper(base::WeakPtr service) + : service_(std::move(service)), + task_runner_(base::ThreadTaskRunnerHandle::Get()) { + DETACH_FROM_SEQUENCE(sequence_checker_); @@ -69,7 +69,7 @@ + devd_buffer_ = new net::IOBufferWithSize(1024); + } + -+ ~BlockingTaskHelper() { ++ ~BlockingTaskRunnerHelper() { + } + + void Start() { @@ -173,7 +173,7 @@ + report_descriptor, + device_node)); + -+ task_runner_->PostTask(FROM_HERE, base::Bind(&HidServiceFreeBSD::AddDevice, ++ task_runner_->PostTask(FROM_HERE, base::BindOnce(&HidServiceFreeBSD::AddDevice, + service_, device_info)); + } + @@ -231,7 +231,7 @@ + + devd_fd_.reset(devd_fd); + file_watcher_ = base::FileDescriptorWatcher::WatchReadable( -+ devd_fd_.get(), base::Bind(&BlockingTaskHelper::OnDevdMessageCanBeRead, ++ devd_fd_.get(), base::Bind(&BlockingTaskRunnerHelper::OnDevdMessageCanBeRead, + base::Unretained(this))); + } + @@ -265,7 +265,7 @@ + if (permissions_checks_attempts_.find(device_name) == permissions_checks_attempts_.end()) { + permissions_checks_attempts_.insert(std::pair(device_name, kMaxPermissionChecks)); + timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(1), -+ this, &BlockingTaskHelper::CheckPendingPermissionChange); ++ this, &BlockingTaskRunnerHelper::CheckPendingPermissionChange); + } + } + } @@ -298,18 +298,17 @@ + scoped_refptr devd_buffer_; + std::map permissions_checks_attempts_; + -+ DISALLOW_COPY_AND_ASSIGN(BlockingTaskHelper); ++ DISALLOW_COPY_AND_ASSIGN(BlockingTaskRunnerHelper); +}; + +HidServiceFreeBSD::HidServiceFreeBSD() -+ : task_runner_(base::ThreadTaskRunnerHandle::Get()), -+ blocking_task_runner_( -+ base::CreateSequencedTaskRunner(kBlockingTaskTraits)), -+ weak_factory_(this) { -+ helper_ = std::make_unique(weak_factory_.GetWeakPtr()); ++ : blocking_task_runner_( ++ base::ThreadPool::CreateSequencedTaskRunner(kBlockingTaskTraits)), ++ helper_(nullptr, base::OnTaskRunnerDeleter(blocking_task_runner_)) { ++ helper_.reset(new BlockingTaskRunnerHelper(weak_factory_.GetWeakPtr())); + blocking_task_runner_->PostTask( + FROM_HERE, -+ base::Bind(&BlockingTaskHelper::Start, base::Unretained(helper_.get()))); ++ base::BindOnce(&BlockingTaskRunnerHelper::Start, base::Unretained(helper_.get()))); +} + +HidServiceFreeBSD::~HidServiceFreeBSD() { Index: patch-services_device_hid_hid__service__freebsd.h =================================================================== --- patch-services_device_hid_hid__service__freebsd.h (revision 542828) +++ patch-services_device_hid_hid__service__freebsd.h (working copy) @@ -1,6 +1,6 @@ ---- services/device/hid/hid_service_freebsd.h.orig 2020-03-17 15:11:01 UTC -+++ services/device/hid/hid_service_freebsd.h -@@ -0,0 +1,47 @@ +--- services/device/hid/hid_service_freebsd.h.orig 2020-07-18 19:40:14.418200000 -0700 ++++ services/device/hid/hid_service_freebsd.h 2020-07-21 19:52:08.796704000 -0700 +@@ -0,0 +1,46 @@ +// 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. @@ -30,17 +30,16 @@ + + private: + struct ConnectParams; -+ class BlockingTaskHelper; ++ class BlockingTaskRunnerHelper; + + static void OpenOnBlockingThread(std::unique_ptr params); + static void FinishOpen(std::unique_ptr params); + -+ const scoped_refptr task_runner_; + const scoped_refptr blocking_task_runner_; + // |helper_| lives on the sequence |blocking_task_runner_| posts to and holds + // a weak reference back to the service that owns it. -+ std::unique_ptr helper_; -+ base::WeakPtrFactory weak_factory_; ++ std::unique_ptr helper_; ++ base::WeakPtrFactory weak_factory_{this}; + + DISALLOW_COPY_AND_ASSIGN(HidServiceFreeBSD); +};