Annotate all Across tasks dangling raw_ptrs

This follows up on https://crrev.com/c/4567353 and annotates all
raw_ptrs that were detected as dangling across tasks on the CQ in the
following CL https://crrev.com/c/4166936.

Change-Id: I8ac81276b72c315d7624008cf7421a419b7786ea
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4650611
Reviewed-by: danakj <danakj@chromium.org>
Commit-Queue: Pâris Meuleman <pmeuleman@chromium.org>
Owners-Override: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1164246}

ash/frame_sink/frame_sink_holder_test_api.h

@@ -30,7 +30,7 @@ class FrameSinkHolderTestApi {
   bool IsFirstFrameRequested() const;
 
  private:
-  raw_ptr<FrameSinkHolder, DanglingUntriaged> frame_sink_holder_;
+  raw_ptr<FrameSinkHolder, DanglingAcrossTasks> frame_sink_holder_;
 };
 
 }  // namespace ash

ash/frame_sink/test/test_begin_frame_source.h

@@ -46,7 +46,7 @@ class TestBeginFrameSource : public viz::BeginFrameSource {
   viz::BeginFrameObserver* GetBeginFrameObserver() const;
 
  private:
-  raw_ptr<viz::BeginFrameObserver, DanglingUntriaged> observer_;
+  raw_ptr<viz::BeginFrameObserver, DanglingAcrossTasks> observer_;
 };
 
 viz::BeginFrameArgs CreateValidBeginFrameArgsForTesting();

ash/in_session_auth/authentication_dialog.h

@@ -41,7 +41,7 @@ class AuthenticationDialog : public views::DialogDelegateView {
     }
 
    private:
-    raw_ptr<AuthenticationDialog, DanglingUntriaged> const dialog_;
+    raw_ptr<AuthenticationDialog, DanglingAcrossTasks> const dialog_;
   };
 
   // |on_auth_complete| is called when the user has been authenticated

ash/in_session_auth/authentication_dialog_unittest.cc

@@ -117,9 +117,9 @@ class AuthenticationDialogTest : public AshTestBase {
 
   absl::optional<bool> success_;
   base::UnguessableToken token_;
-  raw_ptr<AuthenticationDialog, DanglingUntriaged> dialog_;
+  raw_ptr<AuthenticationDialog, DanglingAcrossTasks> dialog_;
   std::unique_ptr<MockInSessionAuthTokenProvider> auth_token_provider_;
-  raw_ptr<MockAuthPerformer, DanglingUntriaged> auth_performer_;
+  raw_ptr<MockAuthPerformer, DanglingAcrossTasks> auth_performer_;
   std::unique_ptr<AuthenticationDialog::TestApi> test_api_;
 };
 

ash/login/ui/lock_contents_view.h

@@ -439,7 +439,7 @@ class ASH_EXPORT LockContentsView
 
   // If the kiosk app button is not visible, the kiosk app default message would
   // be shown.
-  raw_ptr<KioskAppDefaultMessage, DanglingUntriaged> kiosk_default_message_ =
+  raw_ptr<KioskAppDefaultMessage, DanglingAcrossTasks> kiosk_default_message_ =
       nullptr;
 
   // Actions that should be executed before a new layout happens caused by a
@@ -467,7 +467,7 @@ class ASH_EXPORT LockContentsView
   raw_ptr<LoginErrorBubble, ExperimentalAsh> warning_banner_bubble_;
 
   // View that is shown on login timeout with camera usage.
-  raw_ptr<LoginCameraTimeoutView, DanglingUntriaged>
+  raw_ptr<LoginCameraTimeoutView, DanglingAcrossTasks>
       login_camera_timeout_view_ = nullptr;
 
   // Bottom status indicator displaying entreprise domain or ADB enabled alert

base/files/file_descriptor_watcher_posix.cc

@@ -67,7 +67,7 @@ class FileDescriptorWatcher::Controller::Watcher
 
   // WaitableEvent to signal to ensure that the Watcher is always destroyed
   // before the Controller.
-  const raw_ref<base::WaitableEvent, DanglingUntriaged> on_destroyed_;
+  const raw_ref<base::WaitableEvent, DanglingAcrossTasks> on_destroyed_;
 
   // Whether this Watcher is notified when |fd_| becomes readable or writable
   // without blocking.

base/synchronization/waitable_event_watcher.h

@@ -118,7 +118,7 @@ class BASE_EXPORT WaitableEventWatcher
   win::ObjectWatcher watcher_;
 
   EventCallback callback_;
-  raw_ptr<WaitableEvent, DanglingUntriaged> event_ = nullptr;
+  raw_ptr<WaitableEvent, DanglingAcrossTasks> event_ = nullptr;
 #elif BUILDFLAG(IS_APPLE)
   // Invokes the callback and resets the source. Must be called on the task
   // runner on which StartWatching() was called.

base/task/sequence_manager/delayed_task_handle_delegate.h

@@ -42,7 +42,7 @@ class DelayedTaskHandleDelegate : public DelayedTaskHandle::Delegate {
 
  private:
   // The TaskQueueImpl where the task was posted.
-  const raw_ptr<TaskQueueImpl, DanglingUntriaged> outer_
+  const raw_ptr<TaskQueueImpl, DanglingAcrossTasks> outer_
       GUARDED_BY_CONTEXT(sequence_checker_);
 
   // The HeapHandle to the task, if the task is in the DelayedIncomingQueue,

base/task/sequence_manager/task_queue_impl.h

@@ -570,7 +570,7 @@ class BASE_EXPORT TaskQueueImpl {
   }
 
   QueueName name_;
-  const raw_ptr<SequenceManagerImpl, DanglingUntriaged> sequence_manager_;
+  const raw_ptr<SequenceManagerImpl, DanglingAcrossTasks> sequence_manager_;
 
   const scoped_refptr<const AssociatedThreadId> associated_thread_;
 

base/task/task_runner.cc

@@ -28,7 +28,7 @@ class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl {
   bool PostTask(const Location& from_here, OnceClosure task) override;
 
   // Non-owning.
-  raw_ptr<TaskRunner, DanglingUntriaged> destination_;
+  raw_ptr<TaskRunner, DanglingAcrossTasks> destination_;
 };
 
 PostTaskAndReplyTaskRunner::PostTaskAndReplyTaskRunner(

base/task/thread_pool/pooled_single_thread_task_runner_manager.cc

@@ -528,7 +528,7 @@ class PooledSingleThreadTaskRunnerManager::PooledSingleThreadTaskRunner
                 DisableDanglingPtrDetection>
       outer_;
 
-  const raw_ptr<WorkerThread, DanglingUntriaged> worker_;
+  const raw_ptr<WorkerThread, DanglingAcrossTasks> worker_;
   const SingleThreadTaskRunnerThreadMode thread_mode_;
   const scoped_refptr<Sequence> sequence_;
 };

base/trace_event/memory_dump_provider_info.h

@@ -79,7 +79,7 @@ struct BASE_EXPORT MemoryDumpProviderInfo
 
   // It is safe to access the const fields below from any thread as they are
   // never mutated.
-  const raw_ptr<MemoryDumpProvider, DanglingUntriaged> dump_provider;
+  const raw_ptr<MemoryDumpProvider, DanglingAcrossTasks> dump_provider;
 
   // The |options| arg passed to MDM::RegisterDumpProvider().
   const MemoryDumpProvider::Options options;

cc/layers/render_surface_impl.h

@@ -302,7 +302,7 @@ class CC_EXPORT RenderSurfaceImpl {
 
   // The nearest ancestor target surface that will contain the contents of this
   // surface, and that ignores outside occlusion. This can point to itself.
-  raw_ptr<const RenderSurfaceImpl, DanglingUntriaged>
+  raw_ptr<const RenderSurfaceImpl, DanglingAcrossTasks>
       nearest_occlusion_immune_ancestor_;
 
   std::unique_ptr<DamageTracker> damage_tracker_;

cc/layers/texture_layer_unittest.cc

@@ -1450,7 +1450,7 @@ class SoftwareTextureLayerTest : public LayerTreeTest {
   scoped_refptr<Layer> root_;
   scoped_refptr<SolidColorLayer> solid_color_layer_;
   scoped_refptr<TextureLayer> texture_layer_;
-  raw_ptr<TestLayerTreeFrameSink, DanglingUntriaged> frame_sink_ = nullptr;
+  raw_ptr<TestLayerTreeFrameSink, DanglingAcrossTasks> frame_sink_ = nullptr;
   int num_frame_sinks_created_ = 0;
 };
 
@@ -1931,7 +1931,7 @@ class SoftwareTextureLayerLoseFrameSinkTest : public SoftwareTextureLayerTest {
   scoped_refptr<CrossThreadSharedBitmap> bitmap_;
   // Keeps a pointer value of the first frame sink, which will be removed
   // from the host and destroyed.
-  raw_ptr<void, DanglingUntriaged> first_frame_sink_;
+  raw_ptr<void, DanglingAcrossTasks> first_frame_sink_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(SoftwareTextureLayerLoseFrameSinkTest);

cc/test/layer_tree_test.cc

@@ -674,7 +674,7 @@ class LayerTreeTestLayerTreeFrameSinkClient
 
  private:
   raw_ptr<TestHooks> hooks_;
-  raw_ptr<TaskRunnerProvider, DanglingUntriaged> task_runner_provider_;
+  raw_ptr<TaskRunnerProvider, DanglingAcrossTasks> task_runner_provider_;
 };
 
 LayerTreeTest::LayerTreeTest(viz::RendererType renderer_type)

cc/tiles/software_image_decode_cache.cc

@@ -120,7 +120,7 @@ class SoftwareImageDecodeTaskImpl : public TileTask {
   ~SoftwareImageDecodeTaskImpl() override = default;
 
  private:
-  raw_ptr<SoftwareImageDecodeCache, DanglingUntriaged> cache_;
+  raw_ptr<SoftwareImageDecodeCache, DanglingAcrossTasks> cache_;
   SoftwareImageDecodeCache::CacheKey image_key_;
   PaintImage paint_image_;
   SoftwareImageDecodeCache::DecodeTaskType task_type_;

cc/tiles/tile_manager.cc

@@ -366,7 +366,7 @@ class DidFinishRunningAllTilesTask : public TileTask {
 
  private:
   raw_ptr<base::SequencedTaskRunner> task_runner_;
-  raw_ptr<RasterQueryQueue, DanglingUntriaged> pending_raster_queries_;
+  raw_ptr<RasterQueryQueue, DanglingAcrossTasks> pending_raster_queries_;
   CompletionCb completion_cb_;
 };
 

cc/trees/layer_tree_host_unittest.cc

@@ -622,8 +622,8 @@ class LayerTreeHostContextCacheTest : public LayerTreeHostTest {
                  void(bool aggressively_free_resources));
   };
 
-  raw_ptr<MockContextSupport, DanglingUntriaged> mock_main_context_support_;
-  raw_ptr<MockContextSupport, DanglingUntriaged> mock_worker_context_support_;
+  raw_ptr<MockContextSupport, DanglingAcrossTasks> mock_main_context_support_;
+  raw_ptr<MockContextSupport, DanglingAcrossTasks> mock_worker_context_support_;
 };
 
 // Test if the LTH successfully frees resources on the main/worker
@@ -6010,7 +6010,8 @@ class LayerTreeHostTestElasticOverscroll : public LayerTreeHostTest {
  private:
   FakeContentLayerClient client_;
   raw_ptr<Layer, DanglingUntriaged> root_layer_;
-  raw_ptr<ScrollElasticityHelper, DanglingUntriaged> scroll_elasticity_helper_;
+  raw_ptr<ScrollElasticityHelper, DanglingAcrossTasks>
+      scroll_elasticity_helper_;
   int content_layer_id_;
   int num_draws_;
 };

cc/trees/layer_tree_host_unittest_context.cc

@@ -159,8 +159,8 @@ class LayerTreeHostContextTest : public LayerTreeTest {
   // Protects use of gl_ so LoseContext and
   // CreateDisplayLayerTreeFrameSink can both use it on different threads.
   base::Lock gl_lock_;
-  raw_ptr<viz::TestGLES2Interface, DanglingUntriaged> gl_ = nullptr;
-  raw_ptr<viz::TestSharedImageInterface, DanglingUntriaged> sii_ = nullptr;
+  raw_ptr<viz::TestGLES2Interface, DanglingAcrossTasks> gl_ = nullptr;
+  raw_ptr<viz::TestSharedImageInterface, DanglingAcrossTasks> sii_ = nullptr;
 
   int times_to_fail_create_;
   int times_to_lose_during_commit_;
@@ -693,7 +693,7 @@ class LayerTreeHostContextTestLostContextAndEvictTextures
  protected:
   bool lose_after_evict_;
   FakeContentLayerClient client_;
-  raw_ptr<LayerTreeHostImpl, DanglingUntriaged> impl_host_;
+  raw_ptr<LayerTreeHostImpl, DanglingAcrossTasks> impl_host_;
   int num_commits_;
   bool lost_context_;
 };

cc/trees/layer_tree_host_unittest_scroll.cc

@@ -2401,7 +2401,8 @@ class LayerTreeHostScrollTestElasticOverscroll
   // These values should be used on the impl thread only.
   int num_begin_main_frames_impl_thread_;
   MockInputHandlerClient input_handler_client_;
-  raw_ptr<ScrollElasticityHelper, DanglingUntriaged> scroll_elasticity_helper_;
+  raw_ptr<ScrollElasticityHelper, DanglingAcrossTasks>
+      scroll_elasticity_helper_;
 
   // These values should be used on the main thread only.
   int num_begin_main_frames_main_thread_;

chrome/browser/apps/app_service/uninstall_dialog.h

@@ -75,7 +75,7 @@ class UninstallDialog {
     UninstallDialog* uninstall_dialog() const { return uninstall_dialog_; }
 
    private:
-    raw_ptr<UninstallDialog, DanglingUntriaged> uninstall_dialog_;
+    raw_ptr<UninstallDialog, DanglingAcrossTasks> uninstall_dialog_;
   };
 
   // Called when the dialog closes after the user has made a decision about
@@ -132,7 +132,7 @@ class UninstallDialog {
 
   OnUninstallForTestingCallback uninstall_dialog_created_callback_;
 
-  raw_ptr<views::Widget, DanglingUntriaged> widget_ = nullptr;
+  raw_ptr<views::Widget, DanglingAcrossTasks> widget_ = nullptr;
 
   // Tracks whether |parent_window_| got destroyed.
   std::unique_ptr<views::NativeWindowTracker> parent_window_tracker_;

chrome/browser/apps/app_shim/mach_bootstrap_acceptor.h

@@ -62,7 +62,7 @@ class MachBootstrapAcceptor {
   mach_port_t port();
 
   mojo::NamedPlatformChannel::ServerName server_name_;
-  raw_ptr<Delegate, DanglingUntriaged> delegate_;
+  raw_ptr<Delegate, DanglingAcrossTasks> delegate_;
   mojo::PlatformChannelServerEndpoint endpoint_;
   std::unique_ptr<base::DispatchSourceMach> dispatch_source_;
 };

chrome/browser/apps/guest_view/web_view_browsertest.cc

@@ -852,8 +852,8 @@ class WebViewTest : public extensions::PlatformAppBrowserTest {
 
   TestGuestViewManagerFactory factory_;
   // Note that these are only set if you launch app using LoadAppWithGuest().
-  raw_ptr<guest_view::GuestViewBase, DanglingUntriaged> guest_view_;
-  raw_ptr<content::WebContents, DanglingUntriaged> embedder_web_contents_;
+  raw_ptr<guest_view::GuestViewBase, DanglingAcrossTasks> guest_view_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> embedder_web_contents_;
 };
 
 // The following test suites are created to group tests based on specific

chrome/browser/apps/guest_view/web_view_interactive_browsertest.cc

@@ -511,8 +511,8 @@ class WebViewInteractiveTest : public extensions::PlatformAppBrowserTest {
  protected:
   TestGuestViewManagerFactory factory_;
   // Only set if `SetupTest` or `TestHelper` are called.
-  raw_ptr<guest_view::GuestViewBase, DanglingUntriaged> guest_view_;
-  raw_ptr<content::WebContents, DanglingUntriaged> embedder_web_contents_;
+  raw_ptr<guest_view::GuestViewBase, DanglingAcrossTasks> guest_view_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> embedder_web_contents_;
 
   gfx::Point corner_;
   bool mouse_click_result_;

chrome/browser/ash/arc/input_overlay/touch_injector.h

@@ -255,7 +255,7 @@ class TouchInjector : public ui::EventRewriter {
   // TouchInjector is created when targeted |window_| is created and is
   // registered only when |window_| is focused. And TouchInjector doesn't own
   // |window_| and it is destroyed when |window_| is destroyed.
-  raw_ptr<aura::Window, DanglingUntriaged> window_;
+  raw_ptr<aura::Window, DanglingAcrossTasks> window_;
   std::string package_name_;
   gfx::RectF content_bounds_;
   base::WeakPtr<ui::EventRewriterContinuation> continuation_;

chrome/browser/ash/login/saml/lockscreen_reauth_dialog_test_helper.h

@@ -149,21 +149,22 @@ class LockScreenReauthDialogTestHelper {
   void WaitForNetworkDialogToLoad();
 
   // Main Dialog
-  raw_ptr<LockScreenStartReauthDialog, DanglingUntriaged> reauth_dialog_ =
+  raw_ptr<LockScreenStartReauthDialog, DanglingAcrossTasks> reauth_dialog_ =
       nullptr;
-  raw_ptr<LockScreenStartReauthUI, DanglingUntriaged> reauth_webui_controller_ =
-      nullptr;
-  raw_ptr<LockScreenReauthHandler, DanglingUntriaged> main_handler_ = nullptr;
+  raw_ptr<LockScreenStartReauthUI, DanglingAcrossTasks>
+      reauth_webui_controller_ = nullptr;
+  raw_ptr<LockScreenReauthHandler, DanglingAcrossTasks> main_handler_ = nullptr;
 
   // Network dialog which is owned by the main dialog.
-  raw_ptr<LockScreenNetworkDialog, DanglingUntriaged> network_dialog_ = nullptr;
-  raw_ptr<LockScreenNetworkUI, DanglingUntriaged> network_webui_controller_ =
+  raw_ptr<LockScreenNetworkDialog, DanglingAcrossTasks> network_dialog_ =
       nullptr;
-  raw_ptr<NetworkConfigMessageHandler, DanglingUntriaged> network_handler_ =
+  raw_ptr<LockScreenNetworkUI, DanglingAcrossTasks> network_webui_controller_ =
+      nullptr;
+  raw_ptr<NetworkConfigMessageHandler, DanglingAcrossTasks> network_handler_ =
       nullptr;
 
   // Captive portal dialog which is owned by the main dialog.
-  raw_ptr<LockScreenCaptivePortalDialog, DanglingUntriaged>
+  raw_ptr<LockScreenCaptivePortalDialog, DanglingAcrossTasks>
       captive_portal_dialog_ = nullptr;
 };
 

chrome/browser/ash/login/screens/recommend_apps_screen_browsertest.cc

@@ -202,11 +202,11 @@ class RecommendAppsScreenTest : public OobeBaseTest {
     test::OobeJS().ExpectHiddenPath({kRecommendAppsId, "loadingDialog"});
   }
 
-  raw_ptr<RecommendAppsScreen, DanglingUntriaged> recommend_apps_screen_ =
+  raw_ptr<RecommendAppsScreen, DanglingAcrossTasks> recommend_apps_screen_ =
       nullptr;
   absl::optional<RecommendAppsScreen::Result> screen_result_;
-  raw_ptr<StubRecommendAppsFetcher, DanglingUntriaged> recommend_apps_fetcher_ =
-      nullptr;
+  raw_ptr<StubRecommendAppsFetcher, DanglingAcrossTasks>
+      recommend_apps_fetcher_ = nullptr;
 
   LoginManagerMixin login_manager_{&mixin_host_};
 

chrome/browser/background_fetch/background_fetch_browsertest.cc

@@ -235,7 +235,7 @@ class OfflineContentProviderObserver final
 
   ItemsAddedCallback items_added_callback_;
   FinishedProcessingItemCallback finished_processing_item_callback_;
-  raw_ptr<BackgroundFetchDelegateImpl, DanglingUntriaged> delegate_ = nullptr;
+  raw_ptr<BackgroundFetchDelegateImpl, DanglingAcrossTasks> delegate_ = nullptr;
   bool pause_ = false;
   bool resume_ = false;
 
@@ -473,8 +473,8 @@ class BackgroundFetchBrowserTest : public InProcessBrowserTest {
   net::EmbeddedTestServer* https_server() { return https_server_.get(); }
 
  protected:
-  raw_ptr<BackgroundFetchDelegateImpl, DanglingUntriaged> delegate_ = nullptr;
-  raw_ptr<download::BackgroundDownloadService, DanglingUntriaged>
+  raw_ptr<BackgroundFetchDelegateImpl, DanglingAcrossTasks> delegate_ = nullptr;
+  raw_ptr<download::BackgroundDownloadService, DanglingAcrossTasks>
       download_service_ = nullptr;
   base::OnceClosure click_event_closure_;
 
@@ -504,7 +504,7 @@ class BackgroundFetchBrowserTest : public InProcessBrowserTest {
 
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
 
-  raw_ptr<Browser, DanglingUntriaged> active_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> active_browser_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_F(BackgroundFetchBrowserTest, DownloadService_Acceptance) {

chrome/browser/bluetooth/web_bluetooth_browsertest.cc

@@ -540,12 +540,12 @@ class WebBluetoothTest : public InProcessBrowserTest {
       global_values_;
   scoped_refptr<FakeBluetoothAdapter> adapter_;
   TestContentBrowserClient browser_client_;
-  raw_ptr<content::ContentBrowserClient, DanglingUntriaged>
+  raw_ptr<content::ContentBrowserClient, DanglingAcrossTasks>
       old_browser_client_ = nullptr;
-  raw_ptr<FakeBluetoothGattCharacteristic, DanglingUntriaged> characteristic_ =
-      nullptr;
+  raw_ptr<FakeBluetoothGattCharacteristic, DanglingAcrossTasks>
+      characteristic_ = nullptr;
 
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   std::unique_ptr<content::URLLoaderInterceptor> url_loader_interceptor_;
 
   // Web Bluetooth needs HTTPS to work (a secure context). Moreover,

chrome/browser/browsing_data/browsing_data_remover_browsertest_base.h

@@ -97,7 +97,7 @@ class BrowsingDataRemoverBrowserTestBase : public PlatformBrowserTest {
  private:
   base::test::ScopedFeatureList feature_list_;
 #if !BUILDFLAG(IS_ANDROID)
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 #endif
 };
 

chrome/browser/browsing_data/cookies_tree_model.h

@@ -231,17 +231,17 @@ class CookieTreeHostNode : public CookieTreeNode {
   // the COOKIES node to add children. Checking each child and interrogating
   // them to see if they are a COOKIES, DATABASES, etc node seems
   // less preferable than storing an extra pointer per origin.
-  raw_ptr<CookieTreeCookiesNode, DanglingUntriaged> cookies_child_ = nullptr;
-  raw_ptr<CookieTreeDatabasesNode, DanglingUntriaged> databases_child_ =
+  raw_ptr<CookieTreeCookiesNode, DanglingAcrossTasks> cookies_child_ = nullptr;
+  raw_ptr<CookieTreeDatabasesNode, DanglingAcrossTasks> databases_child_ =
       nullptr;
-  raw_ptr<CookieTreeLocalStoragesNode, DanglingUntriaged>
+  raw_ptr<CookieTreeLocalStoragesNode, DanglingAcrossTasks>
       local_storages_child_ = nullptr;
-  raw_ptr<CookieTreeSessionStoragesNode, DanglingUntriaged>
+  raw_ptr<CookieTreeSessionStoragesNode, DanglingAcrossTasks>
       session_storages_child_ = nullptr;
-  raw_ptr<CookieTreeIndexedDBsNode, DanglingUntriaged> indexed_dbs_child_ =
+  raw_ptr<CookieTreeIndexedDBsNode, DanglingAcrossTasks> indexed_dbs_child_ =
       nullptr;
   raw_ptr<CookieTreeFileSystemsNode> file_systems_child_ = nullptr;
-  raw_ptr<CookieTreeQuotaNode, DanglingUntriaged> quota_child_ = nullptr;
+  raw_ptr<CookieTreeQuotaNode, DanglingAcrossTasks> quota_child_ = nullptr;
   raw_ptr<CookieTreeServiceWorkersNode> service_workers_child_ = nullptr;
   raw_ptr<CookieTreeSharedWorkersNode> shared_workers_child_ = nullptr;
   raw_ptr<CookieTreeCacheStoragesNode> cache_storages_child_ = nullptr;

chrome/browser/chromeos/enterprise/incognito_navigation_throttle_browsertest.cc

@@ -163,9 +163,9 @@ class IncognitoNavigationThrottleBrowserTest
   }
 
   scoped_refptr<const extensions::Extension> extension_;
-  raw_ptr<extensions::ExtensionRegistry, DanglingUntriaged> registry_;
+  raw_ptr<extensions::ExtensionRegistry, DanglingAcrossTasks> registry_;
   testing::NiceMock<policy::MockConfigurationPolicyProvider> policy_provider_;
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 };
 
 // Verify that when the `MandatoryExtensionsForIncognitoNavigation` policy is

chrome/browser/dips/dips_bounce_detector_browsertest.cc

@@ -456,7 +456,7 @@ class DIPSBounceDetectorBrowserTest : public PlatformBrowserTest {
   content::test::PrerenderTestHelper prerender_test_helper_;
   content::test::FencedFrameTestHelper fenced_frame_test_helper_;
   base::test::ScopedFeatureList scoped_feature_list_;
-  raw_ptr<DIPSWebContentsObserver, DanglingUntriaged> web_contents_observer_ =
+  raw_ptr<DIPSWebContentsObserver, DanglingAcrossTasks> web_contents_observer_ =
       nullptr;
 };
 

chrome/browser/dips/dips_helper_browsertest.cc

@@ -194,7 +194,7 @@ class DIPSTabHelperBrowserTest : public PlatformBrowserTest,
   }
 
  private:
-  raw_ptr<WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   base::SimpleTestClock test_clock_;
   base::test::ScopedFeatureList scoped_feature_list_;
   raw_ptr<HostContentSettingsMap> map_;

chrome/browser/dips/dips_state.h

@@ -70,7 +70,7 @@ class DIPSState {
   StateValue ToStateValue() const { return state_; }
 
  private:
-  raw_ptr<DIPSStorage, DanglingUntriaged> storage_;
+  raw_ptr<DIPSStorage, DanglingAcrossTasks> storage_;
   std::string site_;
   bool was_loaded_;
   DirtyBit dirty_;

chrome/browser/dips/dips_test_utils.h

@@ -142,7 +142,8 @@ class FrameCookieAccessObserver : public content::WebContentsObserver {
                          const content::CookieAccessDetails& details) override;
 
  private:
-  const raw_ptr<content::RenderFrameHost, DanglingUntriaged> render_frame_host_;
+  const raw_ptr<content::RenderFrameHost, DanglingAcrossTasks>
+      render_frame_host_;
   CookieOperation access_type_;
   base::RunLoop run_loop_;
 };
@@ -177,7 +178,8 @@ class UserActivationObserver : public content::WebContentsObserver {
   void FrameReceivedUserActivation(
       content::RenderFrameHost* render_frame_host) override;
 
-  raw_ptr<content::RenderFrameHost, DanglingUntriaged> const render_frame_host_;
+  raw_ptr<content::RenderFrameHost, DanglingAcrossTasks> const
+      render_frame_host_;
   base::RunLoop run_loop_;
 };
 

chrome/browser/dom_distiller/distillable_page_utils_browsertest.cc

@@ -125,7 +125,7 @@ class TestOption : public InProcessBrowserTest {
 
   std::unique_ptr<base::RunLoop> run_loop_;
   MockObserver holder_;
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   std::unique_ptr<net::test_server::EmbeddedTestServer> https_server_;
 };
 

chrome/browser/download/download_frame_policy_browsertest.cc

@@ -277,7 +277,8 @@ class DownloadFramePolicyBrowserTest
   std::unique_ptr<content::DownloadTestObserver> download_observer_;
   std::unique_ptr<page_load_metrics::PageLoadMetricsTestWaiter>
       web_feature_waiter_;
-  raw_ptr<content::RenderFrameHost, DanglingUntriaged> subframe_rfh_ = nullptr;
+  raw_ptr<content::RenderFrameHost, DanglingAcrossTasks> subframe_rfh_ =
+      nullptr;
   size_t expected_num_downloads_ = 0;
 };
 

chrome/browser/engagement/site_engagement_helper_browsertest.cc

@@ -105,8 +105,8 @@ class SiteEngagementHelperBrowserTest : public InProcessBrowserTest {
   content::test::PrerenderTestHelper prerender_helper_;
   net::test_server::EmbeddedTestServerHandle test_server_handle_;
   base::HistogramTester histogram_tester_;
-  raw_ptr<TestOneShotTimer, DanglingUntriaged> input_tracker_timer_;
-  raw_ptr<TestOneShotTimer, DanglingUntriaged> media_tracker_timer_;
+  raw_ptr<TestOneShotTimer, DanglingAcrossTasks> input_tracker_timer_;
+  raw_ptr<TestOneShotTimer, DanglingAcrossTasks> media_tracker_timer_;
 };
 
 // Tests if SiteEngagementHelper checks the primary main frame in the

chrome/browser/extensions/api/certificate_provider/certificate_provider_apitest.cc

@@ -289,7 +289,7 @@ class CertificateProviderApiTest : public extensions::ExtensionApiTest {
 
  protected:
   testing::NiceMock<policy::MockConfigurationPolicyProvider> provider_;
-  raw_ptr<chromeos::CertificateProviderService, DanglingUntriaged>
+  raw_ptr<chromeos::CertificateProviderService, DanglingAcrossTasks>
       cert_provider_service_ = nullptr;
   policy::PolicyMap policy_map_;
 
@@ -490,9 +490,10 @@ class CertificateProviderApiMockedExtensionTest
     return certificate_data;
   }
 
-  raw_ptr<content::WebContents, DanglingUntriaged> extension_contents_ =
+  raw_ptr<content::WebContents, DanglingAcrossTasks> extension_contents_ =
+      nullptr;
+  raw_ptr<const extensions::Extension, DanglingAcrossTasks> extension_ =
       nullptr;
-  raw_ptr<const extensions::Extension, DanglingUntriaged> extension_ = nullptr;
   base::FilePath extension_path_;
 };
 
@@ -598,7 +599,8 @@ class CertificateProviderRequestPinTest : public CertificateProviderApiTest {
     extension_ = LoadExtension(extension_path);
   }
 
-  raw_ptr<const extensions::Extension, DanglingUntriaged> extension_ = nullptr;
+  raw_ptr<const extensions::Extension, DanglingAcrossTasks> extension_ =
+      nullptr;
   std::unique_ptr<ExtensionTestMessageListener> command_request_listener_;
 };
 

chrome/browser/extensions/api/content_settings/content_settings_apitest.cc

@@ -244,7 +244,7 @@ class ExtensionContentSettingsApiTest : public ExtensionApiTest {
   }
 
  private:
-  raw_ptr<Profile, DanglingUntriaged> profile_ = nullptr;
+  raw_ptr<Profile, DanglingAcrossTasks> profile_ = nullptr;
   std::unique_ptr<ScopedKeepAlive> keep_alive_;
   std::unique_ptr<ScopedProfileKeepAlive> profile_keep_alive_;
 };

chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc

@@ -205,7 +205,7 @@ class DownloadsEventsListener : public EventRouter::TestObserver {
     }
 
    private:
-    raw_ptr<Profile, DanglingUntriaged> profile_;
+    raw_ptr<Profile, DanglingAcrossTasks> profile_;
     std::string event_name_;
     std::string json_args_;
     base::Value args_;
@@ -274,7 +274,7 @@ class DownloadsEventsListener : public EventRouter::TestObserver {
   base::Time last_wait_;
   std::unique_ptr<Event> waiting_for_;
   base::circular_deque<std::unique_ptr<Event>> events_;
-  raw_ptr<Profile, DanglingUntriaged> profile_;
+  raw_ptr<Profile, DanglingAcrossTasks> profile_;
 };
 
 // Object waiting for a download open event.
@@ -758,8 +758,8 @@ class DownloadExtensionTest : public ExtensionApiTest {
 
   raw_ptr<const Extension, DanglingUntriaged> extension_;
   raw_ptr<const Extension, DanglingUntriaged> second_extension_;
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_;
-  raw_ptr<Browser, DanglingUntriaged> current_browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> current_browser_;
   std::unique_ptr<DownloadsEventsListener> events_listener_;
 
   std::unique_ptr<net::test_server::ControllableHttpResponse> first_download_;

chrome/browser/extensions/api/storage/managed_value_store_cache.h

@@ -93,7 +93,7 @@ class ManagedValueStoreCache : public ValueStoreCache,
       VALID_CONTEXT_REQUIRED(backend_sequence_checker_);
 
   // The profile that owns the extension system being used.
-  const raw_ref<Profile, DanglingUntriaged> profile_
+  const raw_ref<Profile, DanglingAcrossTasks> profile_
       GUARDED_BY_CONTEXT(ui_sequence_checker_);
 
   // The policy domain. This is used for observing the policy updates.
@@ -101,7 +101,7 @@ class ManagedValueStoreCache : public ValueStoreCache,
       GUARDED_BY_CONTEXT(ui_sequence_checker_);
 
   // The `profile_`'s `PolicyService`.
-  const raw_ref<policy::PolicyService, DanglingUntriaged> policy_service_
+  const raw_ref<policy::PolicyService, DanglingAcrossTasks> policy_service_
       GUARDED_BY_CONTEXT(ui_sequence_checker_);
 
   // Observes extension loading and unloading, and keeps the `Profile`'s

chrome/browser/extensions/api/tabs/windows_event_router.h

@@ -88,7 +88,7 @@ class WindowsEventRouter : public AppWindowRegistry::Observer,
   // The profile the currently focused window belongs to; either the main or
   // incognito profile or NULL (none of the above). We remember this in order
   // to correctly handle focus changes between non-OTR and OTR windows.
-  raw_ptr<Profile, DanglingUntriaged> focused_profile_;
+  raw_ptr<Profile, DanglingAcrossTasks> focused_profile_;
 
   // The currently focused window. We keep this so as to avoid sending multiple
   // windows.onFocusChanged events with the same windowId.

chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc

@@ -184,7 +184,7 @@ class DelayLoadStartAndExecuteJavascript : public TabStripModelObserver,
   std::string script_;
   bool has_user_gesture_ = false;
   bool script_was_executed_ = false;
-  raw_ptr<content::RenderFrameHost, DanglingUntriaged> rfh_ = nullptr;
+  raw_ptr<content::RenderFrameHost, DanglingAcrossTasks> rfh_ = nullptr;
 };
 
 // Handles requests for URLs with paths of "/test*" sent to the test server, so

chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_apitest.cc

@@ -995,7 +995,7 @@ class WebrtcLoggingPrivateApiStartEventLoggingTestInIncognitoMode
   bool WebRtcEventLogCollectionPolicy() const override { return true; }
 
  private:
-  raw_ptr<Browser, DanglingUntriaged> browser_{
+  raw_ptr<Browser, DanglingAcrossTasks> browser_{
       nullptr};  // Does not own the object.
 };
 

chrome/browser/extensions/chrome_app_icon.h

@@ -93,7 +93,7 @@ class ChromeAppIcon : public IconImage::Observer {
 
   // Unowned pointers.
   const raw_ptr<ChromeAppIconDelegate> delegate_;
-  const raw_ptr<content::BrowserContext, DanglingUntriaged> browser_context_;
+  const raw_ptr<content::BrowserContext, DanglingAcrossTasks> browser_context_;
 
   // Called when this instance of ChromeAppIcon is destroyed.
   DestroyedCallback destroyed_callback_;

chrome/browser/extensions/chrome_extension_test_notification_observer.h

@@ -56,7 +56,7 @@ class ChromeExtensionTestNotificationObserver
       content::WebContents* web_contents,
       content::BrowserContext* browser_context) override;
 
-  const raw_ptr<Browser, DanglingUntriaged> browser_;
+  const raw_ptr<Browser, DanglingAcrossTasks> browser_;
 };
 
 }  // namespace extensions

chrome/browser/extensions/crx_installer_browsertest.cc

@@ -148,7 +148,7 @@ class MockInstallPrompt : public ExtensionInstallPrompt {
   }
 
  private:
-  raw_ptr<MockPromptProxy, DanglingUntriaged> proxy_;
+  raw_ptr<MockPromptProxy, DanglingAcrossTasks> proxy_;
 };
 
 MockPromptProxy::MockPromptProxy(

chrome/browser/extensions/extension_browsertest.h

@@ -445,7 +445,7 @@ class ExtensionBrowserTest : virtual public InProcessBrowserTest,
 #endif
 
   // The default profile to be used.
-  raw_ptr<Profile, DanglingUntriaged> profile_;
+  raw_ptr<Profile, DanglingAcrossTasks> profile_;
 
   // Cache cache implementation.
   std::unique_ptr<ExtensionCacheFake> test_extension_cache_;

chrome/browser/extensions/extension_install_prompt.h

@@ -198,7 +198,7 @@ class ExtensionInstallPrompt {
     bool is_requesting_host_permissions_;
 
     // The extension being installed.
-    raw_ptr<const extensions::Extension, DanglingUntriaged> extension_;
+    raw_ptr<const extensions::Extension, DanglingAcrossTasks> extension_;
 
     std::string delegated_username_;
 

chrome/browser/geolocation/geolocation_browsertest.cc

@@ -235,7 +235,7 @@ class GeolocationBrowserTest : public InProcessBrowserTest {
   std::unique_ptr<device::ScopedGeolocationOverrider> geolocation_overrider_;
 
   // The current Browser as set in Initialize. May be for an incognito profile.
-  raw_ptr<Browser, DanglingUntriaged> current_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> current_browser_ = nullptr;
 
  private:
   // Calls watchPosition() in JavaScript and accepts or denies the resulting
@@ -247,7 +247,7 @@ class GeolocationBrowserTest : public InProcessBrowserTest {
   std::string html_for_tests_ = "/geolocation/simple.html";
 
   // The frame where the JavaScript calls will run.
-  raw_ptr<content::RenderFrameHost, DanglingUntriaged> render_frame_host_ =
+  raw_ptr<content::RenderFrameHost, DanglingAcrossTasks> render_frame_host_ =
       nullptr;
 
   // The urls for the iframes loaded by LoadIFrames.

chrome/browser/media/history/media_history_browsertest.cc

@@ -1201,7 +1201,7 @@ class MediaHistoryForPrerenderBrowserTest : public MediaHistoryBrowserTest {
   content::WebContents* web_contents() { return web_contents_; }
 
  protected:
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   content::test::PrerenderTestHelper prerender_helper_;
   base::test::ScopedFeatureList feature_list_;
 };

chrome/browser/media/history/media_history_table_base.h

@@ -75,7 +75,7 @@ class MediaHistoryTableBase
   base::AtomicFlag cancelled_;
 
   scoped_refptr<base::UpdateableSequencedTaskRunner> db_task_runner_;
-  raw_ptr<sql::Database, DanglingUntriaged> db_;
+  raw_ptr<sql::Database, DanglingAcrossTasks> db_;
 };
 
 }  // namespace media_history

chrome/browser/media/webrtc/audio_debug_recordings_handler.h

@@ -87,7 +87,7 @@ class AudioDebugRecordingsHandler
                                   const base::FilePath& log_directory);
 
   // The browser context associated with our renderer process.
-  const raw_ptr<content::BrowserContext, DanglingUntriaged> browser_context_;
+  const raw_ptr<content::BrowserContext, DanglingAcrossTasks> browser_context_;
 
   // This counter allows saving each debug recording in separate files.
   uint64_t current_audio_debug_recordings_id_;

chrome/browser/media/webrtc/capture_handle_browsertest.cc

@@ -165,7 +165,7 @@ struct TabInfo {
   }
 
   raw_ptr<Browser> browser;
-  raw_ptr<WebContents, DanglingUntriaged> web_contents;
+  raw_ptr<WebContents, DanglingAcrossTasks> web_contents;
   int tab_strip_index;
   std::string capture_handle;  // Expected value for those who may observe.
 };
@@ -319,7 +319,7 @@ class CaptureHandleBrowserTest : public WebRtcTestBase {
 
   // Incognito browser.
   // Note: The regular one is accessible via browser().
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_F(CaptureHandleBrowserTest,
@@ -786,7 +786,7 @@ class CaptureHandleBrowserTestPrerender : public CaptureHandleBrowserTest {
 
  protected:
   std::unique_ptr<content::test::PrerenderTestHelper> prerender_helper_;
-  raw_ptr<WebContents, DanglingUntriaged> captured_web_contents_ = nullptr;
+  raw_ptr<WebContents, DanglingAcrossTasks> captured_web_contents_ = nullptr;
 };
 
 // Verifies that pre-rendered pages don't change the capture handle config.

chrome/browser/media/webrtc/conditional_focus_browsertest.cc

@@ -172,8 +172,8 @@ class ConditionalFocusBrowserTest : public WebRtcTestBase {
   }
 
  protected:
-  raw_ptr<WebContents, DanglingUntriaged> captured_tab_ = nullptr;
-  raw_ptr<WebContents, DanglingUntriaged> capturing_tab_ = nullptr;
+  raw_ptr<WebContents, DanglingAcrossTasks> captured_tab_ = nullptr;
+  raw_ptr<WebContents, DanglingAcrossTasks> capturing_tab_ = nullptr;
 };
 
 // Flaky on Win bots and on linux release bots http://crbug.com/1264744

chrome/browser/media/webrtc/fake_desktop_media_picker_factory.h

@@ -57,8 +57,8 @@ class FakeDesktopMediaPickerFactory : public DesktopMediaPickerFactory {
       override;
 
  private:
-  raw_ptr<FakeDesktopMediaPicker, DanglingUntriaged> picker_;
-  raw_ptr<TestFlags, DanglingUntriaged | AllowPtrArithmetic> test_flags_;
+  raw_ptr<FakeDesktopMediaPicker, DanglingAcrossTasks> picker_;
+  raw_ptr<TestFlags, DanglingAcrossTasks | AllowPtrArithmetic> test_flags_;
   int tests_count_;
   int current_test_;
   bool is_web_contents_excluded_ = false;

chrome/browser/media/webrtc/region_capture_browsertest.cc

@@ -242,8 +242,8 @@ struct TabInfo {
     return CreateNewElement(frame, "div", id);
   }
 
-  raw_ptr<Browser, DanglingUntriaged> browser;
-  raw_ptr<WebContents, DanglingUntriaged> web_contents;
+  raw_ptr<Browser, DanglingAcrossTasks> browser;
+  raw_ptr<WebContents, DanglingAcrossTasks> web_contents;
   int tab_strip_index;
 };
 

chrome/browser/media/webrtc/webrtc_getdisplaymedia_browsertest.cc

@@ -864,7 +864,7 @@ class GetDisplayMediaVideoTrackBrowserTest
   const DisplaySurfaceType display_surface_type_;
 
  private:
-  raw_ptr<content::WebContents, DanglingUntriaged> tab_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> tab_ = nullptr;
 };
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1002,7 +1002,7 @@ class GetDisplayMediaHiDpiBrowserTest
 
   base::test::ScopedFeatureList feature_list_;
   const TestConfigForHiDpi test_config_;
-  raw_ptr<content::WebContents, DanglingUntriaged> tab_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> tab_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_P(GetDisplayMediaHiDpiBrowserTest, Capture) {

chrome/browser/media/webrtc/webrtc_interactive_uitest.cc

@@ -158,8 +158,8 @@ class WebRtcBrowserTest : public WebRtcTestBase {
     HangUp(right_tab_);
   }
 
-  raw_ptr<content::WebContents, DanglingUntriaged> left_tab_;
-  raw_ptr<content::WebContents, DanglingUntriaged> right_tab_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> left_tab_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> right_tab_;
 };
 
 IN_PROC_BROWSER_TEST_F(WebRtcBrowserTest,

chrome/browser/net/dns_probe_browsertest.cc

@@ -182,13 +182,13 @@ class DnsProbeBrowserTest : public InProcessBrowserTest {
 
   std::unique_ptr<FakeHostResolverNetworkContext> network_context_;
   std::unique_ptr<FakeDnsConfigChangeManager> dns_config_change_manager_;
-  raw_ptr<DelayingDnsProbeService, DanglingUntriaged>
+  raw_ptr<DelayingDnsProbeService, DanglingAcrossTasks>
       delaying_dns_probe_service_;
 
   // Browser that methods apply to.
-  raw_ptr<Browser, DanglingUntriaged> active_browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> active_browser_;
   // Helper that current has its DnsProbeStatus messages monitored.
-  raw_ptr<NetErrorTabHelper, DanglingUntriaged> monitored_tab_helper_;
+  raw_ptr<NetErrorTabHelper, DanglingAcrossTasks> monitored_tab_helper_;
 
   std::unique_ptr<base::RunLoop> awaiting_dns_probe_status_run_loop_;
   // Queue of statuses received but not yet consumed by WaitForSentStatus().

chrome/browser/net/net_error_tab_helper_browsertest.cc

@@ -75,7 +75,7 @@ class NetErrorTabHelperTest : public InProcessBrowserTest {
   }
 
  private:
-  raw_ptr<chrome_browser_net::NetErrorTabHelper, DanglingUntriaged>
+  raw_ptr<chrome_browser_net::NetErrorTabHelper, DanglingAcrossTasks>
       tab_helper_ = nullptr;
 };
 

chrome/browser/net/network_context_configuration_browsertest.cc

@@ -720,7 +720,7 @@ class NetworkContextConfigurationBrowserTest
     FlushNetworkInterface();
   }
 
-  raw_ptr<Browser, DanglingUntriaged> incognito_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_ = nullptr;
 
   net::EmbeddedTestServer https_server_;
   std::unique_ptr<net::test_server::ControllableHttpResponse>

chrome/browser/notifications/notification_display_service_tester.h

@@ -94,7 +94,7 @@ class NotificationDisplayServiceTester {
   void OnProfileShutdown();
 
   raw_ptr<Profile> profile_;
-  raw_ptr<StubNotificationDisplayService, DanglingUntriaged> display_service_;
+  raw_ptr<StubNotificationDisplayService, DanglingAcrossTasks> display_service_;
   base::CallbackListSubscription profile_shutdown_subscription_;
 };
 

chrome/browser/password_manager/account_password_store_factory.cc

@@ -73,7 +73,7 @@ class UnsyncedCredentialsDeletionNotifierImpl
   base::WeakPtr<UnsyncedCredentialsDeletionNotifier> GetWeakPtr() override;
 
  private:
-  const raw_ptr<Profile, DanglingUntriaged> profile_;
+  const raw_ptr<Profile, DanglingAcrossTasks> profile_;
   base::WeakPtrFactory<UnsyncedCredentialsDeletionNotifier> weak_ptr_factory_{
       this};
 };

chrome/browser/password_manager/password_manager_browsertest.cc

@@ -4337,7 +4337,7 @@ class MockPrerenderPasswordManagerDriver
   }
   base::OnceClosure quit_closure_;
   uint32_t wait_type_ = WAIT_FOR_NOTHING;
-  raw_ptr<autofill::mojom::PasswordManagerDriver, DanglingUntriaged> impl_ =
+  raw_ptr<autofill::mojom::PasswordManagerDriver, DanglingAcrossTasks> impl_ =
       nullptr;
 };
 

chrome/browser/permissions/permission_manager_browsertest.cc

@@ -104,7 +104,7 @@ class PermissionManagerBrowserTest : public InProcessBrowserTest {
   Browser* incognito_browser() { return incognito_browser_; }
 
  private:
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_F(PermissionManagerBrowserTest,

chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc

@@ -181,7 +181,8 @@ class DocumentPictureInPictureWindowControllerBrowserTest
   };
 
  private:
-  raw_ptr<content::DocumentPictureInPictureWindowController, DanglingUntriaged>
+  raw_ptr<content::DocumentPictureInPictureWindowController,
+          DanglingAcrossTasks>
       pip_window_controller_ = nullptr;
   base::test::ScopedFeatureList scoped_feature_list_;
 };

chrome/browser/picture_in_picture/video_picture_in_picture_window_controller_browsertest.cc

@@ -305,7 +305,7 @@ class VideoPictureInPictureWindowControllerBrowserTest
   }
 
  private:
-  raw_ptr<content::VideoPictureInPictureWindowController, DanglingUntriaged>
+  raw_ptr<content::VideoPictureInPictureWindowController, DanglingAcrossTasks>
       pip_window_controller_ = nullptr;
   MockVideoPictureInPictureWindowController mock_controller_;
 };

chrome/browser/plugins/plugin_info_host_impl.h

@@ -76,7 +76,7 @@ class PluginInfoHostImpl : public chrome::mojom::PluginInfoHost {
     raw_ptr<extensions::ExtensionRegistry, DanglingUntriaged>
         extension_registry_;
 #endif
-    raw_ptr<const HostContentSettingsMap, DanglingUntriaged>
+    raw_ptr<const HostContentSettingsMap, DanglingAcrossTasks>
         host_content_settings_map_;
     scoped_refptr<PluginPrefs> plugin_prefs_;
   };

chrome/browser/policy/test/policy_test_google_browsertest.cc

@@ -116,7 +116,7 @@ class PolicyTestGoogle : public SafeSearchPolicyTest,
   net::EmbeddedTestServer https_server_;
   base::Lock lock_;
   std::map<std::string, net::HttpRequestHeaders> urls_requested_;
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 };
 
 INSTANTIATE_TEST_SUITE_P(, PolicyTestGoogle, ::testing::Bool());

chrome/browser/predictors/loading_predictor_browsertest.cc

@@ -2197,7 +2197,7 @@ class MultiPageBrowserTest : public InProcessBrowserTest {
   content::WebContents* GetWebContents() { return web_contents_; }
 
   net::test_server::EmbeddedTestServerHandle test_server_handle_;
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_;
 };
 
 IN_PROC_BROWSER_TEST_F(MultiPageBrowserTest, LoadingPredictor) {

chrome/browser/preloading/prefetch/no_state_prefetch/no_state_prefetch_test_utils.h

@@ -365,9 +365,9 @@ class PrerenderInProcessBrowserTest : virtual public InProcessBrowserTest {
       external_protocol_handler_delegate_;
   std::unique_ptr<safe_browsing::TestSafeBrowsingServiceFactory>
       safe_browsing_factory_;
-  raw_ptr<TestNoStatePrefetchContentsFactory, DanglingUntriaged>
+  raw_ptr<TestNoStatePrefetchContentsFactory, DanglingAcrossTasks>
       no_state_prefetch_contents_factory_;
-  raw_ptr<Browser, DanglingUntriaged> explicitly_set_browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> explicitly_set_browser_;
   bool autostart_test_server_;
   base::HistogramTester histogram_tester_;
   std::unique_ptr<net::EmbeddedTestServer> https_src_server_;

chrome/browser/preloading/prefetch/search_prefetch/search_preload_unified_browsertest.cc

@@ -398,8 +398,8 @@ class SearchPreloadUnifiedBrowserTest : public PlatformBrowserTest,
 
   constexpr static char kSearchDomain[] = "a.test";
   constexpr static char16_t kSearchDomain16[] = u"a.test";
-  raw_ptr<PrerenderManager, DanglingUntriaged> prerender_manager_ = nullptr;
-  raw_ptr<SearchPrefetchService, DanglingUntriaged> search_prefetch_service_ =
+  raw_ptr<PrerenderManager, DanglingAcrossTasks> prerender_manager_ = nullptr;
+  raw_ptr<SearchPrefetchService, DanglingAcrossTasks> search_prefetch_service_ =
       nullptr;
   net::test_server::EmbeddedTestServer search_engine_server_{
       net::test_server::EmbeddedTestServer::TYPE_HTTPS};

chrome/browser/preloading/prefetch/zero_suggest_prefetch/zero_suggest_prefetch_tab_helper_browsertest.cc

@@ -71,7 +71,7 @@ class ZeroSuggestPrefetchTabHelperBrowserTest : public InProcessBrowserTest {
   }
 
   base::test::ScopedFeatureList feature_list_;
-  raw_ptr<testing::NiceMock<MockAutocompleteController>, DanglingUntriaged>
+  raw_ptr<testing::NiceMock<MockAutocompleteController>, DanglingAcrossTasks>
       controller_;
 };
 

chrome/browser/preloading/prerender/omnibox_prerender_browsertest.cc

@@ -360,7 +360,7 @@ class PrerenderOmniboxSearchSuggestionBrowserTest
 
   constexpr static char kSearchDomain[] = "a.test";
   constexpr static char16_t kSearchDomain16[] = u"a.test";
-  raw_ptr<PrerenderManager, DanglingUntriaged> prerender_manager_;
+  raw_ptr<PrerenderManager, DanglingAcrossTasks> prerender_manager_;
   net::test_server::EmbeddedTestServer search_engine_server_{
       net::test_server::EmbeddedTestServer::TYPE_HTTPS};
   std::string prerender_page_target_ = "/title1.html";

chrome/browser/printing/print_preview_context_menu_observer.h

@@ -30,7 +30,7 @@ class PrintPreviewContextMenuObserver : public RenderViewContextMenuObserver {
  private:
   bool IsPrintPreviewDialog();
 
-  raw_ptr<content::WebContents, DanglingUntriaged> contents_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> contents_;
 };
 
 #endif  // CHROME_BROWSER_PRINTING_PRINT_PREVIEW_CONTEXT_MENU_OBSERVER_H_

chrome/browser/printing/print_preview_dialog_controller_browsertest.cc

@@ -138,9 +138,9 @@ class PrintPreviewDialogControllerBrowserTest : public InProcessBrowserTest {
 
   std::unique_ptr<printing::TestPrintPreviewDialogClonedObserver>
       cloned_tab_observer_;
-  raw_ptr<printing::TestPrintViewManagerForRequestPreview, DanglingUntriaged>
+  raw_ptr<printing::TestPrintViewManagerForRequestPreview, DanglingAcrossTasks>
       test_print_view_manager_;
-  raw_ptr<WebContents, DanglingUntriaged> initiator_ = nullptr;
+  raw_ptr<WebContents, DanglingAcrossTasks> initiator_ = nullptr;
 };
 
 // Test to verify that when a initiator navigates, we can create a new preview

chrome/browser/profiles/avatar_menu.h

@@ -191,7 +191,7 @@ class AvatarMenu :
   raw_ptr<AvatarMenuObserver, DanglingUntriaged> observer_;
 
   // Browser in which this avatar menu resides. Weak.
-  raw_ptr<Browser, DanglingUntriaged> browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> browser_;
 };
 
 #endif  // CHROME_BROWSER_PROFILES_AVATAR_MENU_H_

chrome/browser/profiles/profile_activity_metrics_recorder.h

@@ -52,11 +52,11 @@ class ProfileActivityMetricsRecorder
   void OnUserAction(const std::string& action, base::TimeTicks action_time);
 
   // The profile of the last active window.
-  raw_ptr<Profile, DanglingUntriaged> last_active_profile_ = nullptr;
+  raw_ptr<Profile, DanglingAcrossTasks> last_active_profile_ = nullptr;
 
   // Profile of the currently running session, if there is any. Reset after
   // inactivity.
-  raw_ptr<Profile, DanglingUntriaged> running_session_profile_ = nullptr;
+  raw_ptr<Profile, DanglingAcrossTasks> running_session_profile_ = nullptr;
   base::TimeTicks running_session_start_;
   base::TimeTicks last_session_end_;
 

chrome/browser/profiles/profile_browsertest.cc

@@ -233,7 +233,7 @@ class BrowserCloseObserver : public BrowserListObserver {
   }
 
  private:
-  raw_ptr<Browser, DanglingUntriaged> browser_;
+  raw_ptr<Browser, DanglingAcrossTasks> browser_;
   base::RunLoop run_loop_;
 };
 

chrome/browser/profiles/profile_window_browsertest.cc

@@ -165,7 +165,7 @@ class ProfileWindowCountBrowserTest : public ProfileWindowBrowserTest,
   }
 
  private:
-  raw_ptr<Profile, DanglingUntriaged> profile_ = nullptr;
+  raw_ptr<Profile, DanglingAcrossTasks> profile_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_P(ProfileWindowCountBrowserTest, CountProfileWindows) {

chrome/browser/push_messaging/push_messaging_browsertest.cc

@@ -2812,7 +2812,7 @@ class PushMessagingIncognitoBrowserTest : public PushMessagingBrowserTestBase {
 
  protected:
   content::test::PrerenderTestHelper prerender_helper_;
-  raw_ptr<Browser, DanglingUntriaged> incognito_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> incognito_browser_ = nullptr;
 };
 
 // Regression test for https://crbug.com/476474

chrome/browser/renderer_context_menu/render_view_context_menu_browsertest.cc

@@ -525,10 +525,10 @@ class PdfPluginContextMenuBrowserTest : public InProcessBrowserTest {
   content::RenderFrameHost* extension_frame() { return extension_frame_; }
 
  private:
-  raw_ptr<content::RenderFrameHost, DanglingUntriaged> extension_frame_ =
+  raw_ptr<content::RenderFrameHost, DanglingAcrossTasks> extension_frame_ =
       nullptr;
   guest_view::TestGuestViewManagerFactory factory_;
-  raw_ptr<guest_view::TestGuestViewManager, DanglingUntriaged>
+  raw_ptr<guest_view::TestGuestViewManager, DanglingAcrossTasks>
       test_guest_view_manager_;
 };
 

chrome/browser/renderer_host/render_process_host_chrome_browsertest.cc

@@ -714,7 +714,7 @@ class ChromeRenderProcessHostBackgroundingTestWithAudio
   base::Process audio_process_;
   base::Process no_audio_process_;
 
-  raw_ptr<content::WebContents, DanglingUntriaged> audio_tab_web_contents_;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> audio_tab_web_contents_;
 
  private:
   bool IsProcessBackgrounded(const base::Process& process) {

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.h

@@ -138,7 +138,7 @@ class TabLifecycleUnitSource : public BrowserListObserver,
   BrowserTabStripTracker browser_tab_strip_tracker_;
 
   // Pretend that this is the TabStripModel of the focused window, for testing.
-  raw_ptr<TabStripModel, DanglingUntriaged>
+  raw_ptr<TabStripModel, DanglingAcrossTasks>
       focused_tab_strip_model_for_testing_ = nullptr;
 
   // The currently focused TabLifecycleUnit. Updated by UpdateFocusedTab().

chrome/browser/safe_browsing/cloud_content_scanning/file_opening_job.h

@@ -25,7 +25,7 @@ class FileOpeningJob {
     ~FileOpeningTask();
 
     // Non-owning pointer to the request corresponding to the file to open.
-    raw_ptr<safe_browsing::FileAnalysisRequest, DanglingUntriaged> request =
+    raw_ptr<safe_browsing::FileAnalysisRequest, DanglingAcrossTasks> request =
         nullptr;
 
     // Indicates if this task has been taken and is owned by a thread.

chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc

@@ -355,7 +355,7 @@ class TestThreatDetailsFactory : public ThreatDetailsFactory {
   ThreatDetails* get_details() { return details_; }
 
  private:
-  raw_ptr<ThreatDetails, DanglingUntriaged> details_;
+  raw_ptr<ThreatDetails, DanglingAcrossTasks> details_;
 };
 
 // A SafeBrowingBlockingPage class that lets us wait until it's hidden.

chrome/browser/sessions/session_service_log_browsertest.cc

@@ -88,7 +88,7 @@ class SessionServiceLogTest : public InProcessBrowserTest {
 
  protected:
   // Cached as browser() may be destroyed.
-  raw_ptr<Profile, DanglingUntriaged> profile_ = nullptr;
+  raw_ptr<Profile, DanglingAcrossTasks> profile_ = nullptr;
   std::unique_ptr<ScopedKeepAlive> keep_alive_;
 };
 

chrome/browser/signin/dice_web_signin_interceptor_browsertest.cc

@@ -134,7 +134,7 @@ class FakeDiceWebSigninInterceptorDelegate
   }
 
  private:
-  raw_ptr<Browser, DanglingUntriaged> fre_browser_ = nullptr;
+  raw_ptr<Browser, DanglingAcrossTasks> fre_browser_ = nullptr;
   CoreAccountId fre_account_id_;
   WebSigninInterceptor::SigninInterceptionType expected_interception_type_ =
       WebSigninInterceptor::SigninInterceptionType::kMultiUser;

chrome/browser/site_isolation/site_per_process_text_input_browsertest.cc

@@ -114,7 +114,7 @@ class ViewTextInputTypeObserver : public content::TextInputManagerObserverBase {
   }
 
   raw_ptr<content::WebContents, DanglingUntriaged> web_contents_;
-  raw_ptr<content::RenderWidgetHostView, DanglingUntriaged> view_;
+  raw_ptr<content::RenderWidgetHostView, DanglingAcrossTasks> view_;
   const ui::TextInputType expected_type_;
 };
 

chrome/browser/ssl/security_state_tab_helper_browsertest.cc

@@ -1580,7 +1580,7 @@ class SecurityStateTabHelperPrerenderTest : public SecurityStateTabHelperTest {
   content::WebContents* web_contents() { return web_contents_; }
 
  protected:
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   content::test::PrerenderTestHelper prerender_helper_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };

chrome/browser/subresource_filter/subresource_filter_browser_test_harness.h

@@ -211,7 +211,8 @@ class SubresourceFilterBrowserTest : public PlatformBrowserTest {
   std::unique_ptr<TestSafeBrowsingDatabaseHelper> database_helper_;
 
   // Owned by the profile.
-  raw_ptr<SubresourceFilterProfileContext, DanglingUntriaged> profile_context_;
+  raw_ptr<SubresourceFilterProfileContext, DanglingAcrossTasks>
+      profile_context_;
 };
 
 // This class automatically syncs the SubresourceFilter SafeBrowsing list

chrome/browser/sync/sessions/sync_sessions_router_tab_helper_browsertest.cc

@@ -129,7 +129,7 @@ class SyncSessionsRouterTabHelperBrowserTest : public InProcessBrowserTest {
 
  protected:
  private:
-  raw_ptr<content::WebContents, DanglingUntriaged> web_contents_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> web_contents_ = nullptr;
   content::test::PrerenderTestHelper prerender_helper_;
   TestLocalSessionEventHandler handler;
   TestTranslateDriverObserver observer_;

chrome/browser/sync/test/integration/sync_service_impl_harness.h

@@ -197,10 +197,10 @@ class SyncServiceImplHarness {
   bool IsSyncEnabledByUser() const;
 
   // Profile associated with this sync client.
-  const raw_ptr<Profile, DanglingUntriaged> profile_;
+  const raw_ptr<Profile, DanglingAcrossTasks> profile_;
 
   // SyncServiceImpl object associated with |profile_|.
-  const raw_ptr<syncer::SyncServiceImpl, DanglingUntriaged> service_;
+  const raw_ptr<syncer::SyncServiceImpl, DanglingAcrossTasks> service_;
 
   // Prevents Sync from running until configuration is complete.
   std::unique_ptr<syncer::SyncSetupInProgressHandle> sync_blocker_;

chrome/browser/sync/test/integration/sync_test.h

@@ -398,7 +398,7 @@ class SyncTest : public PlatformBrowserTest, public ProfileObserver {
   // The default profile, created before our actual testing |profiles_|. This is
   // needed in a workaround for https://crbug.com/801569, see comments in the
   // .cc file.
-  raw_ptr<Profile, DanglingUntriaged> previous_profile_;
+  raw_ptr<Profile, DanglingAcrossTasks> previous_profile_;
 
   // Number of sync clients that will be created by a test.
   int num_clients_;
@@ -408,7 +408,7 @@ class SyncTest : public PlatformBrowserTest, public ProfileObserver {
   // directory. Profiles are owned by the ProfileManager.
   // TODO(crbug.com/1349349): store |profiles_|, |browsers_| and |clients_| in
   // one structure.
-  std::vector<raw_ptr<Profile, DanglingUntriaged>> profiles_;
+  std::vector<raw_ptr<Profile, DanglingAcrossTasks>> profiles_;
 
   // List of temporary directories that need to be deleted when the test is
   // completed, used for two-client tests with external server.
@@ -419,7 +419,7 @@ class SyncTest : public PlatformBrowserTest, public ProfileObserver {
   // instance is created for each sync profile. Browser object lifetime is
   // managed by BrowserList, so we don't use a std::vector<std::unique_ptr<>>
   // here.
-  std::vector<raw_ptr<Browser, DanglingUntriaged>> browsers_;
+  std::vector<raw_ptr<Browser, DanglingAcrossTasks>> browsers_;
 
   class ClosedBrowserObserver;
   std::unique_ptr<ClosedBrowserObserver> browser_list_observer_;
@@ -442,8 +442,8 @@ class SyncTest : public PlatformBrowserTest, public ProfileObserver {
 
   // Used to deliver invalidations to different profiles within
   // FakeSyncServerInvalidationSender.
-  std::map<raw_ptr<Profile, DanglingUntriaged>,
-           raw_ptr<FakeSyncGCMDriver, DanglingUntriaged>>
+  std::map<raw_ptr<Profile, DanglingAcrossTasks>,
+           raw_ptr<FakeSyncGCMDriver, DanglingAcrossTasks>>
       profile_to_fake_gcm_driver_;
 
   base::CallbackListSubscription create_services_subscription_;
@@ -452,7 +452,7 @@ class SyncTest : public PlatformBrowserTest, public ProfileObserver {
   // We don't need a corresponding verifier sync client because the contents
   // of the verifier profile are strictly local, and are not meant to be
   // synced.
-  raw_ptr<Profile, DanglingUntriaged> verifier_;
+  raw_ptr<Profile, DanglingAcrossTasks> verifier_;
 
   // Indicates whether to use a new user data dir.
   // Only used for external server tests with two clients.

chrome/browser/sync/test/integration/two_client_power_bookmarks_sync_test.cc

@@ -64,8 +64,8 @@ class TwoClientPowerBookmarksSyncTest : public SyncTest {
   }
 
  protected:
-  raw_ptr<power_bookmarks::PowerBookmarkService, DanglingUntriaged> service0_;
-  raw_ptr<power_bookmarks::PowerBookmarkService, DanglingUntriaged> service1_;
+  raw_ptr<power_bookmarks::PowerBookmarkService, DanglingAcrossTasks> service0_;
+  raw_ptr<power_bookmarks::PowerBookmarkService, DanglingAcrossTasks> service1_;
 
  private:
   power_bookmarks::PowerBookmarkService* GetSyncService(int index) {

chrome/browser/tab_contents/view_source_browsertest.cc

@@ -791,7 +791,7 @@ class ViewSourcePrerenderTest : public ViewSourceTest {
                           base::Unretained(this))};
 
   // The WebContents which is expected to request prerendering.
-  raw_ptr<content::WebContents, DanglingUntriaged> target_ = nullptr;
+  raw_ptr<content::WebContents, DanglingAcrossTasks> target_ = nullptr;
 };
 
 // A frame in a prerendered page should be able to have its source viewed, like

chrome/browser/task_manager/providers/web_contents/devtools_tag_browsertest.cc

@@ -58,7 +58,7 @@ class DevToolsTagTest : public InProcessBrowserTest {
   }
 
  private:
-  raw_ptr<DevToolsWindow, DanglingUntriaged> devtools_window_;
+  raw_ptr<DevToolsWindow, DanglingAcrossTasks> devtools_window_;
 };
 
 // Tests that opening a DevToolsWindow will result in tagging its main