diff options
Diffstat (limited to 'chromium/components/webrtc')
8 files changed, 82 insertions, 51 deletions
diff --git a/chromium/components/webrtc/BUILD.gn b/chromium/components/webrtc/BUILD.gn index 44981f1895b..b9e6f308e9f 100644 --- a/chromium/components/webrtc/BUILD.gn +++ b/chromium/components/webrtc/BUILD.gn @@ -2,6 +2,10 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. +if (is_android) { + import("//build/config/android/rules.gni") +} + if (!is_ios) { source_set("media_stream_device_enumerator") { sources = [ @@ -95,3 +99,16 @@ source_set("unit_tests") { "//third_party/webrtc_overrides:metronome_like_task_queue_test", ] } + +if (is_android) { + java_cpp_features("java_features_srcjar") { + # External code should depend on ":components_webrtc_java" instead. + visibility = [ ":*" ] + sources = [ "//components/webrtc/thread_wrapper.cc" ] + template = + "//components/webrtc/java_templates/ComponentsWebRtcFeatures.java.tmpl" + } + android_library("components_webrtc_java") { + srcjar_deps = [ ":java_features_srcjar" ] + } +} diff --git a/chromium/components/webrtc/fake_ssl_client_socket.cc b/chromium/components/webrtc/fake_ssl_client_socket.cc index ee11f24c48b..e41bac585d5 100644 --- a/chromium/components/webrtc/fake_ssl_client_socket.cc +++ b/chromium/components/webrtc/fake_ssl_client_socket.cc @@ -6,13 +6,13 @@ #include <stddef.h> #include <stdint.h> + #include <cstdlib> #include <cstring> #include <utility> #include "base/bind.h" #include "base/compiler_specific.h" -#include "base/cxx17_backports.h" #include "base/logging.h" #include "net/base/io_buffer.h" #include "net/base/net_errors.h" @@ -81,12 +81,12 @@ scoped_refptr<net::DrainableIOBuffer> NewDrainableIOBufferWithSize(int size) { base::StringPiece FakeSSLClientSocket::GetSslClientHello() { return base::StringPiece(reinterpret_cast<const char*>(kSslClientHello), - base::size(kSslClientHello)); + std::size(kSslClientHello)); } base::StringPiece FakeSSLClientSocket::GetSslServerHello() { return base::StringPiece(reinterpret_cast<const char*>(kSslServerHello), - base::size(kSslServerHello)); + std::size(kSslServerHello)); } FakeSSLClientSocket::FakeSSLClientSocket( @@ -94,10 +94,10 @@ FakeSSLClientSocket::FakeSSLClientSocket( : transport_socket_(std::move(transport_socket)), next_handshake_state_(STATE_NONE), handshake_completed_(false), - write_buf_(NewDrainableIOBufferWithSize(base::size(kSslClientHello))), - read_buf_(NewDrainableIOBufferWithSize(base::size(kSslServerHello))) { + write_buf_(NewDrainableIOBufferWithSize(std::size(kSslClientHello))), + read_buf_(NewDrainableIOBufferWithSize(std::size(kSslServerHello))) { CHECK(transport_socket_.get()); - std::memcpy(write_buf_->data(), kSslClientHello, base::size(kSslClientHello)); + std::memcpy(write_buf_->data(), kSslClientHello, std::size(kSslClientHello)); } FakeSSLClientSocket::~FakeSSLClientSocket() {} @@ -301,7 +301,7 @@ net::Error FakeSSLClientSocket::ProcessVerifyServerHelloDone(size_t read) { return net::ERR_UNEXPECTED; } const uint8_t* expected_data_start = - &kSslServerHello[base::size(kSslServerHello) - + &kSslServerHello[std::size(kSslServerHello) - read_buf_->BytesRemaining()]; if (std::memcmp(expected_data_start, read_buf_->data(), read) != 0) { return net::ERR_UNEXPECTED; diff --git a/chromium/components/webrtc/fake_ssl_client_socket_unittest.cc b/chromium/components/webrtc/fake_ssl_client_socket_unittest.cc index ca9f06e5933..46468bde309 100644 --- a/chromium/components/webrtc/fake_ssl_client_socket_unittest.cc +++ b/chromium/components/webrtc/fake_ssl_client_socket_unittest.cc @@ -12,7 +12,6 @@ #include <utility> #include <vector> -#include "base/cxx17_backports.h" #include "base/memory/ref_counted.h" #include "base/test/task_environment.h" #include "net/base/completion_once_callback.h" @@ -158,9 +157,9 @@ class FakeSSLClientSocketTest : public testing::Test { AddChunkedOps(ssl_server_hello, read_chunk_size, mode, &reads); AddChunkedOps(ssl_client_hello, write_chunk_size, mode, &writes); reads.push_back( - net::MockRead(mode, kReadTestData, base::size(kReadTestData))); + net::MockRead(mode, kReadTestData, std::size(kReadTestData))); writes.push_back( - net::MockWrite(mode, kWriteTestData, base::size(kWriteTestData))); + net::MockWrite(mode, kWriteTestData, std::size(kWriteTestData))); } SetData(mock_connect, &reads, &writes); @@ -175,7 +174,7 @@ class FakeSSLClientSocketTest : public testing::Test { } ExpectStatus(mode, net::OK, status, &connect_callback); if (fake_ssl_client_socket.IsConnected()) { - int read_len = base::size(kReadTestData); + int read_len = std::size(kReadTestData); int read_buf_len = 2 * read_len; auto read_buf = base::MakeRefCounted<net::IOBuffer>(read_buf_len); @@ -188,9 +187,9 @@ class FakeSSLClientSocketTest : public testing::Test { base::MakeRefCounted<net::StringIOBuffer>(kWriteTestData); net::TestCompletionCallback write_callback; int write_status = fake_ssl_client_socket.Write( - write_buf.get(), base::size(kWriteTestData), + write_buf.get(), std::size(kWriteTestData), write_callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS); - ExpectStatus(mode, base::size(kWriteTestData), write_status, + ExpectStatus(mode, std::size(kWriteTestData), write_status, &write_callback); } else { ADD_FAILURE(); @@ -239,7 +238,7 @@ class FakeSSLClientSocketTest : public testing::Test { if (error == ERR_MALFORMED_SERVER_HELLO) { static const char kBadData[] = "BAD_DATA"; reads[index].data = kBadData; - reads[index].data_len = base::size(kBadData); + reads[index].data_len = std::size(kBadData); } else { reads[index].result = error; reads[index].data = NULL; diff --git a/chromium/components/webrtc/java_templates/ComponentsWebRtcFeatures.java.tmpl b/chromium/components/webrtc/java_templates/ComponentsWebRtcFeatures.java.tmpl new file mode 100644 index 00000000000..0586785974b --- /dev/null +++ b/chromium/components/webrtc/java_templates/ComponentsWebRtcFeatures.java.tmpl @@ -0,0 +1,16 @@ +// Copyright 2022 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. + +package org.chromium.components.webrtc; + +/** + * Contains features that are specific to components/webrtc/. + */ +public final class ComponentsWebRtcFeatures {{ + +{NATIVE_FEATURES} + + // Prevents instantiation. + private ComponentsWebRtcFeatures() {{}} +}} diff --git a/chromium/components/webrtc/media_stream_devices_controller.cc b/chromium/components/webrtc/media_stream_devices_controller.cc index 261a62cdf27..4f0b40519c5 100644 --- a/chromium/components/webrtc/media_stream_devices_controller.cc +++ b/chromium/components/webrtc/media_stream_devices_controller.cc @@ -9,7 +9,6 @@ #include <vector> #include "base/bind.h" -#include "base/metrics/histogram_functions.h" #include "build/build_config.h" #include "components/permissions/permission_manager.h" #include "components/permissions/permission_result.h" @@ -117,8 +116,6 @@ void MediaStreamDevicesController::RequestPermissions( bool has_pan_tilt_zoom_camera = controller->HasAvailableDevices( ContentSettingsType::CAMERA_PAN_TILT_ZOOM, request.requested_video_device_id); - base::UmaHistogramBoolean("WebRTC.MediaStreamDevices.HasPanTiltZoomCamera", - has_pan_tilt_zoom_camera); // Request CAMERA_PAN_TILT_ZOOM only if the website requested the // pan-tilt-zoom permission and there are suitable PTZ capable devices @@ -357,6 +354,13 @@ MediaStreamDevices MediaStreamDevicesController::GetDevices( } break; } + case blink::MEDIA_GET_OPEN_DEVICE: { + // Transferred tracks, that use blink::MEDIA_GET_OPEN_DEVICE type, do not + // need to get permissions for MediaStreamDevice as those are controlled + // by the original context. + NOTREACHED(); + break; + } case blink::MEDIA_DEVICE_ACCESS: { // Get the default devices for the request. enumerator_->GetDefaultDevicesForBrowserContext( diff --git a/chromium/components/webrtc/thread_wrapper.cc b/chromium/components/webrtc/thread_wrapper.cc index eae08b9c4d4..0d188110721 100644 --- a/chromium/components/webrtc/thread_wrapper.cc +++ b/chromium/components/webrtc/thread_wrapper.cc @@ -6,14 +6,15 @@ #include <stddef.h> #include <stdint.h> + #include <memory> #include "base/bind.h" #include "base/callback_helpers.h" -#include "base/cxx17_backports.h" #include "base/lazy_instance.h" #include "base/memory/raw_ptr.h" #include "base/sequence_checker.h" +#include "base/synchronization/waitable_event.h" #include "base/thread_annotations.h" #include "base/threading/thread_local.h" #include "base/threading/thread_task_runner_handle.h" @@ -21,6 +22,7 @@ #include "base/trace_event/trace_event.h" #include "third_party/abseil-cpp/absl/types/optional.h" #include "third_party/webrtc/rtc_base/physical_socket_server.h" +#include "third_party/webrtc_overrides/metronome_source.h" namespace webrtc { namespace { @@ -100,26 +102,22 @@ base::LazyInstance<base::ThreadLocalPointer<ThreadWrapper>>::DestructorAtExit g_jingle_thread_wrapper = LAZY_INSTANCE_INITIALIZER; // static -void ThreadWrapper::EnsureForCurrentMessageLoop( - scoped_refptr<blink::MetronomeSource> metronome_source) { +void ThreadWrapper::EnsureForCurrentMessageLoop() { if (ThreadWrapper::current() == nullptr) { - std::unique_ptr<ThreadWrapper> wrapper = ThreadWrapper::WrapTaskRunner( - metronome_source, base::ThreadTaskRunnerHandle::Get()); + std::unique_ptr<ThreadWrapper> wrapper = + ThreadWrapper::WrapTaskRunner(base::ThreadTaskRunnerHandle::Get()); base::CurrentThread::Get()->AddDestructionObserver(wrapper.release()); } DCHECK_EQ(rtc::Thread::Current(), current()); - DCHECK_EQ(current()->metronome_source_, metronome_source); } std::unique_ptr<ThreadWrapper> ThreadWrapper::WrapTaskRunner( - scoped_refptr<blink::MetronomeSource> metronome_source, scoped_refptr<base::SingleThreadTaskRunner> task_runner) { DCHECK(!ThreadWrapper::current()); DCHECK(task_runner->BelongsToCurrentThread()); - std::unique_ptr<ThreadWrapper> result( - new ThreadWrapper(std::move(metronome_source), task_runner)); + std::unique_ptr<ThreadWrapper> result(new ThreadWrapper(task_runner)); g_jingle_thread_wrapper.Get().Set(result.get()); return result; } @@ -137,12 +135,11 @@ void ThreadWrapper::SetLatencyAndTaskDurationCallbacks( } ThreadWrapper::ThreadWrapper( - scoped_refptr<blink::MetronomeSource> metronome_source, scoped_refptr<base::SingleThreadTaskRunner> task_runner) : Thread(std::make_unique<rtc::PhysicalSocketServer>()), - metronome_source_(std::move(metronome_source)), task_runner_(task_runner), send_allowed_(false), + use_metronome_(base::FeatureList::IsEnabled(kThreadWrapperUsesMetronome)), last_task_id_(0), pending_send_event_(base::WaitableEvent::ResetPolicy::MANUAL, base::WaitableEvent::InitialState::NOT_SIGNALED) { @@ -276,7 +273,7 @@ void ThreadWrapper::Send(const rtc::Location& posted_from, while (!pending_send.done_event.IsSignaled()) { base::WaitableEvent* events[] = {&pending_send.done_event, ¤t_thread->pending_send_event_}; - size_t event = base::WaitableEvent::WaitMany(events, base::size(events)); + size_t event = base::WaitableEvent::WaitMany(events, std::size(events)); DCHECK(event == 0 || event == 1); if (event == 1) @@ -344,10 +341,10 @@ void ThreadWrapper::PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task, uint32_t milliseconds) { base::TimeTicks target_time = base::TimeTicks::Now() + base::Milliseconds(milliseconds); - if (metronome_source_) { + if (use_metronome_) { // Coalesce tasks onto the metronome. base::TimeTicks snapped_target_time = - metronome_source_->GetTimeSnappedToNextMetronomeTick(target_time); + blink::MetronomeSource::TimeSnappedToNextTick(target_time); if (coalesced_tasks_.QueueDelayedTask(target_time, std::move(task), snapped_target_time)) { task_runner_->PostDelayedTaskAt( diff --git a/chromium/components/webrtc/thread_wrapper.h b/chromium/components/webrtc/thread_wrapper.h index 8d48e101712..df5572fb746 100644 --- a/chromium/components/webrtc/thread_wrapper.h +++ b/chromium/components/webrtc/thread_wrapper.h @@ -23,7 +23,6 @@ #include "third_party/abseil-cpp/absl/types/optional.h" #include "third_party/webrtc/rtc_base/thread.h" #include "third_party/webrtc_overrides/coalesced_tasks.h" -#include "third_party/webrtc_overrides/metronome_source.h" namespace webrtc { @@ -53,13 +52,11 @@ class ThreadWrapper : public base::CurrentThread::DestructionObserver, // Create ThreadWrapper for the current thread if it hasn't been created // yet. The thread wrapper is destroyed automatically when the current // MessageLoop is destroyed. - static void EnsureForCurrentMessageLoop( - scoped_refptr<blink::MetronomeSource> metronome_source = nullptr); + static void EnsureForCurrentMessageLoop(); // Creates ThreadWrapper for |task_runner| that runs tasks on the // current thread. static std::unique_ptr<ThreadWrapper> WrapTaskRunner( - scoped_refptr<blink::MetronomeSource> metronome_source, scoped_refptr<base::SingleThreadTaskRunner> task_runner); // Returns thread wrapper for the current thread or nullptr if it doesn't @@ -141,8 +138,8 @@ class ThreadWrapper : public base::CurrentThread::DestructionObserver, struct PendingSend; class PostTaskLatencySampler; - ThreadWrapper(scoped_refptr<blink::MetronomeSource> metronome_source, - scoped_refptr<base::SingleThreadTaskRunner> task_runner); + explicit ThreadWrapper( + scoped_refptr<base::SingleThreadTaskRunner> task_runner); void PostTaskInternal(const rtc::Location& posted_from, int delay_ms, @@ -172,15 +169,12 @@ class ThreadWrapper : public base::CurrentThread::DestructionObserver, // |task_start_timestamp|. void FinalizeRunTask(absl::optional<base::TimeTicks> task_start_timestamp); - // TODO(https://crbug.com/1296138): When MetronomeSource is simplified, - // snapping to metronome ticks will be a static function, and we can remove - // this object reference. - const scoped_refptr<blink::MetronomeSource> metronome_source_; // Task runner used to execute messages posted on this thread. scoped_refptr<base::SingleThreadTaskRunner> task_runner_; bool send_allowed_; + const bool use_metronome_; // |lock_| must be locked when accessing |messages_|. base::Lock lock_; int last_task_id_; @@ -190,9 +184,9 @@ class ThreadWrapper : public base::CurrentThread::DestructionObserver, std::unique_ptr<PostTaskLatencySampler> latency_sampler_; SampledDurationCallback task_latency_callback_; SampledDurationCallback task_duration_callback_; - // If |metronome_source_| is used, low precision tasks are coalesced onto - // metronome ticks and stored in |coalesced_tasks_| until they are ready to - // run. + // If |kThreadWrapperUsesMetronome| is enabled, low precision tasks are + // coalesced onto metronome ticks and stored in |coalesced_tasks_| until they + // are ready to run. blink::CoalescedTasks coalesced_tasks_; base::WeakPtr<ThreadWrapper> weak_ptr_; diff --git a/chromium/components/webrtc/thread_wrapper_unittest.cc b/chromium/components/webrtc/thread_wrapper_unittest.cc index d620340c0fd..c7d0c157c81 100644 --- a/chromium/components/webrtc/thread_wrapper_unittest.cc +++ b/chromium/components/webrtc/thread_wrapper_unittest.cc @@ -13,6 +13,7 @@ #include "base/synchronization/waitable_event.h" #include "base/task/single_thread_task_runner.h" #include "base/task/thread_pool.h" +#include "base/test/scoped_feature_list.h" #include "base/test/task_environment.h" #include "base/threading/thread.h" #include "testing/gmock/include/gmock/gmock.h" @@ -317,20 +318,23 @@ TEST_F(ThreadWrapperTest, Dispose) { // Provider needed for the MetronomeLikeTaskQueueTest suite. class ThreadWrapperProvider : public blink::MetronomeLikeTaskQueueProvider { public: - static constexpr base::TimeDelta kMetronomeTick = base::Hertz(64); - void Initialize() override { - scoped_refptr<blink::MetronomeSource> metronome_source = - base::MakeRefCounted<blink::MetronomeSource>(base::TimeTicks::Now(), - kMetronomeTick); - ThreadWrapper::EnsureForCurrentMessageLoop(std::move(metronome_source)); + scoped_feature_list_.InitAndEnableFeature(kThreadWrapperUsesMetronome); + ThreadWrapper::EnsureForCurrentMessageLoop(); thread_ = rtc::Thread::Current(); } - base::TimeDelta MetronomeTick() const override { return kMetronomeTick; } + base::TimeDelta DeltaToNextTick() const override { + base::TimeTicks now = base::TimeTicks::Now(); + return blink::MetronomeSource::TimeSnappedToNextTick(now) - now; + } + base::TimeDelta MetronomeTick() const override { + return blink::MetronomeSource::Tick(); + } webrtc::TaskQueueBase* TaskQueue() const override { return thread_; } private: + base::test::ScopedFeatureList scoped_feature_list_; // ThreadWrapper destroys itself when |message_loop_| is destroyed. raw_ptr<rtc::Thread> thread_; }; |