[DanglingPtr] Enable dangling pointer checks

browser/brave_ads/analytics/p3a/brave_stats_helper.h

@@ -55,7 +55,7 @@ class BraveStatsHelper : public ProfileManagerObserver, public ProfileObserver {
       profile_manager_observer_{this};
 
   raw_ptr<PrefService> local_state_;
-  raw_ptr<ProfileManager> profile_manager_;
+  raw_ptr<ProfileManager, DanglingUntriaged> profile_manager_;
 
   base::Time testing_first_run_time_;
 };

browser/brave_wallet/ethereum_provider_impl_unittest.cc

@@ -942,12 +942,12 @@ class EthereumProviderImplUnitTest : public testing::Test {
   scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory_;
   base::ScopedTempDir temp_dir_;
   TestingProfile profile_;
-  raw_ptr<KeyringService> keyring_service_ = nullptr;
+  raw_ptr<KeyringService, DanglingUntriaged> keyring_service_ = nullptr;
   raw_ptr<AssetRatioService> asset_ratio_service_;
-  raw_ptr<TxService> tx_service_;
+  raw_ptr<TxService, DanglingUntriaged> tx_service_;
 
  protected:
-  raw_ptr<JsonRpcService> json_rpc_service_ = nullptr;
+  raw_ptr<JsonRpcService, DanglingUntriaged> json_rpc_service_ = nullptr;
   std::unique_ptr<BraveWalletService> brave_wallet_service_;
 };
 

browser/net/url_context.h

@@ -97,7 +97,8 @@ struct BraveRequestInfo {
   // |set_headers| contains headers which values were added or modified.
   std::set<std::string> set_headers;
   std::set<std::string> removed_headers;
-  raw_ptr<const net::HttpResponseHeaders> original_response_headers = nullptr;
+  raw_ptr<const net::HttpResponseHeaders, DanglingUntriaged>
+      original_response_headers = nullptr;
   raw_ptr<scoped_refptr<net::HttpResponseHeaders>> override_response_headers =
       nullptr;
 

browser/playlist/playlist_data_source.h

@@ -68,7 +68,7 @@ class PlaylistDataSource : public FaviconSource {
                     const net::HttpByteRange& range,
                     GotRangeDataCallback got_data_callback);
 
-  raw_ptr<PlaylistService> service_ = nullptr;
+  raw_ptr<PlaylistService, DanglingUntriaged> service_ = nullptr;
 };
 
 }  // namespace playlist

browser/ui/ai_chat/ai_chat_tab_helper_unittest.cc

@@ -150,9 +150,10 @@ class AIChatTabHelperUnitTest : public content::RenderViewHostTestHarness,
  protected:
   NiceMock<favicon::MockFaviconService> favicon_service_;
   std::unique_ptr<NiceMock<MockAssociatedContentObserver>> observer_;
-  raw_ptr<AIChatTabHelper> helper_;
-  raw_ptr<MockPrintPreviewExtractor> print_preview_extractor_;
-  raw_ptr<MockPageContentFetcher> page_content_fetcher_;
+  raw_ptr<AIChatTabHelper, DanglingUntriaged> helper_;
+  raw_ptr<MockPrintPreviewExtractor, DanglingUntriaged>
+      print_preview_extractor_;
+  raw_ptr<MockPageContentFetcher, DanglingUntriaged> page_content_fetcher_;
   bool is_print_preview_supported_ = true;
 };
 

browser/ui/commander/commander_service.h

@@ -78,7 +78,7 @@ class CommanderService : public CommanderFrontendDelegate,
   std::u16string prompt_;
   std::vector<std::unique_ptr<CommandItem>> items_;
   uint32_t current_result_set_id_ = 0;
-  raw_ptr<Browser> last_browser_;
+  raw_ptr<Browser, DanglingUntriaged> last_browser_;
   raw_ptr<Profile> profile_;
 
   // Some commands have multiple steps (like move tab to window, pick a

browser/ui/sidebar/sidebar_controller.h

@@ -90,7 +90,7 @@ class SidebarController : public SidebarService::Observer {
 
   raw_ptr<BraveBrowser> browser_ = nullptr;
   // Interface to view.
-  raw_ptr<Sidebar> sidebar_ = nullptr;
+  raw_ptr<Sidebar, DanglingUntriaged> sidebar_ = nullptr;
 
   std::unique_ptr<SidebarModel> sidebar_model_;
   base::ScopedObservation<SidebarService, SidebarService::Observer>

browser/ui/views/frame/brave_browser_root_view.h

@@ -32,7 +32,7 @@ class BraveBrowserRootView : public BrowserRootView,
   void OnNativeThemeUpdated(ui::NativeTheme* observed_theme) override;
 
  private:
-  raw_ptr<Browser> browser_ = nullptr;
+  raw_ptr<Browser, DanglingUntriaged> browser_ = nullptr;
   base::ScopedObservation<ui::NativeTheme, ui::NativeThemeObserver>
       theme_observation_{this};
 };

browser/ui/views/frame/brave_browser_view.h

@@ -214,7 +214,7 @@ class BraveBrowserView : public BrowserView,
   raw_ptr<views::View> sidebar_separator_view_ = nullptr;
   raw_ptr<views::View> contents_background_view_ = nullptr;
   raw_ptr<views::View> vertical_tab_strip_host_view_ = nullptr;
-  raw_ptr<VerticalTabStripWidgetDelegateView>
+  raw_ptr<VerticalTabStripWidgetDelegateView, DanglingUntriaged>
       vertical_tab_strip_widget_delegate_view_ = nullptr;
 
 #if defined(USE_AURA)

browser/ui/views/frame/brave_browser_view_layout.h

@@ -65,9 +65,9 @@ class BraveBrowserViewLayout : public BrowserViewLayout {
   gfx::Insets AdjustInsetsConsideringFrameBorder(const gfx::Insets& insets);
 #endif
 
-  raw_ptr<views::View> vertical_tab_strip_host_ = nullptr;
-  raw_ptr<views::View> reader_mode_toolbar_ = nullptr;
-  raw_ptr<SidebarContainerView> sidebar_container_ = nullptr;
+  raw_ptr<views::View, DanglingUntriaged> vertical_tab_strip_host_ = nullptr;
+  raw_ptr<views::View, DanglingUntriaged> reader_mode_toolbar_ = nullptr;
+  raw_ptr<SidebarContainerView, DanglingUntriaged> sidebar_container_ = nullptr;
   raw_ptr<views::View> sidebar_separator_ = nullptr;
   raw_ptr<views::View> contents_background_ = nullptr;
 };

browser/ui/views/frame/brave_contents_layout_manager_unittest.cc

@@ -61,12 +61,14 @@ class BraveContentsLayoutManagerUnitTest : public testing::Test {
   base::test::ScopedFeatureList scoped_feature_;
 
   std::unique_ptr<views::View> contents_container_;
-  raw_ptr<views::WebView> contents_view_ = nullptr;
-  raw_ptr<views::WebView> devtools_view_ = nullptr;
-  raw_ptr<views::WebView> secondary_contents_view_ = nullptr;
-  raw_ptr<views::WebView> secondary_devtools_view_ = nullptr;
-  raw_ptr<SplitViewSeparator> split_view_separator_ = nullptr;
-  raw_ptr<BraveContentsLayoutManager> layout_manager_ = nullptr;
+  raw_ptr<views::WebView, DanglingUntriaged> contents_view_ = nullptr;
+  raw_ptr<views::WebView, DanglingUntriaged> devtools_view_ = nullptr;
+  raw_ptr<views::WebView, DanglingUntriaged> secondary_contents_view_ = nullptr;
+  raw_ptr<views::WebView, DanglingUntriaged> secondary_devtools_view_ = nullptr;
+  raw_ptr<SplitViewSeparator, DanglingUntriaged> split_view_separator_ =
+      nullptr;
+  raw_ptr<BraveContentsLayoutManager, DanglingUntriaged> layout_manager_ =
+      nullptr;
 };
 
 TEST_F(BraveContentsLayoutManagerUnitTest,

browser/ui/views/sidebar/sidebar_show_options_event_detect_widget.h

@@ -64,7 +64,7 @@ class SidebarShowOptionsEventDetectWidget : public views::ViewObserver,
 
   bool sidebar_on_left_ = true;
   raw_ref<BraveBrowserView> browser_view_;
-  raw_ptr<ContentsView> contents_view_ = nullptr;
+  raw_ptr<ContentsView, DanglingUntriaged> contents_view_ = nullptr;
   raw_ref<Delegate> delegate_;
   std::unique_ptr<views::Widget> widget_;
   base::ScopedObservation<views::View, views::ViewObserver> observation_{this};

browser/ui/views/split_view/split_view_separator.h

@@ -58,7 +58,8 @@ class SplitViewSeparator : public views::ResizeArea,
 
   raw_ptr<Browser> browser_ = nullptr;
 
-  raw_ptr<SplitViewSeparatorDelegate> resize_area_delegate_ = nullptr;
+  raw_ptr<SplitViewSeparatorDelegate, DanglingUntriaged> resize_area_delegate_ =
+      nullptr;
 
   raw_ptr<views::Widget> menu_button_widget_ = nullptr;
 

browser/ui/views/toolbar/brave_vpn_button.cc

@@ -111,8 +111,8 @@ class VPNButtonMenuModel : public ui::SimpleMenuModel,
     }
   }
 
-  raw_ptr<Browser> browser_ = nullptr;
-  raw_ptr<brave_vpn::BraveVpnService> service_ = nullptr;
+  raw_ptr<Browser, DanglingUntriaged> browser_ = nullptr;
+  raw_ptr<brave_vpn::BraveVpnService, DanglingUntriaged> service_ = nullptr;
 };
 
 }  // namespace

browser/ui/views/toolbar/brave_vpn_button.h

@@ -70,8 +70,8 @@ class BraveVPNButton : public ToolbarButton,
   bool is_connected_ = false;
   std::optional<brave_vpn::mojom::ConnectionState>
       connection_state_for_testing_;
-  raw_ptr<Browser> browser_ = nullptr;
-  raw_ptr<brave_vpn::BraveVpnService> service_ = nullptr;
+  raw_ptr<Browser, DanglingUntriaged> browser_ = nullptr;
+  raw_ptr<brave_vpn::BraveVpnService, DanglingUntriaged> service_ = nullptr;
   raw_ptr<views::MenuButtonController> menu_button_controller_ = nullptr;
 };
 

build/commands/lib/config.js

@@ -425,11 +425,11 @@ Config.prototype.buildArgs = function () {
     brave_services_production_domain: this.braveServicesProductionDomain,
     brave_services_staging_domain: this.braveServicesStagingDomain,
     brave_services_dev_domain: this.braveServicesDevDomain,
-    enable_dangling_raw_ptr_feature_flag: false,
     brave_services_key_id: this.brave_services_key_id,
     service_key_aichat: this.service_key_aichat,
     service_key_stt: this.service_key_stt,
     generate_about_credits: true,
+    enable_backup_ref_ptr_instance_tracer: true,
   }
 
   if (!this.isBraveReleaseBuild()) {

chromium_src/components/privacy_sandbox/privacy_sandbox_settings_unittest.cc

@@ -188,7 +188,7 @@ class PrivacySandboxSettingsTest : public testing::Test {
       tracking_protection_settings_;
 
   std::unique_ptr<PrivacySandboxSettings> privacy_sandbox_settings_;
-  raw_ptr<MockPrivacySandboxDelegate> mock_delegate_;
+  raw_ptr<MockPrivacySandboxDelegate, DanglingUntriaged> mock_delegate_;
 };
 
 TEST_F(PrivacySandboxSettingsTest, PreferenceOverridesDefaultContentSetting) {

components/ai_chat/core/browser/ai_chat_service_unittest.cc

@@ -172,7 +172,7 @@ class MockConversationHandlerClient : public mojom::ConversationUI {
  private:
   mojo::Receiver<mojom::ConversationUI> conversation_ui_receiver_{this};
   mojo::Remote<mojom::ConversationHandler> conversation_handler_remote_;
-  raw_ptr<ConversationHandler> conversation_handler_;
+  raw_ptr<ConversationHandler, DanglingUntriaged> conversation_handler_;
 };
 
 class MockAssociatedContent

components/ai_chat/core/browser/conversation_handler.h

@@ -359,10 +359,10 @@ class ConversationHandler : public mojom::ConversationHandler,
 
   // Data store UUID for conversation
   raw_ptr<const mojom::Conversation> metadata_;
-  raw_ptr<AIChatService> ai_chat_service_;
+  raw_ptr<AIChatService, DanglingUntriaged> ai_chat_service_;
   raw_ptr<ModelService> model_service_;
-  raw_ptr<AIChatCredentialManager> credential_manager_;
-  raw_ptr<AIChatFeedbackAPI> feedback_api_;
+  raw_ptr<AIChatCredentialManager, DanglingUntriaged> credential_manager_;
+  raw_ptr<AIChatFeedbackAPI, DanglingUntriaged> feedback_api_;
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
 
   base::ScopedObservation<ModelService, ModelService::Observer>

components/ai_chat/core/browser/engine/conversation_api_client.h

@@ -107,7 +107,7 @@ class ConversationAPIClient {
 
   const std::string model_name_;
   std::unique_ptr<api_request_helper::APIRequestHelper> api_request_helper_;
-  raw_ptr<AIChatCredentialManager> credential_manager_;
+  raw_ptr<AIChatCredentialManager, DanglingUntriaged> credential_manager_;
 
   base::WeakPtrFactory<ConversationAPIClient> weak_ptr_factory_{this};
 };

components/brave_component_updater/browser/brave_component.h

@@ -100,7 +100,7 @@ class BraveComponent {
   std::string component_name_;
   std::string component_id_;
   std::string component_base64_public_key_;
-  raw_ptr<Delegate> delegate_ = nullptr;  // NOT OWNED
+  raw_ptr<Delegate, DanglingUntriaged> delegate_ = nullptr;
   base::WeakPtrFactory<BraveComponent> weak_factory_;
 };
 

components/brave_vpn/browser/brave_vpn_service.h

@@ -234,7 +234,8 @@ class BraveVpnService :
                           BraveVPNConnectionManager::Observer>
       observed_{this};
   bool wait_region_data_ready_ = false;
-  raw_ptr<BraveVPNConnectionManager> connection_manager_ = nullptr;
+  raw_ptr<BraveVPNConnectionManager, DanglingUntriaged> connection_manager_ =
+      nullptr;
 
   PrefChangeRegistrar policy_pref_change_registrar_;
 #endif  // !BUILDFLAG(IS_ANDROID)

components/brave_wallet/browser/bitcoin/bitcoin_wallet_service.h

@@ -171,7 +171,7 @@ class BitcoinWalletService : public mojom::BitcoinWalletService,
                                 const mojom::BitcoinSignature& hw_signature);
   void CreateTransactionTaskDone(CreateTransactionTask* task);
 
-  raw_ptr<KeyringService> keyring_service_;
+  raw_ptr<KeyringService, DanglingUntriaged> keyring_service_;
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   std::list<std::unique_ptr<CreateTransactionTask>> create_transaction_tasks_;
   std::list<std::unique_ptr<DiscoverWalletAccountTask>>

components/brave_wallet/browser/brave_wallet_p3a_unittest.cc

@@ -351,8 +351,8 @@ class BraveWalletP3AUnitTest : public testing::Test {
   sync_preferences::TestingPrefServiceSyncable local_state_;
   std::unique_ptr<base::HistogramTester> histogram_tester_;
   std::unique_ptr<BitcoinTestRpcServer> bitcoin_test_rpc_server_;
-  raw_ptr<KeyringService> keyring_service_;
-  raw_ptr<TxService> tx_service_;
+  raw_ptr<KeyringService, DanglingUntriaged> keyring_service_;
+  raw_ptr<TxService, DanglingUntriaged> tx_service_;
   std::unique_ptr<BraveWalletService> brave_wallet_service_;
   raw_ptr<BraveWalletP3A> wallet_p3a_;
   scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory_;

components/brave_wallet/browser/json_rpc_service.h

@@ -818,8 +818,8 @@ class JsonRpcService : public mojom::JsonRpcService {
 
   mojo::ReceiverSet<mojom::JsonRpcService> receivers_;
   raw_ptr<NetworkManager> network_manager_ = nullptr;
-  const raw_ptr<PrefService> prefs_ = nullptr;
-  const raw_ptr<PrefService> local_state_prefs_ = nullptr;
+  const raw_ptr<PrefService, DanglingUntriaged> prefs_ = nullptr;
+  const raw_ptr<PrefService, DanglingUntriaged> local_state_prefs_ = nullptr;
   std::unique_ptr<NftMetadataFetcher> nft_metadata_fetcher_;
   std::unique_ptr<SimpleHashClient> simple_hash_client_;
   base::WeakPtrFactory<JsonRpcService> weak_ptr_factory_{this};

components/brave_wallet/browser/network_manager.h

@@ -83,7 +83,7 @@ class NetworkManager {
       const std::string& network_id);
 
  private:
-  raw_ptr<PrefService> prefs_ = nullptr;
+  raw_ptr<PrefService, DanglingUntriaged> prefs_ = nullptr;
 };
 
 }  // namespace brave_wallet

components/brave_wallet/browser/nft_metadata_fetcher.h

@@ -103,7 +103,7 @@ class NftMetadataFetcher {
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   std::unique_ptr<APIRequestHelper> api_request_helper_;
   raw_ptr<JsonRpcService> json_rpc_service_ = nullptr;
-  raw_ptr<PrefService> prefs_ = nullptr;
+  raw_ptr<PrefService, DanglingUntriaged> prefs_ = nullptr;
   base::WeakPtrFactory<NftMetadataFetcher> weak_ptr_factory_;
 };
 

components/brave_wallet/browser/tx_storage_delegate_impl.h

@@ -80,7 +80,7 @@ class TxStorageDelegateImpl final : public TxStorageDelegate {
 
   std::unique_ptr<value_store::ValueStoreFrontend> store_;
 
-  raw_ptr<PrefService> prefs_;
+  raw_ptr<PrefService, DanglingUntriaged> prefs_;
   base::WeakPtrFactory<TxStorageDelegateImpl> weak_factory_{this};
 };
 

components/brave_wallet/browser/wallet_data_files_installer_unittest.cc

@@ -228,7 +228,7 @@ class WalletDataFilesInstallerUnitTest : public testing::Test {
   network::TestURLLoaderFactory url_loader_factory_;
   scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory_;
   data_decoder::test::InProcessDataDecoder in_process_data_decoder_;
-  raw_ptr<KeyringService> keyring_service_;
+  raw_ptr<KeyringService, DanglingUntriaged> keyring_service_;
   std::unique_ptr<BraveWalletService> brave_wallet_service_;
   std::unique_ptr<component_updater::MockComponentUpdateService> cus_;
   base::FilePath install_dir_;

components/brave_wallet/browser/zcash/zcash_block_tracker.h

@@ -50,7 +50,7 @@ class ZCashBlockTracker : public BlockTracker {
   std::map<std::string, uint32_t> latest_height_map_;
   base::ObserverList<Observer> observers_;
 
-  raw_ptr<ZCashRpc> zcash_rpc_ = nullptr;
+  raw_ptr<ZCashRpc, DanglingUntriaged> zcash_rpc_ = nullptr;
 
   base::WeakPtrFactory<ZCashBlockTracker> weak_ptr_factory_{this};
 };

components/brave_wallet/browser/zcash/zcash_tx_manager.h

@@ -85,7 +85,7 @@ class ZCashTxManager : public TxManager, public ZCashBlockTracker::Observer {
                               base::expected<bool, std::string> confirm_status);
 
   raw_ptr<ZCashWalletService> zcash_wallet_service_ = nullptr;
-  raw_ptr<ZCashRpc> zcash_rpc_ = nullptr;
+  raw_ptr<ZCashRpc, DanglingUntriaged> zcash_rpc_ = nullptr;
   base::ScopedObservation<ZCashBlockTracker, ZCashBlockTracker::Observer>
       block_tracker_observation_{this};
   base::WeakPtrFactory<ZCashTxManager> weak_factory_{this};

components/ntp_background_images/browser/ntp_custom_images_source.h

@@ -43,7 +43,8 @@ class NTPCustomImagesSource : public content::URLDataSource {
                     GotDataCallback callback);
   void OnGotImageFile(GotDataCallback callback, const std::string& input);
 
-  raw_ptr<BraveNTPCustomBackgroundService> service_ = nullptr;  // not owned
+  raw_ptr<BraveNTPCustomBackgroundService, DanglingUntriaged> service_ =
+      nullptr;  // not owned
   base::WeakPtrFactory<NTPCustomImagesSource> weak_factory_;
 };
 

components/p3a/constellation_log_store.h

@@ -86,7 +86,7 @@ class ConstellationLogStore : public metrics::LogStore {
 
   size_t GetMaxEpochsToRetain() const;
 
-  const raw_ref<PrefService> local_state_;
+  const raw_ref<PrefService, DanglingUntriaged> local_state_;
   MetricLogType log_type_;
 
   base::flat_map<LogKey, std::string, LogKeyCompare> log_;

components/p3a/message_manager.h

@@ -123,7 +123,7 @@ class MessageManager : public MetricLogStore::Delegate {
   bool IsActualMetric(const std::string& histogram_name) const override;
   bool IsEphemeralMetric(const std::string& histogram_name) const override;
 
-  const raw_ref<PrefService> local_state_;
+  const raw_ref<PrefService, DanglingUntriaged> local_state_;
 
   MessageMetainfo message_meta_;
 

components/p3a/metric_log_store.h

@@ -102,7 +102,7 @@ class MetricLogStore : public metrics::LogStore {
   const char* GetPrefName() const;
 
   const raw_ref<Delegate> delegate_;
-  const raw_ref<PrefService> local_state_;
+  const raw_ref<PrefService, DanglingUntriaged> local_state_;
 
   MetricLogType type_;
 

components/p3a/p3a_message.h

@@ -59,7 +59,7 @@ class MessageMetainfo {
   // attributes.
   void MaybeStripCountry();
 
-  raw_ptr<PrefService> local_state_ = nullptr;
+  raw_ptr<PrefService, DanglingUntriaged> local_state_ = nullptr;
 };
 
 base::Value::Dict GenerateP3AMessageDict(std::string_view metric_name,

components/p3a/rotation_scheduler.h

@@ -65,7 +65,7 @@ class RotationScheduler {
   base::flat_map<MetricLogType, base::Time> last_json_rotation_times_;
   base::flat_map<MetricLogType, base::Time> last_constellation_rotation_times_;
 
-  const raw_ref<PrefService> local_state_;
+  const raw_ref<PrefService, DanglingUntriaged> local_state_;
   const raw_ptr<const P3AConfig> config_;
 };
 

components/p3a/star_randomness_meta.h

@@ -109,7 +109,7 @@ class StarRandomnessMeta {
 
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
 
-  const raw_ptr<PrefService> local_state_;
+  const raw_ptr<PrefService, DanglingUntriaged> local_state_;
 
   base::flat_map<MetricLogType, std::unique_ptr<RandomnessServerUpdateState>>
       update_states_;