// 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. #include "net/log/net_log_util.h" #include #include #include "base/containers/contains.h" #include "base/feature_list.h" #include "base/files/file_path.h" #include "base/metrics/field_trial.h" #include "base/ranges/algorithm.h" #include "base/strings/string_piece.h" #include "base/test/scoped_feature_list.h" #include "base/test/task_environment.h" #include "base/values.h" #include "net/base/net_errors.h" #include "net/base/net_info_source_list.h" #include "net/base/test_completion_callback.h" #include "net/dns/public/doh_provider_entry.h" #include "net/http/http_cache.h" #include "net/http/http_transaction.h" #include "net/log/net_log_source.h" #include "net/log/net_log_with_source.h" #include "net/log/test_net_log.h" #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" #include "net/url_request/url_request_context.h" #include "net/url_request/url_request_context_builder.h" #include "net/url_request/url_request_test_util.h" #include "testing/gtest/include/gtest/gtest.h" namespace net { namespace { // Make sure GetNetConstants doesn't crash. TEST(NetLogUtil, GetNetConstants) { base::Value constants(GetNetConstants()); } // Make sure GetNetInfo doesn't crash when called on contexts with and without // caches, and they have the same number of elements. TEST(NetLogUtil, GetNetInfo) { base::test::TaskEnvironment task_environment; auto context = CreateTestURLRequestContextBuilder()->Build(); HttpCache* http_cache = context->http_transaction_factory()->GetCache(); // Get NetInfo when there's no cache backend (It's only created on first use). EXPECT_FALSE(http_cache->GetCurrentBackend()); base::Value::Dict net_info_without_cache(GetNetInfo(context.get())); EXPECT_FALSE(http_cache->GetCurrentBackend()); EXPECT_GT(net_info_without_cache.size(), 0u); // Force creation of a cache backend, and get NetInfo again. disk_cache::Backend* backend = nullptr; EXPECT_EQ(OK, context->http_transaction_factory()->GetCache()->GetBackend( &backend, TestCompletionCallback().callback())); EXPECT_TRUE(http_cache->GetCurrentBackend()); base::Value::Dict net_info_with_cache = GetNetInfo(context.get()); EXPECT_GT(net_info_with_cache.size(), 0u); EXPECT_EQ(net_info_without_cache.size(), net_info_with_cache.size()); } // Verify that active Field Trials are reflected. TEST(NetLogUtil, GetNetInfoIncludesFieldTrials) { base::test::TaskEnvironment task_environment; // Clear all Field Trials. base::test::ScopedFeatureList scoped_feature_list; scoped_feature_list.InitWithFeatureList( std::make_unique()); // Add and activate a new Field Trial. base::FieldTrial* field_trial = base::FieldTrialList::FactoryGetFieldTrial( "NewFieldTrial", 100, "Default", base::FieldTrial::ONE_TIME_RANDOMIZED, nullptr); field_trial->AppendGroup("Active", 100); EXPECT_EQ(field_trial->group_name(), "Active"); auto context = CreateTestURLRequestContextBuilder()->Build(); base::Value net_info(GetNetInfo(context.get())); // Verify that the returned information reflects the new trial. ASSERT_TRUE(net_info.is_dict()); base::Value::List* trials = net_info.GetDict().FindList("activeFieldTrialGroups"); ASSERT_NE(nullptr, trials); EXPECT_EQ(1u, trials->size()); EXPECT_TRUE((*trials)[0].is_string()); EXPECT_EQ("NewFieldTrial:Active", (*trials)[0].GetString()); } // Demonstrate that disabling a provider causes it to be added to the list of // disabled DoH providers. // // TODO(https://crbug.com/1306495) Stop using the real DoH provider list. TEST(NetLogUtil, GetNetInfoIncludesDisabledDohProviders) { constexpr base::StringPiece kArbitraryProvider = "Google"; base::test::TaskEnvironment task_environment; for (bool provider_enabled : {false, true}) { // Get the DoH provider entry. auto provider_list = net::DohProviderEntry::GetList(); auto provider_it = base::ranges::find(provider_list, kArbitraryProvider, &net::DohProviderEntry::provider); CHECK(provider_it != provider_list.end()); const DohProviderEntry& provider_entry = **provider_it; // Enable or disable the provider's feature according to `provider_enabled`. base::test::ScopedFeatureList scoped_feature_list; scoped_feature_list.InitWithFeatureState(provider_entry.feature, provider_enabled); EXPECT_EQ(provider_enabled, base::FeatureList::IsEnabled(provider_entry.feature)); // Verify that the provider is present in the list of disabled providers iff // we disabled it. auto context = CreateTestURLRequestContextBuilder()->Build(); base::Value net_info(GetNetInfo(context.get())); ASSERT_TRUE(net_info.is_dict()); const base::Value::List* disabled_doh_providers_list = net_info.GetDict().FindList(kNetInfoDohProvidersDisabledDueToFeature); CHECK(disabled_doh_providers_list); EXPECT_EQ(!provider_enabled, base::Contains(*disabled_doh_providers_list, base::Value(kArbitraryProvider))); } } // Make sure CreateNetLogEntriesForActiveObjects works for requests from a // single URLRequestContext. TEST(NetLogUtil, CreateNetLogEntriesForActiveObjectsOneContext) { base::test::TaskEnvironment task_environment; // Using same context for each iteration makes sure deleted requests don't // appear in the list, or result in crashes. auto context = CreateTestURLRequestContextBuilder()->Build(); TestDelegate delegate; for (size_t num_requests = 0; num_requests < 5; ++num_requests) { std::vector> requests; for (size_t i = 0; i < num_requests; ++i) { requests.push_back(context->CreateRequest(GURL("about:life"), DEFAULT_PRIORITY, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS)); } std::set contexts; contexts.insert(context.get()); RecordingNetLogObserver net_log_observer; CreateNetLogEntriesForActiveObjects(contexts, &net_log_observer); auto entry_list = net_log_observer.GetEntries(); ASSERT_EQ(num_requests, entry_list.size()); for (size_t i = 0; i < num_requests; ++i) { EXPECT_EQ(entry_list[i].source.id, requests[i]->net_log().source().id); } } } // Make sure CreateNetLogEntriesForActiveObjects works with multiple // URLRequestContexts. TEST(NetLogUtil, CreateNetLogEntriesForActiveObjectsMultipleContexts) { base::test::TaskEnvironment task_environment; TestDelegate delegate; for (size_t num_requests = 0; num_requests < 5; ++num_requests) { std::vector> contexts; std::vector> requests; std::set context_set; for (size_t i = 0; i < num_requests; ++i) { contexts.push_back(CreateTestURLRequestContextBuilder()->Build()); context_set.insert(contexts[i].get()); requests.push_back( contexts[i]->CreateRequest(GURL("about:hats"), DEFAULT_PRIORITY, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS)); } RecordingNetLogObserver net_log_observer; CreateNetLogEntriesForActiveObjects(context_set, &net_log_observer); auto entry_list = net_log_observer.GetEntries(); ASSERT_EQ(num_requests, entry_list.size()); for (size_t i = 0; i < num_requests; ++i) { EXPECT_EQ(entry_list[i].source.id, requests[i]->net_log().source().id); } } } } // namespace } // namespace net