admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adopt absl::string_view in rtc_base/ (straightforward cases)

Browse Source 
Bug: webrtc:13579
Change-Id: I240db6285abb22652242bc0b2ebe9844ec4a45f0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/258723
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Ali Tofigh <alito@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36561}
This commit is contained in:
Ali Tofigh 2022-04-13 12:55:15 +02:00 committed by WebRTC LUCI CQ
parent a62136ac74
commit 2ab914c6ab
40 changed files with 165 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/audio_device/dummy/file_audio_device.cc
View File

@ -206,7 +206,7 @@ int32_t FileAudioDevice::StartPlayout() {
// PLAYOUT
if (!_outputFilename.empty()) {
_outputFile = FileWrapper::OpenWriteOnly(_outputFilename.c_str());
_outputFile = FileWrapper::OpenWriteOnly(_outputFilename);
if (!_outputFile.is_open()) {
RTC_LOG(LS_ERROR) << "Failed to open playout file: " << _outputFilename;
_playing = false;
@ -266,7 +266,7 @@ int32_t FileAudioDevice::StartRecording() {
}
if (!_inputFilename.empty()) {
_inputFile = FileWrapper::OpenReadOnly(_inputFilename.c_str());
_inputFile = FileWrapper::OpenReadOnly(_inputFilename);
if (!_inputFile.is_open()) {
RTC_LOG(LS_ERROR) << "Failed to open audio input file: "
<< _inputFilename;

4
modules/audio_processing/aec_dump/aec_dump_impl.cc
View File

@ -255,8 +255,8 @@ std::unique_ptr<AecDump> AecDumpFactory::Create(webrtc::FileWrapper file,
std::unique_ptr<AecDump> AecDumpFactory::Create(std::string file_name,
int64_t max_log_size_bytes,
rtc::TaskQueue* worker_queue) {
return Create(FileWrapper::OpenWriteOnly(file_name.c_str()),
max_log_size_bytes, worker_queue);
return Create(FileWrapper::OpenWriteOnly(file_name), max_log_size_bytes,
worker_queue);
}
std::unique_ptr<AecDump> AecDumpFactory::Create(FILE* handle,

2
modules/audio_processing/audio_processing_unittest.cc
View File

@ -1600,7 +1600,7 @@ TEST_F(ApmTest, DebugDumpFromFileHandle) {
const std::string filename =
test::TempFilename(test::OutputPath(), "debug_aec");
FileWrapper f = FileWrapper::OpenWriteOnly(filename.c_str());
FileWrapper f = FileWrapper::OpenWriteOnly(filename);
ASSERT_TRUE(f.is_open());
#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP

2
modules/audio_processing/test/wav_based_simulator.cc
View File

@ -25,7 +25,7 @@ namespace test {
std::vector<WavBasedSimulator::SimulationEventType>
WavBasedSimulator::GetCustomEventChain(const std::string& filename) {
std::vector<WavBasedSimulator::SimulationEventType> call_chain;
FileWrapper file_wrapper = FileWrapper::OpenReadOnly(filename.c_str());
FileWrapper file_wrapper = FileWrapper::OpenReadOnly(filename);
RTC_CHECK(file_wrapper.is_open())
<< "Could not open the custom call order file, reverting "

24
modules/audio_processing/transient/file_utils_unittest.cc
View File

@ -159,7 +159,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ConvertDoubleToByteArray) {
TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16BufferFromFile) {
std::string test_filename = kTestFileName;
FileWrapper file = FileWrapper::OpenReadOnly(test_filename.c_str());
FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileName.c_str();
@ -197,7 +197,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16BufferFromFile) {
TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToFloatBuffer) {
std::string test_filename = kTestFileName;
FileWrapper file = FileWrapper::OpenReadOnly(test_filename.c_str());
FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileName.c_str();
@ -237,7 +237,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToFloatBuffer) {
TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToDoubleBuffer) {
std::string test_filename = kTestFileName;
FileWrapper file = FileWrapper::OpenReadOnly(test_filename.c_str());
FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileName.c_str();
@ -275,7 +275,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToDoubleBuffer) {
TEST_F(TransientFileUtilsTest, MAYBE_ReadFloatBufferFromFile) {
std::string test_filename = kTestFileNamef;
FileWrapper file = FileWrapper::OpenReadOnly(test_filename.c_str());
FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileNamef.c_str();
@ -311,7 +311,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadFloatBufferFromFile) {
TEST_F(TransientFileUtilsTest, MAYBE_ReadDoubleBufferFromFile) {
std::string test_filename = kTestFileName;
FileWrapper file = FileWrapper::OpenReadOnly(test_filename.c_str());
FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileName.c_str();
@ -348,7 +348,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName.c_str());
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -365,7 +365,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
file.Close();
file = FileWrapper::OpenReadOnly(kOutFileName.c_str());
file = FileWrapper::OpenReadOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -384,7 +384,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName.c_str());
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -401,7 +401,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
file.Close();
file = FileWrapper::OpenReadOnly(kOutFileName.c_str());
file = FileWrapper::OpenReadOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -420,7 +420,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName.c_str());
FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -437,7 +437,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
file.Close();
file = FileWrapper::OpenReadOnly(kOutFileName.c_str());
file = FileWrapper::OpenReadOnly(kOutFileName);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
@ -472,7 +472,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_ExpectedErrorReturnValues) {
EXPECT_EQ(0u, WriteInt16BufferToFile(&file, 1, int16_buffer.get()));
EXPECT_EQ(0u, WriteDoubleBufferToFile(&file, 1, double_buffer.get()));
file = FileWrapper::OpenReadOnly(test_filename.c_str());
file = FileWrapper::OpenReadOnly(test_filename);
ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
<< kTestFileName.c_str();

4
modules/audio_processing/transient/transient_detector_unittest.cc
View File

@ -48,7 +48,7 @@ TEST(TransientDetectorTest, CorrectnessBasedOnFiles) {
<< (sample_rate_hz / 1000) << "kHz";
FileWrapper detect_file = FileWrapper::OpenReadOnly(
test::ResourcePath(detect_file_name.str(), "dat").c_str());
test::ResourcePath(detect_file_name.str(), "dat"));
bool file_opened = detect_file.is_open();
ASSERT_TRUE(file_opened) << "File could not be opened.\n"
@ -60,7 +60,7 @@ TEST(TransientDetectorTest, CorrectnessBasedOnFiles) {
<< (sample_rate_hz / 1000) << "kHz";
FileWrapper audio_file = FileWrapper::OpenReadOnly(
test::ResourcePath(audio_file_name.str(), "pcm").c_str());
test::ResourcePath(audio_file_name.str(), "pcm"));
// Create detector.
TransientDetector detector(sample_rate_hz);

6
modules/audio_processing/transient/wpd_tree_unittest.cc
View File

@ -88,7 +88,7 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
rtc::StringBuilder matlab_stream;
matlab_stream << "audio_processing/transient/wpd" << i;
std::string matlab_string = test::ResourcePath(matlab_stream.str(), "dat");
matlab_files_data[i] = FileWrapper::OpenReadOnly(matlab_string.c_str());
matlab_files_data[i] = FileWrapper::OpenReadOnly(matlab_string);
bool file_opened = matlab_files_data[i].is_open();
ASSERT_TRUE(file_opened) << "File could not be opened.\n" << matlab_string;
@ -98,7 +98,7 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
out_stream << test::OutputPath() << "wpd_" << i << ".out";
std::string out_string = out_stream.str();
out_files_data[i] = FileWrapper::OpenWriteOnly(out_string.c_str());
out_files_data[i] = FileWrapper::OpenWriteOnly(out_string);
file_opened = out_files_data[i].is_open();
ASSERT_TRUE(file_opened) << "File could not be opened.\n" << out_string;
@ -108,7 +108,7 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
std::string test_file_name = test::ResourcePath(
"audio_processing/transient/ajm-macbook-1-spke16m", "pcm");
FileWrapper test_file = FileWrapper::OpenReadOnly(test_file_name.c_str());
FileWrapper test_file = FileWrapper::OpenReadOnly(test_file_name);
bool file_opened = test_file.is_open();
ASSERT_TRUE(file_opened) << "File could not be opened.\n" << test_file_name;

1
rtc_base/BUILD.gn
View File

@ -703,6 +703,7 @@ rtc_library("net_helpers") {
":win32",
]
}
absl_deps = [ "//third_party/abseil-cpp/absl/strings" ]
}
rtc_library("async_resolver_interface") {

9
rtc_base/async_resolver.cc
View File

@ -14,6 +14,7 @@
#include <string>
#include <utility>
#include "absl/strings/string_view.h"
#include "api/ref_counted_base.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
@ -66,7 +67,7 @@ void PostTaskToGlobalQueue(std::unique_ptr<webrtc::QueuedTask> task) {
} // namespace
#endif
int ResolveHostname(const std::string& hostname,
int ResolveHostname(absl::string_view hostname,
int family,
std::vector<IPAddress>* addresses) {
#ifdef __native_client__
@ -99,7 +100,8 @@ int ResolveHostname(const std::string& hostname,
// https://android.googlesource.com/platform/bionic/+/
// 7e0bfb511e85834d7c6cb9631206b62f82701d60/libc/netbsd/net/getaddrinfo.c#1657
hints.ai_flags = AI_ADDRCONFIG;
int ret = getaddrinfo(hostname.c_str(), nullptr, &hints, &result);
int ret =
getaddrinfo(std::string(hostname).c_str(), nullptr, &hints, &result);
if (ret != 0) {
return ret;
}
@ -151,8 +153,7 @@ void AsyncResolver::Start(const SocketAddress& addr) {
[this, addr, caller_task_queue = webrtc::TaskQueueBase::Current(),
state = state_] {
std::vector<IPAddress> addresses;
int error =
ResolveHostname(addr.hostname().c_str(), addr.family(), &addresses);
int error = ResolveHostname(addr.hostname(), addr.family(), &addresses);
webrtc::MutexLock lock(&state->mutex);
if (state->status == State::Status::kLive) {
caller_task_queue->PostTask(webrtc::ToQueuedTask(

5
rtc_base/event_tracer.cc
View File

@ -17,6 +17,7 @@
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/sequence_checker.h"
#include "rtc_base/atomic_ops.h"
#include "rtc_base/checks.h"
@ -367,11 +368,11 @@ void StartInternalCaptureToFile(FILE* file) {
}
}
bool StartInternalCapture(const char* filename) {
bool StartInternalCapture(absl::string_view filename) {
if (!g_event_logger)
return false;
FILE* file = fopen(filename, "w");
FILE* file = fopen(std::string(filename).c_str(), "w");
if (!file) {
RTC_LOG(LS_ERROR) << "Failed to open trace file '" << filename
<< "' for writing.";

3
rtc_base/event_tracer.h
View File

@ -28,6 +28,7 @@
#include <stdio.h>
#include "absl/strings/string_view.h"
#include "rtc_base/system/rtc_export.h"
namespace webrtc {
@ -73,7 +74,7 @@ namespace rtc {
namespace tracing {
// Set up internal event tracer.
RTC_EXPORT void SetupInternalTracer();
RTC_EXPORT bool StartInternalCapture(const char* filename);
RTC_EXPORT bool StartInternalCapture(absl::string_view filename);
RTC_EXPORT void StartInternalCaptureToFile(FILE* file);
RTC_EXPORT void StopInternalCapture();
// Make sure we run this, this will tear down the internal tracing.

5
rtc_base/experiments/BUILD.gn
View File

@ -19,7 +19,10 @@ rtc_library("alr_experiment") {
"../../api:field_trials_view",
"../../api/transport:field_trial_based_config",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
absl_deps = [
"//third_party/abseil-cpp/absl/strings:strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}
rtc_library("field_trial_parser") {

5
rtc_base/experiments/alr_experiment.cc
View File

@ -15,6 +15,7 @@
#include <string>
#include "absl/strings/string_view.h"
#include "api/transport/field_trial_based_config.h"
#include "rtc_base/logging.h"
@ -39,7 +40,7 @@ bool AlrExperimentSettings::MaxOneFieldTrialEnabled(
}
absl::optional<AlrExperimentSettings>
AlrExperimentSettings::CreateFromFieldTrial(const char* experiment_name) {
AlrExperimentSettings::CreateFromFieldTrial(absl::string_view experiment_name) {
return AlrExperimentSettings::CreateFromFieldTrial(FieldTrialBasedConfig(),
experiment_name);
}
@ -47,7 +48,7 @@ AlrExperimentSettings::CreateFromFieldTrial(const char* experiment_name) {
absl::optional<AlrExperimentSettings>
AlrExperimentSettings::CreateFromFieldTrial(
const FieldTrialsView& key_value_config,
const char* experiment_name) {
absl::string_view experiment_name) {
absl::optional<AlrExperimentSettings> ret;
std::string group_name = key_value_config.Lookup(experiment_name);

5
rtc_base/experiments/alr_experiment.h
View File

@ -13,6 +13,7 @@
#include <stdint.h>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/field_trials_view.h"
@ -32,10 +33,10 @@ struct AlrExperimentSettings {
static const char kScreenshareProbingBweExperimentName[];
static const char kStrictPacingAndProbingExperimentName[];
static absl::optional<AlrExperimentSettings> CreateFromFieldTrial(
const char* experiment_name);
absl::string_view experiment_name);
static absl::optional<AlrExperimentSettings> CreateFromFieldTrial(
const FieldTrialsView& key_value_config,
const char* experiment_name);
absl::string_view experiment_name);
static bool MaxOneFieldTrialEnabled();
static bool MaxOneFieldTrialEnabled(const FieldTrialsView& key_value_config);

49
rtc_base/file_rotating_stream_unittest.cc
View File

@ -79,28 +79,28 @@ class MAYBE_FileRotatingStreamTest : public ::testing::Test {
// Checks that the stream reads in the expected contents and then returns an
// end of stream result.
void VerifyStreamRead(const char* expected_contents,
const size_t expected_length,
void VerifyStreamRead(absl::string_view expected_contents,
absl::string_view dir_path,
const char* file_prefix) {
absl::string_view file_prefix) {
size_t expected_length = expected_contents.size();
FileRotatingStreamReader reader(dir_path, file_prefix);
EXPECT_EQ(reader.GetSize(), expected_length);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
memset(buffer.get(), 0, expected_length);
EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
EXPECT_EQ(0,
memcmp(expected_contents.data(), buffer.get(), expected_length));
}
void VerifyFileContents(const char* expected_contents,
const size_t expected_length,
void VerifyFileContents(absl::string_view expected_contents,
absl::string_view file_path) {
size_t expected_length = expected_contents.size();
std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length + 1]);
webrtc::FileWrapper f =
webrtc::FileWrapper::OpenReadOnly(std::string(file_path));
webrtc::FileWrapper f = webrtc::FileWrapper::OpenReadOnly(file_path);
ASSERT_TRUE(f.is_open());
size_t size_read = f.Read(buffer.get(), expected_length + 1);
EXPECT_EQ(size_read, expected_length);
EXPECT_EQ(0, memcmp(expected_contents, buffer.get(),
EXPECT_EQ(0, memcmp(expected_contents.data(), buffer.get(),
std::min(expected_length, size_read)));
}
@ -151,8 +151,7 @@ TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
WriteAndFlush(message.c_str(), message.size());
// Since the max log size is 2, we will be causing rotation. Read from the
// next file.
VerifyFileContents(message.c_str(), message.size(),
stream_->GetFilePath(1));
VerifyFileContents(message, stream_->GetFilePath(1));
}
// Check that exactly three files exist.
for (size_t i = 0; i < arraysize(messages); ++i) {
@ -167,8 +166,7 @@ TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
// Reopen for read.
std::string expected_contents("bbccd");
VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
dir_path_, kFilePrefix);
VerifyStreamRead(expected_contents, dir_path_, kFilePrefix);
}
// Tests that a write operation (with dir name without delimiter) followed by a
@ -191,7 +189,7 @@ TEST_F(MAYBE_FileRotatingStreamTest, WriteWithoutDelimiterAndRead) {
// Reopen for read.
std::string expected_contents("bbccd");
VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
VerifyStreamRead(expected_contents,
dir_path_ + std::string(webrtc::test::kPathDelimiter),
kFilePrefix);
}
@ -215,8 +213,8 @@ TEST_F(MAYBE_FileRotatingStreamTest, WriteAndReadWithoutDelimiter) {
// Reopen for read.
std::string expected_contents("bbccd");
VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
dir_path_.substr(0, dir_path_.size() - 1), kFilePrefix);
VerifyStreamRead(expected_contents, dir_path_.substr(0, dir_path_.size() - 1),
kFilePrefix);
}
// Tests that writing data greater than the total capacity of the files
@ -230,11 +228,9 @@ TEST_F(MAYBE_FileRotatingStreamTest, WriteOverflowAndRead) {
std::string message("foobarbaz");
WriteAndFlush(message.c_str(), message.size());
std::string expected_file_contents("z");
VerifyFileContents(expected_file_contents.c_str(),
expected_file_contents.size(), stream_->GetFilePath(0));
VerifyFileContents(expected_file_contents, stream_->GetFilePath(0));
std::string expected_stream_contents("arbaz");
VerifyStreamRead(expected_stream_contents.c_str(),
expected_stream_contents.size(), dir_path_, kFilePrefix);
VerifyStreamRead(expected_stream_contents, dir_path_, kFilePrefix);
}
// Tests that the returned file paths have the right folder and prefix.
@ -286,15 +282,16 @@ class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
// Checks that the stream reads in the expected contents and then returns an
// end of stream result.
void VerifyStreamRead(const char* expected_contents,
const size_t expected_length,
void VerifyStreamRead(absl::string_view expected_contents,
absl::string_view dir_path) {
size_t expected_length = expected_contents.size();
CallSessionFileRotatingStreamReader reader(dir_path);
EXPECT_EQ(reader.GetSize(), expected_length);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
memset(buffer.get(), 0, expected_length);
EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
EXPECT_EQ(0,
memcmp(expected_contents.data(), buffer.get(), expected_length));
}
std::unique_ptr<CallSessionFileRotatingStream> stream_;
@ -310,8 +307,7 @@ TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
std::string message("abcde");
WriteAndFlush(message.c_str(), message.size());
std::string expected_contents("abe");
VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
dir_path_);
VerifyStreamRead(expected_contents, dir_path_);
}
// Tests that writing and reading to a stream with capacity lesser than 4MB
@ -323,8 +319,7 @@ TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmall) {
std::string message("123456789");
WriteAndFlush(message.c_str(), message.size());
std::string expected_contents("1234789");
VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
dir_path_);
VerifyStreamRead(expected_contents, dir_path_);
}
// Tests that writing and reading to a stream with capacity greater than 4MB

19
rtc_base/http_common.cc
View File

@ -120,14 +120,14 @@ const ConstantToLabel SECURITY_ERRORS[] = {
typedef std::pair<std::string, std::string> HttpAttribute;
typedef std::vector<HttpAttribute> HttpAttributeList;
inline bool IsEndOfAttributeName(size_t pos, size_t len, const char* data) {
if (pos >= len)
inline bool IsEndOfAttributeName(size_t pos, absl::string_view data) {
if (pos >= data.size())
return true;
if (isspace(static_cast<unsigned char>(data[pos])))
return true;
// The reason for this complexity is that some attributes may contain trailing
// equal signs (like base64 tokens in Negotiate auth headers)
if ((pos + 1 < len) && (data[pos] == '=') &&
if ((pos + 1 < data.size()) && (data[pos] == '=') &&
!isspace(static_cast<unsigned char>(data[pos + 1])) &&
(data[pos + 1] != '=')) {
return true;
@ -135,10 +135,10 @@ inline bool IsEndOfAttributeName(size_t pos, size_t len, const char* data) {
return false;
}
void HttpParseAttributes(const char* data,
size_t len,
void HttpParseAttributes(absl::string_view data,
HttpAttributeList& attributes) {
size_t pos = 0;
const size_t len = data.size();
while (true) {
// Skip leading whitespace
while ((pos < len) && isspace(static_cast<unsigned char>(data[pos]))) {
@ -151,12 +151,12 @@ void HttpParseAttributes(const char* data,
// Find end of attribute name
size_t start = pos;
while (!IsEndOfAttributeName(pos, len, data)) {
while (!IsEndOfAttributeName(pos, data)) {
++pos;
}
HttpAttribute attribute;
attribute.first.assign(data + start, data + pos);
attribute.first.assign(data.data() + start, data.data() + pos);
// Attribute has value?
if ((pos < len) && (data[pos] == '=')) {
@ -250,8 +250,7 @@ struct NegotiateAuthContext : public HttpAuthContext {
} // anonymous namespace
HttpAuthResult HttpAuthenticate(const char* challenge,
size_t len,
HttpAuthResult HttpAuthenticate(absl::string_view challenge,
const SocketAddress& server,
absl::string_view method,
absl::string_view uri,
@ -261,7 +260,7 @@ HttpAuthResult HttpAuthenticate(const char* challenge,
std::string& response,
std::string& auth_method) {
HttpAttributeList args;
HttpParseAttributes(challenge, len, args);
HttpParseAttributes(challenge, args);
HttpHasNthAttribute(args, 0, &auth_method, nullptr);
if (context && (context->auth_method != auth_method))

3
rtc_base/http_common.h
View File

@ -36,8 +36,7 @@ enum HttpAuthResult { HAR_RESPONSE, HAR_IGNORE, HAR_CREDENTIALS, HAR_ERROR };
// Start by passing a null pointer, then pass the same pointer each additional
// call. When the authentication attempt is finished, delete the context.
// TODO(bugs.webrtc.org/8905): Change "response" to "ZeroOnFreeBuffer".
HttpAuthResult HttpAuthenticate(const char* challenge,
size_t len,
HttpAuthResult HttpAuthenticate(absl::string_view challenge,
const SocketAddress& server,
absl::string_view method,
absl::string_view uri,

5
rtc_base/ip_address.cc
View File

@ -283,10 +283,9 @@ bool IPFromString(absl::string_view str, IPAddress* out) {
return false;
}
in_addr addr;
const std::string str_copy = std::string(str);
if (rtc::inet_pton(AF_INET, str_copy.c_str(), &addr) == 0) {
if (rtc::inet_pton(AF_INET, str, &addr) == 0) {
in6_addr addr6;
if (rtc::inet_pton(AF_INET6, str_copy.c_str(), &addr6) == 0) {
if (rtc::inet_pton(AF_INET6, str, &addr6) == 0) {
*out = IPAddress();
return false;
}

6
rtc_base/log_sinks.cc
View File

@ -20,8 +20,8 @@
namespace rtc {
FileRotatingLogSink::FileRotatingLogSink(const std::string& log_dir_path,
const std::string& log_prefix,
FileRotatingLogSink::FileRotatingLogSink(absl::string_view log_dir_path,
absl::string_view log_prefix,
size_t max_log_size,
size_t num_log_files)
: FileRotatingLogSink(new FileRotatingStream(log_dir_path,
@ -69,7 +69,7 @@ bool FileRotatingLogSink::DisableBuffering() {
}
CallSessionFileRotatingLogSink::CallSessionFileRotatingLogSink(
const std::string& log_dir_path,
absl::string_view log_dir_path,
size_t max_total_log_size)
: FileRotatingLogSink(
new CallSessionFileRotatingStream(log_dir_path, max_total_log_size)) {

6
rtc_base/log_sinks.h
View File

@ -28,8 +28,8 @@ class FileRotatingLogSink : public LogSink {
public:
// `num_log_files` must be greater than 1 and `max_log_size` must be greater
// than 0.
FileRotatingLogSink(const std::string& log_dir_path,
const std::string& log_prefix,
FileRotatingLogSink(absl::string_view log_dir_path,
absl::string_view log_prefix,
size_t max_log_size,
size_t num_log_files);
~FileRotatingLogSink() override;
@ -62,7 +62,7 @@ class FileRotatingLogSink : public LogSink {
// Init() must be called before adding this sink.
class CallSessionFileRotatingLogSink : public FileRotatingLogSink {
public:
CallSessionFileRotatingLogSink(const std::string& log_dir_path,
CallSessionFileRotatingLogSink(absl::string_view log_dir_path,
size_t max_total_log_size);
~CallSessionFileRotatingLogSink() override;

17
rtc_base/logging.cc
View File

@ -188,7 +188,7 @@ LogMessage::LogMessage(const char* file,
LogMessage::LogMessage(const char* file,
int line,
LoggingSeverity sev,
const std::string& tag)
absl::string_view tag)
: LogMessage(file, line, sev) {
print_stream_ << tag << ": ";
}
@ -296,7 +296,7 @@ void LogMessage::RemoveLogToStream(LogSink* stream) {
UpdateMinLogSeverity();
}
void LogMessage::ConfigureLogging(const char* params) {
void LogMessage::ConfigureLogging(absl::string_view params) {
LoggingSeverity current_level = LS_VERBOSE;
LoggingSeverity debug_level = GetLogToDebug();
@ -355,13 +355,14 @@ void LogMessage::UpdateMinLogSeverity()
}
#if defined(WEBRTC_ANDROID)
void LogMessage::OutputToDebug(const std::string& str,
void LogMessage::OutputToDebug(absl::string_view str,
LoggingSeverity severity,
const char* tag) {
#else
void LogMessage::OutputToDebug(const std::string& str,
void LogMessage::OutputToDebug(absl::string_view str,
LoggingSeverity severity) {
#endif
std::string str_str = std::string(str);
bool log_to_stderr = log_to_stderr_;
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && defined(NDEBUG)
// On the Mac, all stderr output goes to the Console log and causes clutter.
@ -386,7 +387,7 @@ void LogMessage::OutputToDebug(const std::string& str,
#if defined(WEBRTC_WIN)
// Always log to the debugger.
// Perhaps stderr should be controlled by a preference, as on Mac?
OutputDebugStringA(str.c_str());
OutputDebugStringA(str_str.c_str());
if (log_to_stderr) {
// This handles dynamically allocated consoles, too.
if (HANDLE error_handle = ::GetStdHandle(STD_ERROR_HANDLE)) {
@ -426,14 +427,14 @@ void LogMessage::OutputToDebug(const std::string& str,
int idx = 0;
const int max_lines = size / kMaxLogLineSize + 1;
if (max_lines == 1) {
__android_log_print(prio, tag, "%.*s", size, str.c_str());
__android_log_print(prio, tag, "%.*s", size, str_str.c_str());
} else {
while (size > 0) {
const int len = std::min(size, kMaxLogLineSize);
// Use the size of the string in the format (str may have \0 in the
// middle).
__android_log_print(prio, tag, "[%d/%d] %.*s", line + 1, max_lines, len,
str.c_str() + idx);
str_str.c_str() + idx);
idx += len;
size -= len;
++line;
@ -441,7 +442,7 @@ void LogMessage::OutputToDebug(const std::string& str,
}
#endif // WEBRTC_ANDROID
if (log_to_stderr) {
fprintf(stderr, "%s", str.c_str());
fprintf(stderr, "%s", str_str.c_str());
fflush(stderr);
}
}

16
rtc_base/logging.h
View File

@ -439,7 +439,7 @@ class LogMessage {
LogMessage(const char* file,
int line,
LoggingSeverity sev,
const std::string& tag);
absl::string_view tag);
~LogMessage();
LogMessage(const LogMessage&) = delete;
@ -485,7 +485,7 @@ class LogMessage {
static int GetMinLogSeverity();
// Parses the provided parameter stream to configure the options above.
// Useful for configuring logging from the command line.
static void ConfigureLogging(const char* params);
static void ConfigureLogging(absl::string_view params);
// Checks the current global debug severity and if the `streams_` collection
// is empty. If `severity` is smaller than the global severity and if the
// `streams_` collection is empty, the LogMessage will be considered a noop
@ -516,7 +516,7 @@ class LogMessage {
LogMessage(const char* file,
int line,
LoggingSeverity sev,
const std::string& tag) {}
absl::string_view tag) {}
~LogMessage() = default;
inline void AddTag(const char* tag) {}
@ -534,7 +534,7 @@ class LogMessage {
inline static void RemoveLogToStream(LogSink* stream) {}
inline static int GetLogToStream(LogSink* stream = nullptr) { return 0; }
inline static int GetMinLogSeverity() { return 0; }
inline static void ConfigureLogging(const char* params) {}
inline static void ConfigureLogging(absl::string_view params) {}
static constexpr bool IsNoop(LoggingSeverity severity) { return true; }
template <LoggingSeverity S>
static constexpr bool IsNoop() {
@ -551,11 +551,11 @@ class LogMessage {
// These write out the actual log messages.
#if defined(WEBRTC_ANDROID)
static void OutputToDebug(const std::string& msg,
static void OutputToDebug(absl::string_view msg,
LoggingSeverity severity,
const char* tag);
#else
static void OutputToDebug(const std::string& msg, LoggingSeverity severity);
static void OutputToDebug(absl::string_view msg, LoggingSeverity severity);
#endif // defined(WEBRTC_ANDROID)
// Called from the dtor (or from a test) to append optional extra error
@ -592,11 +592,11 @@ class LogMessage {
// Next methods do nothing; no one will call these functions.
inline static void UpdateMinLogSeverity() {}
#if defined(WEBRTC_ANDROID)
inline static void OutputToDebug(const std::string& msg,
inline static void OutputToDebug(absl::string_view msg,
LoggingSeverity severity,
const char* tag) {}
#else
inline static void OutputToDebug(const std::string& msg,
inline static void OutputToDebug(absl::string_view msg,
LoggingSeverity severity) {}
#endif // defined(WEBRTC_ANDROID)
inline void FinishPrintStream() {}

10
rtc_base/net_helpers.cc
View File

@ -11,6 +11,9 @@
#include "rtc_base/net_helpers.h"
#include <memory>
#include <string>
#include "absl/strings/string_view.h"
#if defined(WEBRTC_WIN)
#include <ws2spi.h>
@ -37,11 +40,12 @@ const char* inet_ntop(int af, const void* src, char* dst, socklen_t size) {
#endif
}
int inet_pton(int af, const char* src, void* dst) {
int inet_pton(int af, absl::string_view src, void* dst) {
std::string src_str = std::string(src);
#if defined(WEBRTC_WIN)
return win32_inet_pton(af, src, dst);
return win32_inet_pton(af, src_str.c_str(), dst);
#else
return ::inet_pton(af, src, dst);
return ::inet_pton(af, src_str.c_str(), dst);
#endif
}

4
rtc_base/net_helpers.h
View File

@ -19,12 +19,14 @@
#include "rtc_base/win32.h"
#endif
#include "absl/strings/string_view.h"
namespace rtc {
// rtc namespaced wrappers for inet_ntop and inet_pton so we can avoid
// the windows-native versions of these.
const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);
int inet_pton(int af, const char* src, void* dst);
int inet_pton(int af, absl::string_view src, void* dst);
bool HasIPv4Enabled();
bool HasIPv6Enabled();

2
rtc_base/network.cc
View File

@ -216,7 +216,7 @@ bool MatchTypeNameWithIndexPattern(absl::string_view network_name,
// result of the downstream network filtering, see e.g.
// BasicPortAllocatorSession::GetNetworks when
// PORTALLOCATOR_DISABLE_COSTLY_NETWORKS is turned on.
AdapterType GetAdapterTypeFromName(const char* network_name) {
AdapterType GetAdapterTypeFromName(absl::string_view network_name) {
if (MatchTypeNameWithIndexPattern(network_name, "lo")) {
// Note that we have a more robust way to determine if a network interface
// is a loopback interface by checking the flag IFF_LOOPBACK in ifa_flags of

2
rtc_base/network.h
View File

@ -63,7 +63,7 @@ std::string MakeNetworkKey(absl::string_view name,
// Utility function that attempts to determine an adapter type by an interface
// name (e.g., "wlan0"). Can be used by NetworkManager subclasses when other
// mechanisms fail to determine the type.
RTC_EXPORT AdapterType GetAdapterTypeFromName(const char* network_name);
RTC_EXPORT AdapterType GetAdapterTypeFromName(absl::string_view network_name);
class DefaultLocalAddressProvider {
public:

6
rtc_base/openssl_adapter.cc
View File

@ -252,11 +252,11 @@ void OpenSSLAdapter::SetRole(SSLRole role) {
role_ = role;
}
int OpenSSLAdapter::StartSSL(const char* hostname) {
int OpenSSLAdapter::StartSSL(absl::string_view hostname) {
if (state_ != SSL_NONE)
return -1;
ssl_host_name_ = hostname;
ssl_host_name_.assign(hostname.data(), hostname.size());
if (GetSocket()->GetState() != Socket::CS_CONNECTED) {
state_ = SSL_WAIT;
@ -422,7 +422,7 @@ int OpenSSLAdapter::ContinueSSL() {
return 0;
}
void OpenSSLAdapter::Error(const char* context, int err, bool signal) {
void OpenSSLAdapter::Error(absl::string_view context, int err, bool signal) {
RTC_LOG(LS_WARNING) << "OpenSSLAdapter::Error(" << context << ", " << err
<< ")";
state_ = SSL_ERROR;

4
rtc_base/openssl_adapter.h
View File

@ -61,7 +61,7 @@ class OpenSSLAdapter final : public SSLAdapter,
void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) override;
void SetIdentity(std::unique_ptr<SSLIdentity> identity) override;
void SetRole(SSLRole role) override;
int StartSSL(const char* hostname) override;
int StartSSL(absl::string_view hostname) override;
int Send(const void* pv, size_t cb) override;
int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
@ -110,7 +110,7 @@ class OpenSSLAdapter final : public SSLAdapter,
int BeginSSL();
int ContinueSSL();
void Error(const char* context, int err, bool signal = true);
void Error(absl::string_view context, int err, bool signal = true);
void Cleanup();
// Return value and arguments have the same meanings as for Send; `error` is

2
rtc_base/openssl_stream_adapter.cc
View File

@ -956,7 +956,7 @@ int OpenSSLStreamAdapter::ContinueSSL() {
return 0;
}
void OpenSSLStreamAdapter::Error(const char* context,
void OpenSSLStreamAdapter::Error(absl::string_view context,
int err,
uint8_t alert,
bool signal) {

2
rtc_base/openssl_stream_adapter.h
View File

@ -173,7 +173,7 @@ class OpenSSLStreamAdapter final : public SSLStreamAdapter {
// `alert` indicates an alert description (one of the SSL_AD constants) to
// send to the remote endpoint when closing the association. If 0, a normal
// shutdown will be performed.
void Error(const char* context, int err, uint8_t alert, bool signal);
void Error(absl::string_view context, int err, uint8_t alert, bool signal);
void Cleanup(uint8_t alert);
// Flush the input buffers by reading left bytes (for DTLS)

5
rtc_base/socket_adapters.cc
View File

@ -411,8 +411,9 @@ void AsyncHttpsProxySocket::ProcessLine(char* data, size_t len) {
} else if ((state_ == PS_AUTHENTICATE) &&
absl::StartsWithIgnoreCase(data, "Proxy-Authenticate:")) {
std::string response, auth_method;
switch (HttpAuthenticate(data + 19, len - 19, proxy_, "CONNECT", "/", user_,
pass_, context_, response, auth_method)) {
switch (HttpAuthenticate(absl::string_view(data + 19, len - 19), proxy_,
"CONNECT", "/", user_, pass_, context_, response,
auth_method)) {
case HAR_IGNORE:
RTC_LOG(LS_VERBOSE) << "Ignoring Proxy-Authenticate: " << auth_method;
if (!unknown_mechanisms_.empty())

3
rtc_base/ssl_adapter.h
View File

@ -14,6 +14,7 @@
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/ssl_certificate.h"
#include "rtc_base/ssl_identity.h"
@ -89,7 +90,7 @@ class SSLAdapter : public AsyncSocketAdapter {
// StartSSL returns 0 if successful.
// If StartSSL is called while the socket is closed or connecting, the SSL
// negotiation will begin as soon as the socket connects.
virtual int StartSSL(const char* hostname) = 0;
virtual int StartSSL(absl::string_view hostname) = 0;
// When an SSLAdapterFactory is used, an SSLAdapter may be used to resume
// a previous SSL session, which results in an abbreviated handshake.

2
rtc_base/ssl_adapter_unittest.cc
View File

@ -110,7 +110,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
RTC_LOG(LS_INFO) << "Starting " << GetSSLProtocolName(ssl_mode_)
<< " handshake with " << hostname;
if (ssl_adapter_->StartSSL(std::string(hostname).c_str()) != 0) {
if (ssl_adapter_->StartSSL(hostname) != 0) {
return -1;
}
}

2
rtc_base/ssl_stream_adapter_unittest.cc
View File

@ -685,7 +685,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
return server_ssl_->GetSslVersion();
}
bool ExportKeyingMaterial(const char* label,
bool ExportKeyingMaterial(absl::string_view label,
const unsigned char* context,
size_t context_len,
bool use_context,

1
rtc_base/system/BUILD.gn
View File

@ -30,6 +30,7 @@ rtc_library("file_wrapper") {
"..:criticalsection",
"..:safe_conversions",
]
absl_deps = [ "//third_party/abseil-cpp/absl/strings" ]
}
if (rtc_include_tests) {

36
rtc_base/system/file_wrapper.cc
View File

@ -9,10 +9,12 @@
*/
#include "rtc_base/system/file_wrapper.h"
#include "rtc_base/numerics/safe_conversions.h"
#include <cerrno>
#include "absl/strings/string_view.h"
#include "rtc_base/numerics/safe_conversions.h"
#ifdef _WIN32
#include <Windows.h>
#else
@ -23,14 +25,17 @@
namespace webrtc {
namespace {
FILE* FileOpen(const char* file_name_utf8, bool read_only, int* error) {
FILE* FileOpen(absl::string_view file_name_utf8, bool read_only, int* error) {
RTC_CHECK_EQ(file_name_utf8.find_first_of('\0'), absl::string_view::npos)
<< "Invalid filename, containing NUL character";
std::string file_name = std::string(file_name_utf8);
#if defined(_WIN32)
int len = MultiByteToWideChar(CP_UTF8, 0, file_name_utf8, -1, nullptr, 0);
int len = MultiByteToWideChar(CP_UTF8, 0, file_name.c_str(), -1, nullptr, 0);
std::wstring wstr(len, 0);
MultiByteToWideChar(CP_UTF8, 0, file_name_utf8, -1, &wstr[0], len);
MultiByteToWideChar(CP_UTF8, 0, file_name.c_str(), -1, &wstr[0], len);
FILE* file = _wfopen(wstr.c_str(), read_only ? L"rb" : L"wb");
#else
FILE* file = fopen(file_name_utf8, read_only ? "rb" : "wb");
FILE* file = fopen(file_name.c_str(), read_only ? "rb" : "wb");
#endif
if (!file && error) {
*error = errno;
@ -38,36 +43,19 @@ FILE* FileOpen(const char* file_name_utf8, bool read_only, int* error) {
return file;
}
const char* GetCstrCheckNoEmbeddedNul(const std::string& s) {
const char* p = s.c_str();
RTC_CHECK_EQ(strlen(p), s.size())
<< "Invalid filename, containing NUL character";
return p;
}
} // namespace
// static
FileWrapper FileWrapper::OpenReadOnly(const char* file_name_utf8) {
FileWrapper FileWrapper::OpenReadOnly(absl::string_view file_name_utf8) {
return FileWrapper(FileOpen(file_name_utf8, true, nullptr));
}
// static
FileWrapper FileWrapper::OpenReadOnly(const std::string& file_name_utf8) {
return OpenReadOnly(GetCstrCheckNoEmbeddedNul(file_name_utf8));
}
// static
FileWrapper FileWrapper::OpenWriteOnly(const char* file_name_utf8,
FileWrapper FileWrapper::OpenWriteOnly(absl::string_view file_name_utf8,
int* error /*=nullptr*/) {
return FileWrapper(FileOpen(file_name_utf8, false, error));
}
// static
FileWrapper FileWrapper::OpenWriteOnly(const std::string& file_name_utf8,
int* error /*=nullptr*/) {
return OpenWriteOnly(GetCstrCheckNoEmbeddedNul(file_name_utf8), error);
}
FileWrapper::FileWrapper(FileWrapper&& other) {
operator=(std::move(other));
}

9
rtc_base/system/file_wrapper.h
View File

@ -16,6 +16,8 @@
#include <string>
#include "absl/strings/string_view.h"
// Implementation that can read (exclusive) or write from/to a file.
namespace webrtc {
@ -34,11 +36,8 @@ class FileWrapper final {
// returned object to check if the open operation was successful. On failure,
// and if `error` is non-null, the system errno value is stored at |*error|.
// The file is closed by the destructor.
static FileWrapper OpenReadOnly(const char* file_name_utf8);
static FileWrapper OpenReadOnly(const std::string& file_name_utf8);
static FileWrapper OpenWriteOnly(const char* file_name_utf8,
int* error = nullptr);
static FileWrapper OpenWriteOnly(const std::string& file_name_utf8,
static FileWrapper OpenReadOnly(absl::string_view file_name_utf8);
static FileWrapper OpenWriteOnly(absl::string_view file_name_utf8,
int* error = nullptr);
FileWrapper() = default;

2
test/test_main_lib.cc
View File

@ -201,7 +201,7 @@ class TestMainImpl : public TestMain {
const bool capture_events = !trace_event_path.empty();
if (capture_events) {
rtc::tracing::SetupInternalTracer();
rtc::tracing::StartInternalCapture(trace_event_path.c_str());
rtc::tracing::StartInternalCapture(trace_event_path);
}
absl::optional<std::vector<std::string>> metrics_to_plot =

20
video/rtp_video_stream_receiver2_unittest.cc
View File

@ -356,7 +356,7 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
TEST_F(RtpVideoStreamReceiver2Test, GenericKeyFrame) {
RtpPacketReceived rtp_packet;
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetPayloadType(kPayloadType);
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
@ -376,7 +376,7 @@ TEST_F(RtpVideoStreamReceiver2Test, PacketInfoIsPropagatedIntoVideoFrames) {
extension_map.Register<AbsoluteCaptureTimeExtension>(kId0);
RtpPacketReceived rtp_packet(&extension_map);
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
rtp_packet.SetTimestamp(1);
rtp_packet.SetSsrc(kSsrc);
@ -407,7 +407,7 @@ TEST_F(RtpVideoStreamReceiver2Test,
RtpPacketReceived rtp_packet(&extension_map);
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
uint16_t sequence_number = 1;
uint32_t rtp_timestamp = 1;
rtp_packet.SetSequenceNumber(sequence_number);
@ -485,7 +485,7 @@ TEST_F(RtpVideoStreamReceiver2Test,
TEST_F(RtpVideoStreamReceiver2Test, GenericKeyFrameBitstreamError) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameKey);
@ -587,7 +587,7 @@ TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) {
video_header.is_last_packet_in_frame = true;
video_header.codec = kVideoCodecH264;
video_header.frame_type = VideoFrameType::kVideoFrameKey;
rtc::CopyOnWriteBuffer data({1, 2, 3});
rtc::CopyOnWriteBuffer data({'1', '2', '3'});
mock_on_complete_frame_callback_.AppendExpectedBitstream(
kH264StartCode, sizeof(kH264StartCode));
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
@ -669,7 +669,7 @@ TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
TEST_F(RtpVideoStreamReceiver2Test, PaddingInMediaStream) {
RtpPacketReceived rtp_packet;
RTPVideoHeader video_header = GetDefaultH264VideoHeader();
rtc::CopyOnWriteBuffer data({1, 2, 3});
rtc::CopyOnWriteBuffer data({'1', '2', '3'});
rtp_packet.SetPayloadType(kPayloadType);
rtp_packet.SetSequenceNumber(2);
video_header.is_first_packet_in_frame = true;
@ -706,7 +706,7 @@ TEST_F(RtpVideoStreamReceiver2Test, PaddingInMediaStream) {
TEST_F(RtpVideoStreamReceiver2Test, RequestKeyframeIfFirstFrameIsDelta) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameDelta);
@ -720,7 +720,7 @@ TEST_F(RtpVideoStreamReceiver2Test, RequestKeyframeWhenPacketBufferGetsFull) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameDelta);
// Incomplete frames so that the packet buffer is filling up.
@ -1125,7 +1125,7 @@ TEST_F(RtpVideoStreamReceiver2Test, TransformFrame) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameKey);
@ -1165,7 +1165,7 @@ INSTANTIATE_TEST_SUITE_P(PlayoutDelay,
Values(kDefaultBehavior, kOverridePlayoutDelay));
TEST_P(RtpVideoStreamReceiver2TestPlayoutDelay, PlayoutDelay) {
rtc::CopyOnWriteBuffer payload_data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer payload_data({'1', '2', '3', '4'});
RtpHeaderExtensionMap extension_map;
extension_map.Register<PlayoutDelayLimits>(1);
RtpPacketToSend packet_to_send(&extension_map);

20
video/rtp_video_stream_receiver_unittest.cc
View File

@ -337,7 +337,7 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) {
TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrame) {
RtpPacketReceived rtp_packet;
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetPayloadType(kPayloadType);
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
@ -357,7 +357,7 @@ TEST_F(RtpVideoStreamReceiverTest, PacketInfoIsPropagatedIntoVideoFrames) {
extension_map.Register<AbsoluteCaptureTimeExtension>(kId0);
RtpPacketReceived rtp_packet(&extension_map);
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
rtp_packet.SetTimestamp(1);
rtp_packet.SetSsrc(kSsrc);
@ -388,7 +388,7 @@ TEST_F(RtpVideoStreamReceiverTest,
RtpPacketReceived rtp_packet(&extension_map);
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
uint16_t sequence_number = 1;
uint32_t rtp_timestamp = 1;
rtp_packet.SetSequenceNumber(sequence_number);
@ -465,7 +465,7 @@ TEST_F(RtpVideoStreamReceiverTest,
TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrameBitstreamError) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameKey);
@ -567,7 +567,7 @@ TEST_P(RtpVideoStreamReceiverTestH264, OutOfBandFmtpSpsPps) {
video_header.is_last_packet_in_frame = true;
video_header.codec = kVideoCodecH264;
video_header.frame_type = VideoFrameType::kVideoFrameKey;
rtc::CopyOnWriteBuffer data({1, 2, 3});
rtc::CopyOnWriteBuffer data({'1', '2', '3'});
mock_on_complete_frame_callback_.AppendExpectedBitstream(
kH264StartCode, sizeof(kH264StartCode));
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
@ -649,7 +649,7 @@ TEST_P(RtpVideoStreamReceiverTestH264, ForceSpsPpsIdrIsKeyframe) {
TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) {
RtpPacketReceived rtp_packet;
RTPVideoHeader video_header = GetDefaultH264VideoHeader();
rtc::CopyOnWriteBuffer data({1, 2, 3});
rtc::CopyOnWriteBuffer data({'1', '2', '3'});
rtp_packet.SetPayloadType(kPayloadType);
rtp_packet.SetSequenceNumber(2);
video_header.is_first_packet_in_frame = true;
@ -686,7 +686,7 @@ TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) {
TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameDelta);
@ -700,7 +700,7 @@ TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeWhenPacketBufferGetsFull) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameDelta);
// Incomplete frames so that the packet buffer is filling up.
@ -1164,7 +1164,7 @@ TEST_F(RtpVideoStreamReceiverTest, TransformFrame) {
RtpPacketReceived rtp_packet;
rtp_packet.SetPayloadType(kPayloadType);
rtc::CopyOnWriteBuffer data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer data({'1', '2', '3', '4'});
rtp_packet.SetSequenceNumber(1);
RTPVideoHeader video_header =
GetGenericVideoHeader(VideoFrameType::kVideoFrameKey);
@ -1204,7 +1204,7 @@ INSTANTIATE_TEST_SUITE_P(PlayoutDelay,
Values(kDefaultBehavior, kOverridePlayoutDelay));
TEST_P(RtpVideoStreamReceiverTestPlayoutDelay, PlayoutDelay) {
rtc::CopyOnWriteBuffer payload_data({1, 2, 3, 4});
rtc::CopyOnWriteBuffer payload_data({'1', '2', '3', '4'});
RtpHeaderExtensionMap extension_map;
extension_map.Register<PlayoutDelayLimits>(1);
RtpPacketToSend packet_to_send(&extension_map);