Use more inclusive language in third_party/blink/renderer/platform

Bug: 1097346
Change-Id: I09239e7647e182e1094ffed28aecd12c89f31fa8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2255218
Commit-Queue: Chris Harrelson <chrishtr@chromium.org>
Reviewed-by: Chris Harrelson <chrishtr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#780488}

third_party/blink/renderer/modules/peerconnection/rtc_peer_connection_handler_test.cc

@@ -917,7 +917,7 @@ TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithBadSelector) {
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetRTCStats) {
-  blink::WhitelistStatsForTesting(webrtc::RTCTestStats::kType);
+  blink::AllowStatsForTesting(webrtc::RTCTestStats::kType);
 
   rtc::scoped_refptr<webrtc::RTCStatsReport> report =
       webrtc::RTCStatsReport::Create();

third_party/blink/renderer/platform/DEPS

 include_rules = [
-    # To whitelist base/ stuff Blink is allowed to include, we list up all
+    # To only allow a subset of base/ in Blink, we explicitly list all
     # directories and files instead of writing 'base/'.
     "+base/allocator/partition_allocator",
     "+base/atomic_ref_count.h",

third_party/blink/renderer/platform/bindings/v8_object_constructor.cc

@@ -45,8 +45,8 @@ v8::MaybeLocal<v8::Object> V8ObjectConstructor::NewInstance(
   v8::MicrotasksScope microtasks_scope(
       isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
   // Construct without side effect only in ConstructorMode::kWrapExistingObject
-  // cases. This allows whitelisted methods to correctly set return values
-  // without invoking Blink's internal constructors.
+  // cases. Allowed methods can correctly set return values without invoking
+  // Blink's internal constructors.
   v8::MaybeLocal<v8::Object> result = function->NewInstanceWithSideEffectType(
       isolate->GetCurrentContext(), argc, argv,
       v8::SideEffectType::kHasNoSideEffect);

third_party/blink/renderer/platform/fonts/bitmap_glyphs_block_list_test.cc

@@ -13,7 +13,7 @@ namespace blink {
 #if defined(OS_WIN)
 
 static void TestBitmapGlyphsBlockListed(AtomicString windows_family_name,
-                                        bool blacklisted_expected) {
+                                        bool block_listed_expected) {
   FontCache* font_cache = FontCache::GetFontCache();
   FontDescription font_description;
   FontFamily font_family;
@@ -24,7 +24,7 @@ static void TestBitmapGlyphsBlockListed(AtomicString windows_family_name,
   ASSERT_TRUE(simple_font_data);
   const FontPlatformData& font_platform_data = simple_font_data->PlatformData();
   ASSERT_TRUE(font_platform_data.Typeface());
-  ASSERT_EQ(blacklisted_expected,
+  ASSERT_EQ(block_listed_expected,
             BitmapGlyphsBlockList::ShouldAvoidEmbeddedBitmapsForTypeface(
                 *font_platform_data.Typeface()));
 }

third_party/blink/renderer/platform/loader/cors/cors.cc

@@ -277,7 +277,7 @@ bool CheckIfRequestCanSkipPreflight(
 // This is the same as that function except using KURL and SecurityOrigin
 // instead of GURL and url::Origin. We can't combine them because converting
 // SecurityOrigin to url::Origin loses information about origins that are
-// whitelisted by SecurityPolicy.
+// allowed by SecurityPolicy.
 //
 // This function also doesn't use a |tainted_origin| flag because Blink loaders
 // mutate the origin instead of using such a flag.

third_party/blink/renderer/platform/peerconnection/rtc_stats.cc

@@ -22,50 +22,50 @@ namespace blink {
 
 namespace {
 
-class RTCStatsWhitelist {
+class RTCStatsAllowlist {
  public:
-  RTCStatsWhitelist() {
-    whitelisted_stats_types_.insert(webrtc::RTCCertificateStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCCodecStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCDataChannelStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCIceCandidatePairStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCIceCandidateStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCLocalIceCandidateStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCRemoteIceCandidateStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCMediaStreamStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCMediaStreamTrackStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCPeerConnectionStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCRTPStreamStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCInboundRTPStreamStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCOutboundRTPStreamStats::kType);
-    whitelisted_stats_types_.insert(
+  RTCStatsAllowlist() {
+    allowlisted_stats_types_.insert(webrtc::RTCCertificateStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCCodecStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCDataChannelStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCIceCandidatePairStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCIceCandidateStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCLocalIceCandidateStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCRemoteIceCandidateStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCMediaStreamStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCMediaStreamTrackStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCPeerConnectionStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCRTPStreamStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCInboundRTPStreamStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCOutboundRTPStreamStats::kType);
+    allowlisted_stats_types_.insert(
         webrtc::RTCRemoteInboundRtpStreamStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCMediaSourceStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCAudioSourceStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCVideoSourceStats::kType);
-    whitelisted_stats_types_.insert(webrtc::RTCTransportStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCMediaSourceStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCAudioSourceStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCVideoSourceStats::kType);
+    allowlisted_stats_types_.insert(webrtc::RTCTransportStats::kType);
   }
 
-  bool IsWhitelisted(const webrtc::RTCStats& stats) {
-    return whitelisted_stats_types_.find(stats.type()) !=
-           whitelisted_stats_types_.end();
+  bool IsAllowlisted(const webrtc::RTCStats& stats) {
+    return allowlisted_stats_types_.find(stats.type()) !=
+           allowlisted_stats_types_.end();
   }
 
-  void WhitelistStatsForTesting(const char* type) {
-    whitelisted_stats_types_.insert(type);
+  void AllowStatsForTesting(const char* type) {
+    allowlisted_stats_types_.insert(type);
   }
 
  private:
-  std::set<std::string> whitelisted_stats_types_;
+  std::set<std::string> allowlisted_stats_types_;
 };
 
-RTCStatsWhitelist* GetStatsWhitelist() {
-  static RTCStatsWhitelist* whitelist = new RTCStatsWhitelist();
-  return whitelist;
+RTCStatsAllowlist* GetStatsAllowlist() {
+  static RTCStatsAllowlist* list = new RTCStatsAllowlist();
+  return list;
 }
 
-bool IsWhitelistedStats(const webrtc::RTCStats& stats) {
-  return GetStatsWhitelist()->IsWhitelisted(stats);
+bool IsAllowlistedStats(const webrtc::RTCStats& stats) {
+  return GetStatsAllowlist()->IsAllowlisted(stats);
 }
 
 // Filters stats that should be surfaced to JS. Stats are surfaced if they're
@@ -74,9 +74,9 @@ bool IsWhitelistedStats(const webrtc::RTCStats& stats) {
 std::vector<const webrtc::RTCStatsMemberInterface*> FilterMembers(
     std::vector<const webrtc::RTCStatsMemberInterface*> stats_members,
     const Vector<webrtc::NonStandardGroupId>& exposed_group_ids) {
-  // Note that using "is_standarized" avoids having to maintain a whitelist of
+  // Note that using "is_standarized" avoids having to maintain an allowlist of
   // every single standardized member, as we do at the "stats object" level
-  // with "RTCStatsWhitelist".
+  // with "RTCStatsAllowlist".
   base::EraseIf(
       stats_members,
       [&exposed_group_ids](const webrtc::RTCStatsMemberInterface* member) {
@@ -96,11 +96,11 @@ std::vector<const webrtc::RTCStatsMemberInterface*> FilterMembers(
   return stats_members;
 }
 
-size_t CountWhitelistedStats(
+size_t CountAllowlistedStats(
     const scoped_refptr<const webrtc::RTCStatsReport>& stats_report) {
   size_t size = 0;
   for (const auto& stats : *stats_report) {
-    if (IsWhitelistedStats(stats)) {
+    if (IsAllowlistedStats(stats)) {
       ++size;
     }
   }
@@ -123,7 +123,7 @@ RTCStatsReportPlatform::RTCStatsReportPlatform(
       it_(stats_report_->begin()),
       end_(stats_report_->end()),
       exposed_group_ids_(exposed_group_ids),
-      size_(CountWhitelistedStats(stats_report)) {
+      size_(CountAllowlistedStats(stats_report)) {
   DCHECK(stats_report_);
 }
 
@@ -138,7 +138,7 @@ std::unique_ptr<RTCStatsReportPlatform> RTCStatsReportPlatform::CopyHandle()
 std::unique_ptr<RTCStats> RTCStatsReportPlatform::GetStats(
     const String& id) const {
   const webrtc::RTCStats* stats = stats_report_->Get(id.Utf8());
-  if (!stats || !IsWhitelistedStats(*stats))
+  if (!stats || !IsAllowlistedStats(*stats))
     return std::unique_ptr<RTCStats>();
   return std::make_unique<RTCStats>(stats_report_, stats, exposed_group_ids_);
 }
@@ -147,7 +147,7 @@ std::unique_ptr<RTCStats> RTCStatsReportPlatform::Next() {
   while (it_ != end_) {
     const webrtc::RTCStats& next = *it_;
     ++it_;
-    if (IsWhitelistedStats(next)) {
+    if (IsAllowlistedStats(next)) {
       return std::make_unique<RTCStats>(stats_report_, &next,
                                         exposed_group_ids_);
     }
@@ -346,8 +346,8 @@ void RTCStatsCollectorCallbackImpl::OnStatsDeliveredOnMainThread(
       base::WrapRefCounted(report.get()), exposed_group_ids_));
 }
 
-void WhitelistStatsForTesting(const char* type) {
-  GetStatsWhitelist()->WhitelistStatsForTesting(type);
+void AllowStatsForTesting(const char* type) {
+  GetStatsAllowlist()->AllowStatsForTesting(type);
 }
 
 }  // namespace blink

third_party/blink/renderer/platform/peerconnection/rtc_stats.h

@@ -31,9 +31,9 @@ class RTCStats;
 class RTCStatsMember;
 
 // Wrapper around a webrtc::RTCStatsReport. Filters out any stats objects that
-// aren't whitelisted. |filter| controls whether to include only standard
-// members (RTCStatsMemberInterface::is_standardized return true) or not
-// (RTCStatsMemberInterface::is_standardized return false).
+// aren't listed in the allow list. |filter| controls whether to include only
+// standard members (RTCStatsMemberInterface::is_standardized return true) or
+// not (RTCStatsMemberInterface::is_standardized return false).
 //
 // Note: This class is named |RTCStatsReportPlatform| not to collide with class
 // |RTCStatsReport|, from renderer/modules/peerconnection/rtc_stats_report.cc|h.
@@ -62,7 +62,7 @@ class PLATFORM_EXPORT RTCStatsReportPlatform {
   webrtc::RTCStatsReport::ConstIterator it_;
   const webrtc::RTCStatsReport::ConstIterator end_;
   Vector<webrtc::NonStandardGroupId> exposed_group_ids_;
-  // Number of whitelisted webrtc::RTCStats in |stats_report_|.
+  // Number of allowlisted webrtc::RTCStats in |stats_report_|.
   const size_t size_;
 };
 
@@ -156,7 +156,7 @@ class PLATFORM_EXPORT RTCStatsCollectorCallbackImpl
   Vector<webrtc::NonStandardGroupId> exposed_group_ids_;
 };
 
-PLATFORM_EXPORT void WhitelistStatsForTesting(const char* type);
+PLATFORM_EXPORT void AllowStatsForTesting(const char* type);
 
 }  // namespace blink
 

third_party/blink/renderer/platform/peerconnection/rtc_stats_test.cc

@@ -14,40 +14,40 @@
 
 namespace blink {
 
-TEST(RTCStatsTest, OnlyIncludeWhitelistedStats_GetStats) {
-  const char* not_whitelisted_id = "NotWhitelistedId";
-  const char* whitelisted_id = "WhitelistedId";
+TEST(RTCStatsTest, OnlyIncludeAllowlistedStats_GetStats) {
+  const char* not_allowlisted_id = "NotAllowlistedId";
+  const char* allowlisted_id = "AllowlistedId";
 
   rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
       webrtc::RTCStatsReport::Create(42);
   webrtc_report->AddStats(std::unique_ptr<webrtc::RTCTestStats>(
-      new webrtc::RTCTestStats(not_whitelisted_id, 42)));
+      new webrtc::RTCTestStats(not_allowlisted_id, 42)));
   webrtc_report->AddStats(std::unique_ptr<webrtc::RTCPeerConnectionStats>(
-      new webrtc::RTCPeerConnectionStats(whitelisted_id, 42)));
+      new webrtc::RTCPeerConnectionStats(allowlisted_id, 42)));
 
   RTCStatsReportPlatform report(webrtc_report.get(), {});
-  EXPECT_FALSE(report.GetStats(not_whitelisted_id));
-  EXPECT_TRUE(report.GetStats(whitelisted_id));
+  EXPECT_FALSE(report.GetStats(not_allowlisted_id));
+  EXPECT_TRUE(report.GetStats(allowlisted_id));
 }
 
-TEST(RTCStatsTest, OnlyIncludeWhitelistedStats_Iteration) {
-  const char* not_whitelisted_id = "NotWhitelistedId";
-  const char* whitelisted_id = "WhitelistedId";
+TEST(RTCStatsTest, OnlyIncludeAllowlistedStats_Iteration) {
+  const char* not_allowlisted_id = "NotAllowlistedId";
+  const char* allowlisted_id = "AllowlistedId";
 
   rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
       webrtc::RTCStatsReport::Create(42);
   webrtc_report->AddStats(std::unique_ptr<webrtc::RTCTestStats>(
-      new webrtc::RTCTestStats(not_whitelisted_id, 42)));
+      new webrtc::RTCTestStats(not_allowlisted_id, 42)));
   webrtc_report->AddStats(std::unique_ptr<webrtc::RTCPeerConnectionStats>(
-      new webrtc::RTCPeerConnectionStats(whitelisted_id, 42)));
+      new webrtc::RTCPeerConnectionStats(allowlisted_id, 42)));
 
   RTCStatsReportPlatform report(webrtc_report.get(), {});
-  // Only whitelisted stats are counted.
+  // Only allowlisted stats are counted.
   EXPECT_EQ(report.Size(), 1u);
 
   std::unique_ptr<RTCStats> stats = report.Next();
   EXPECT_TRUE(stats);
-  EXPECT_EQ(stats->Id(), whitelisted_id);
+  EXPECT_EQ(stats->Id(), allowlisted_id);
   EXPECT_FALSE(report.Next());
 }
 
@@ -78,12 +78,12 @@ TestStats::TestStats(const std::string& id, int64_t timestamp_us)
                        {webrtc::NonStandardGroupId::kGroupIdForTesting}) {}
 }  // namespace
 
-// Similar to how only whitelisted stats objects should be surfaced, only
-// standardized members of the whitelisted objects should be surfaced.
+// Similar to how only allowlisted stats objects should be surfaced, only
+// standardized members of the allowlisted objects should be surfaced.
 TEST(RTCStatsTest, OnlyIncludeStandarizedMembers) {
   rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
       webrtc::RTCStatsReport::Create(42);
-  WhitelistStatsForTesting(TestStats::kType);
+  AllowStatsForTesting(TestStats::kType);
   webrtc_report->AddStats(std::make_unique<TestStats>("id", 0));
 
   // TestStats has two members, but the non-standard member should be filtered
@@ -98,7 +98,7 @@ TEST(RTCStatsTest, OnlyIncludeStandarizedMembers) {
 TEST(RTCStatsTest, IncludeAllMembers) {
   rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
       webrtc::RTCStatsReport::Create(7);
-  WhitelistStatsForTesting(TestStats::kType);
+  AllowStatsForTesting(TestStats::kType);
   webrtc_report->AddStats(std::make_unique<TestStats>("id", 0));
 
   // Include both standard and non-standard member.
@@ -115,7 +115,7 @@ TEST(RTCStatsTest, IncludeAllMembers) {
 TEST(RTCStatsTest, CopyHandle) {
   rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
       webrtc::RTCStatsReport::Create(17);
-  WhitelistStatsForTesting(TestStats::kType);
+  AllowStatsForTesting(TestStats::kType);
   webrtc_report->AddStats(std::make_unique<TestStats>("id", 0));
 
   // Check that filtering options are preserved during copy.

third_party/blink/renderer/platform/wtf/DEPS

 include_rules = [
-    # To whitelist base/ stuff Blink is allowed to include, we list up all
+    # To only allow a subset of base/ in Blink, we explicitly list all
     # directories and files instead of writing 'base/'.
     "+base/allocator/partition_allocator",
     "+base/atomic_ref_count.h",