ios/chrome/browser/metrics/model/dwa_egtest.mm - chromium/src - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #import "base/ios/ios_util.h"
 #import "components/metrics/dwa/dwa_recorder.h"
 #import "ios/chrome/browser/authentication/ui_bundled/signin_earl_grey.h"
 #import "ios/chrome/browser/authentication/ui_bundled/signin_earl_grey_ui_test_util.h"
 #import "ios/chrome/browser/metrics/model/metrics_app_interface.h"
 #import "ios/chrome/browser/signin/model/fake_system_identity.h"
 #import "ios/chrome/test/earl_grey/chrome_actions.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey_ui.h"
 #import "ios/chrome/test/earl_grey/chrome_matchers.h"
 #import "ios/chrome/test/earl_grey/chrome_test_case.h"
 #import "ios/testing/earl_grey/app_launch_configuration.h"
 #import "ios/testing/earl_grey/earl_grey_test.h"
 #import "net/test/embedded_test_server/default_handlers.h"

 using chrome_test_util::GoogleServicesSettingsButton;
 using chrome_test_util::SettingsDoneButton;

 @interface DWATestCase : ChromeTestCase

 @end

 @implementation DWATestCase

 + (void)setUpForTestCase {
   [super setUpForTestCase];
 }

 - (void)setUp {
   [super setUp];

   // These tests enable history synchronization via Recent Tabs.
   // If the list contains too many tabs, the button at the bottom of
   // the view moves offscreen, and its animation causes the tests to freeze,
   // similar to crbug.com/640977.
   if (![ChromeTestCase forceRestartAndWipe]) {
     [ChromeEarlGrey clearBrowsingHistory];
   }

   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"setUp: Failed to assert that DWA was not enabled.");

   // Sign in to Chrome and enable history sync.

   // Note: URL-keyed anonymized data collection is turned on as part of the
   // flow to Sign in to Chrome and enable history sync. This matches the main
   // user flow that enables DWA.
   [SigninEarlGreyUI signinWithFakeIdentity:[FakeSystemIdentity fakeIdentity1]
                          enableHistorySync:YES];
   [ChromeEarlGrey waitForSyncTransportStateActiveWithTimeout:
                       syncher::kSyncDWAOperationsTimeout];

   // Grant metrics consent and update MetricsServicesManager.
   [MetricsAppInterface overrideMetricsAndCrashReportingForTesting];

   GREYAssert(![MetricsAppInterface setMetricsAndCrashReportingForTesting:YES],
              @"setUp: Unpaired set/reset of user consent.");

   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"setUp: Failed to assert that DWA was enabled.");
   GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:YES],
              @"setUp: Failed to assert that DWA was allowed for all profiles.");

   net::test_server::RegisterDefaultHandlers(self.testServer);
   GREYAssertTrue(self.testServer->Start(), @"Server did not start.");
 }

 - (void)tearDownHelper {
   [ChromeEarlGrey waitForSyncTransportStateActiveWithTimeout:
                       syncher::kSyncDWAOperationsTimeout];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"tearDownHelper: Failed to assert that DWA was enabled.");
   [MetricsAppInterface clearDWARecorder];
   [self assertDwaRecorderIsEmpty];

   // Revoke metrics consent and update MetricsServicesManager.
   GREYAssert([MetricsAppInterface setMetricsAndCrashReportingForTesting:NO],
              @"tearDownHelper: Unpaired set/reset of user consent.");
   [MetricsAppInterface stopOverridingMetricsAndCrashReportingForTesting];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"tearDownHelper: Failed to assert that DWA was not enabled.");

   // Sign out of Chrome.

   // Note: URL-keyed anonymized data collection is turned off as part of the
   // flow to Sign out of Chrome. This matches the main user flow that disables
   // DWA.
   [SigninEarlGrey signOut];

   [ChromeEarlGrey clearFakeSyncServerData];

   [super tearDownHelper];
 }

 // Enable the DWA feature
 - (AppLaunchConfiguration)appConfigurationForTestCase {
   AppLaunchConfiguration config = [super appConfigurationForTestCase];

   config.features_enabled.push_back(metrics::dwa::kDwaFeature);

   return config;
 }

 #pragma mark - Helpers

 // Waits for a new incognito tab to be opened.
 - (void)openNewIncognitoTab {
   const NSUInteger incognitoTabCount = [ChromeEarlGrey incognitoTabCount];
   [ChromeEarlGrey openNewIncognitoTab];
   [ChromeEarlGrey waitForIncognitoTabCount:(incognitoTabCount + 1)];
   GREYAssert([ChromeEarlGrey isIncognitoMode],
              @"openNewIncognitoTab: Failed to switch to incognito mode.");
 }

 // Waits for the current incognito tab to be closed.
 - (void)closeCurrentIncognitoTab {
   const NSUInteger incognitoTabCount = [ChromeEarlGrey incognitoTabCount];
   [ChromeEarlGrey closeCurrentTab];
   [ChromeEarlGrey waitForIncognitoTabCount:(incognitoTabCount - 1)];
 }

 // Waits for all incognito tabs to be closed.
 - (void)closeAllIncognitoTabs {
   [ChromeEarlGrey closeAllIncognitoTabs];
   [ChromeEarlGrey waitForIncognitoTabCount:0];

   // The user is dropped into the tab grid after closing the last incognito tab.
   // Therefore this test must manually switch back to showing the normal tabs.
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::TabGridOpenTabsPanelButton()]
       performAction:grey_tap()];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::TabGridDoneButton()]
       performAction:grey_tap()];
   GREYAssert(![ChromeEarlGrey isIncognitoMode],
              @"closeAllIncognitoTabs: Failed to switch to normal mode.");
 }

 // Waits for a new tab to be opened.
 - (void)openNewRegularTab {
   const NSUInteger tabCount = [ChromeEarlGrey mainTabCount];
   [ChromeEarlGrey openNewTab];
   [ChromeEarlGrey waitForMainTabCount:(tabCount + 1)];
 }

 // Toggle "Make searches and browsing better" switch on.
 - (void)turnOnMsbbSwitch {
   // Wait for the Msbb switch to appear.
   [ChromeEarlGrey waitForUIElementToAppearWithMatcher:
                       chrome_test_util::TableViewSwitchCell(
                           @"betterSearchAndBrowsingItem_switch", NO)];
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::TableViewSwitchCell(
                                    @"betterSearchAndBrowsingItem_switch", NO)]
       performAction:chrome_test_util::TurnTableViewSwitchOn(YES)];
 }

 // Toggle "Make searches and browsing better" switch off.
 - (void)turnOffMsbbSwitch {
   [ChromeEarlGrey waitForUIElementToAppearWithMatcher:
                       chrome_test_util::TableViewSwitchCell(
                           @"betterSearchAndBrowsingItem_switch", YES)];
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::TableViewSwitchCell(
                                    @"betterSearchAndBrowsingItem_switch", YES)]
       performAction:chrome_test_util::TurnTableViewSwitchOn(NO)];
 }

 // Assertions to check that the DWA recorder is enabled and allowed for all
 // profiles.
 - (void)assertDwaIsEnabledAndAllowed {
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"Failed to assert that DWA was enabled.");
   GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:YES],
              @"Failed to assert that DWA was "
              @"allowed for all profiles.");
 }

 // Assertions to check that the DWA recorder has entries.
 - (void)assertDwaRecorderHasMetrics {
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
              @"DWA Recorder should have "
              @"entries.");
 }

 // Assertions to check that the DWA recorder is not enabled and not allowed for
 // all profiles.
 - (void)assertDwaIsDisabledAndDisallowed {
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");
   GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:NO],
              @"Failed to assert that DWA was not "
              @"allowed for all profiles.");
 }

 // Assertions to check that the DWA recorder has no entries.
 - (void)assertDwaRecorderIsEmpty {
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not have any "
              @"entries.");
 }

 #pragma mark - Tests

 // The tests in this file should correspond to the tests in
 // //chrome/browser/metrics/dwa_browsertest.cc

 // LINT.IfChange(DwaServiceCheck)
 - (void)testDwaServiceCheck {
   // [Note: Tests begin with an open regular tab. This tab is opened in setUp.
   // DWA should be enabled with first regular browser.
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"Failed to assert that DWA was enabled.");

   // Records a DWA entry metric.
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface hasUnsentDWALogs:NO],
              @"DWA Service should not have unsent logs.");

   [MetricsAppInterface DWAServiceFlushCall];
   [self assertDwaRecorderIsEmpty];
   GREYAssert([MetricsAppInterface hasUnsentDWALogs:YES],
              @"DWA Service should have unsent logs.");
 }
 // LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:DwaServiceCheck)

 // Make sure that DWA is disabled and purged while an incognito window is open.
 // LINT.IfChange(RegularBrowserPlusIncognitoCheck)
 - (void)testRegularBrowserPlusIncognitoCheck {
   // Note: Tests begin with an open regular tab. This tab is opened in setUp.
   // DWA should be enabled with first regular browser.
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"Failed to assert that DWA "
              @"was enabled.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
              @"Failed to record test "
              @"entry metric.");

   // Opening an incognito browser should disable DwaRecorder and metrics
   // should be purged.
   [self openNewIncognitoTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA "
              @"was not enabled.");
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");

   // Opening another regular tab mustn't enabled DWA.
   [self openNewRegularTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");

   // Opening and closing another incognito browser must not enable DWA.
   [self openNewIncognitoTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");

   [self closeCurrentIncognitoTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");

   // TODO(crbug.com/41271925): Due to continuous animations, it is not feasible
   // (i) to use the tab switcher to switch between modes or (ii) to omit the
   // below code block and simply call [ChromeEarlGrey closeAllIncognitoTabs];
   // from incognito mode.
   [self openNewRegularTab];
   [ChromeEarlGrey closeCurrentTab];
   [ChromeEarlGrey closeCurrentTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA "
              @"was not enabled.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");

   // At this point, there is one open regular tab and one open incognito tab.
   [ChromeEarlGrey closeAllIncognitoTabs];
   // All incognito tabs have been closed, so DWA should be enabled.
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"Failed to assert that DWA "
              @"was enabled.");
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
              @"DWA Recorder should not "
              @"have any entries.");
   [MetricsAppInterface recordTestDWAEntryMetric];
   GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
              @"Failed to record test "
              @"entry metric.");
 }
 // LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:RegularBrowserPlusIncognitoCheck)

 // Make sure opening a regular browser after Incognito doesn't enable DWA.
 // LINT.IfChange(IncognitoBrowserPlusRegularCheck)
 - (void)testIncognitoBrowserPlusRegularCheck {
   // Note: Tests begin with an open regular tab. This tab is opened in setUp.

   // TODO(crbug.com/41271925): Due to continuous animations, it is not feasible
   // to close the regular tab that is already open. The functions closeAllTabs,
   // closeCurrentTab, and closeAllTabsInCurrentMode close the tab and then hang.
   // As a workaround, we open an incognito tab and then close the regular tab to
   // get to a state in which a single incognito tab is open.

   // Opening an incognito browser should disable DwaRecorder and metrics should
   // be purged.
   [self openNewIncognitoTab];
   [ChromeEarlGrey closeAllNormalTabs];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");

   // Opening another regular browser must not enable DWA.
   [self openNewRegularTab];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
              @"Failed to assert that DWA was not enabled.");

   // All incognito tabs have been closed, so DWA should be enabled.
   [ChromeEarlGrey closeAllIncognitoTabs];
   GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
              @"Failed to assert that DWA was enabled.");
 }
 // LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:IncognitoBrowserPlusRegularCheck)

 // Tests that disabling MSBB UKM consent disables and purges DWA.
 // Additionally tests that DWA is disabled until all UKM consents are enabled.
 // LINT.IfChange(UkmMsbbConsentChangeCheck)
 - (void)testUkmMsbbConsentChangeCheck {
   // Note: Tests begin with an open regular tab. This tab is opened in setUp.
   [MetricsAppInterface recordTestDWAEntryMetric];
   [self assertDwaIsEnabledAndAllowed];
   [self assertDwaRecorderHasMetrics];

   [ChromeEarlGreyUI openSettingsMenu];
   [ChromeEarlGrey waitForSufficientlyVisibleElementWithMatcher:
                       GoogleServicesSettingsButton()];

   // Open Google services settings.
   [ChromeEarlGreyUI tapSettingsMenuButton:GoogleServicesSettingsButton()];
   [ChromeEarlGreyUI waitForAppToIdle];

   // Toggle "Make searches and browsing better" switch off.
   [self turnOffMsbbSwitch];
   [self assertDwaIsDisabledAndDisallowed];
   [self assertDwaRecorderIsEmpty];

   // Toggle "Make searches and browsing better" switch on.
   [self turnOnMsbbSwitch];
   [self assertDwaIsEnabledAndAllowed];
   [self assertDwaRecorderIsEmpty];

   // Validate DWA entries is able to be recorded when all consents are enabled.
   [MetricsAppInterface recordTestDWAEntryMetric];
   [self assertDwaRecorderHasMetrics];

   [[EarlGrey selectElementWithMatcher:SettingsDoneButton()]
       performAction:grey_tap()];
 }
 // LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:UkmMsbbConsentChangeCheck)

 @end
	// Copyright 2025 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#import "base/ios/ios_util.h"
	#import "components/metrics/dwa/dwa_recorder.h"
	#import "ios/chrome/browser/authentication/ui_bundled/signin_earl_grey.h"
	#import "ios/chrome/browser/authentication/ui_bundled/signin_earl_grey_ui_test_util.h"
	#import "ios/chrome/browser/metrics/model/metrics_app_interface.h"
	#import "ios/chrome/browser/signin/model/fake_system_identity.h"
	#import "ios/chrome/test/earl_grey/chrome_actions.h"
	#import "ios/chrome/test/earl_grey/chrome_earl_grey.h"
	#import "ios/chrome/test/earl_grey/chrome_earl_grey_ui.h"
	#import "ios/chrome/test/earl_grey/chrome_matchers.h"
	#import "ios/chrome/test/earl_grey/chrome_test_case.h"
	#import "ios/testing/earl_grey/app_launch_configuration.h"
	#import "ios/testing/earl_grey/earl_grey_test.h"
	#import "net/test/embedded_test_server/default_handlers.h"

	using chrome_test_util::GoogleServicesSettingsButton;
	using chrome_test_util::SettingsDoneButton;

	@interface DWATestCase : ChromeTestCase

	@end

	@implementation DWATestCase

	+ (void)setUpForTestCase {
	[super setUpForTestCase];
	}

	- (void)setUp {
	[super setUp];

	// These tests enable history synchronization via Recent Tabs.
	// If the list contains too many tabs, the button at the bottom of
	// the view moves offscreen, and its animation causes the tests to freeze,
	// similar to crbug.com/640977.
	if (![ChromeTestCase forceRestartAndWipe]) {
	[ChromeEarlGrey clearBrowsingHistory];
	}

	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"setUp: Failed to assert that DWA was not enabled.");

	// Sign in to Chrome and enable history sync.

	// Note: URL-keyed anonymized data collection is turned on as part of the
	// flow to Sign in to Chrome and enable history sync. This matches the main
	// user flow that enables DWA.
	[SigninEarlGreyUI signinWithFakeIdentity:[FakeSystemIdentity fakeIdentity1]
	enableHistorySync:YES];
	[ChromeEarlGrey waitForSyncTransportStateActiveWithTimeout:
	syncher::kSyncDWAOperationsTimeout];

	// Grant metrics consent and update MetricsServicesManager.
	[MetricsAppInterface overrideMetricsAndCrashReportingForTesting];

	GREYAssert(![MetricsAppInterface setMetricsAndCrashReportingForTesting:YES],
	@"setUp: Unpaired set/reset of user consent.");

	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"setUp: Failed to assert that DWA was enabled.");
	GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:YES],
	@"setUp: Failed to assert that DWA was allowed for all profiles.");

	net::test_server::RegisterDefaultHandlers(self.testServer);
	GREYAssertTrue(self.testServer->Start(), @"Server did not start.");
	}

	- (void)tearDownHelper {
	[ChromeEarlGrey waitForSyncTransportStateActiveWithTimeout:
	syncher::kSyncDWAOperationsTimeout];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"tearDownHelper: Failed to assert that DWA was enabled.");
	[MetricsAppInterface clearDWARecorder];
	[self assertDwaRecorderIsEmpty];

	// Revoke metrics consent and update MetricsServicesManager.
	GREYAssert([MetricsAppInterface setMetricsAndCrashReportingForTesting:NO],
	@"tearDownHelper: Unpaired set/reset of user consent.");
	[MetricsAppInterface stopOverridingMetricsAndCrashReportingForTesting];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"tearDownHelper: Failed to assert that DWA was not enabled.");

	// Sign out of Chrome.

	// Note: URL-keyed anonymized data collection is turned off as part of the
	// flow to Sign out of Chrome. This matches the main user flow that disables
	// DWA.
	[SigninEarlGrey signOut];

	[ChromeEarlGrey clearFakeSyncServerData];

	[super tearDownHelper];
	}

	// Enable the DWA feature
	- (AppLaunchConfiguration)appConfigurationForTestCase {
	AppLaunchConfiguration config = [super appConfigurationForTestCase];

	config.features_enabled.push_back(metrics::dwa::kDwaFeature);

	return config;
	}

	#pragma mark - Helpers

	// Waits for a new incognito tab to be opened.
	- (void)openNewIncognitoTab {
	const NSUInteger incognitoTabCount = [ChromeEarlGrey incognitoTabCount];
	[ChromeEarlGrey openNewIncognitoTab];
	[ChromeEarlGrey waitForIncognitoTabCount:(incognitoTabCount + 1)];
	GREYAssert([ChromeEarlGrey isIncognitoMode],
	@"openNewIncognitoTab: Failed to switch to incognito mode.");
	}

	// Waits for the current incognito tab to be closed.
	- (void)closeCurrentIncognitoTab {
	const NSUInteger incognitoTabCount = [ChromeEarlGrey incognitoTabCount];
	[ChromeEarlGrey closeCurrentTab];
	[ChromeEarlGrey waitForIncognitoTabCount:(incognitoTabCount - 1)];
	}

	// Waits for all incognito tabs to be closed.
	- (void)closeAllIncognitoTabs {
	[ChromeEarlGrey closeAllIncognitoTabs];
	[ChromeEarlGrey waitForIncognitoTabCount:0];

	// The user is dropped into the tab grid after closing the last incognito tab.
	// Therefore this test must manually switch back to showing the normal tabs.
	[[EarlGrey
	selectElementWithMatcher:chrome_test_util::TabGridOpenTabsPanelButton()]
	performAction:grey_tap()];
	[[EarlGrey selectElementWithMatcher:chrome_test_util::TabGridDoneButton()]
	performAction:grey_tap()];
	GREYAssert(![ChromeEarlGrey isIncognitoMode],
	@"closeAllIncognitoTabs: Failed to switch to normal mode.");
	}

	// Waits for a new tab to be opened.
	- (void)openNewRegularTab {
	const NSUInteger tabCount = [ChromeEarlGrey mainTabCount];
	[ChromeEarlGrey openNewTab];
	[ChromeEarlGrey waitForMainTabCount:(tabCount + 1)];
	}

	// Toggle "Make searches and browsing better" switch on.
	- (void)turnOnMsbbSwitch {
	// Wait for the Msbb switch to appear.
	[ChromeEarlGrey waitForUIElementToAppearWithMatcher:
	chrome_test_util::TableViewSwitchCell(
	@"betterSearchAndBrowsingItem_switch", NO)];
	[[EarlGrey
	selectElementWithMatcher:chrome_test_util::TableViewSwitchCell(
	@"betterSearchAndBrowsingItem_switch", NO)]
	performAction:chrome_test_util::TurnTableViewSwitchOn(YES)];
	}

	// Toggle "Make searches and browsing better" switch off.
	- (void)turnOffMsbbSwitch {
	[ChromeEarlGrey waitForUIElementToAppearWithMatcher:
	chrome_test_util::TableViewSwitchCell(
	@"betterSearchAndBrowsingItem_switch", YES)];
	[[EarlGrey
	selectElementWithMatcher:chrome_test_util::TableViewSwitchCell(
	@"betterSearchAndBrowsingItem_switch", YES)]
	performAction:chrome_test_util::TurnTableViewSwitchOn(NO)];
	}

	// Assertions to check that the DWA recorder is enabled and allowed for all
	// profiles.
	- (void)assertDwaIsEnabledAndAllowed {
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"Failed to assert that DWA was enabled.");
	GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:YES],
	@"Failed to assert that DWA was "
	@"allowed for all profiles.");
	}

	// Assertions to check that the DWA recorder has entries.
	- (void)assertDwaRecorderHasMetrics {
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
	@"DWA Recorder should have "
	@"entries.");
	}

	// Assertions to check that the DWA recorder is not enabled and not allowed for
	// all profiles.
	- (void)assertDwaIsDisabledAndDisallowed {
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");
	GREYAssert([MetricsAppInterface DWARecorderAllowedForAllProfiles:NO],
	@"Failed to assert that DWA was not "
	@"allowed for all profiles.");
	}

	// Assertions to check that the DWA recorder has no entries.
	- (void)assertDwaRecorderIsEmpty {
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not have any "
	@"entries.");
	}

	#pragma mark - Tests

	// The tests in this file should correspond to the tests in
	// //chrome/browser/metrics/dwa_browsertest.cc

	// LINT.IfChange(DwaServiceCheck)
	- (void)testDwaServiceCheck {
	// [Note: Tests begin with an open regular tab. This tab is opened in setUp.
	// DWA should be enabled with first regular browser.
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"Failed to assert that DWA was enabled.");

	// Records a DWA entry metric.
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface hasUnsentDWALogs:NO],
	@"DWA Service should not have unsent logs.");

	[MetricsAppInterface DWAServiceFlushCall];
	[self assertDwaRecorderIsEmpty];
	GREYAssert([MetricsAppInterface hasUnsentDWALogs:YES],
	@"DWA Service should have unsent logs.");
	}
	// LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:DwaServiceCheck)

	// Make sure that DWA is disabled and purged while an incognito window is open.
	// LINT.IfChange(RegularBrowserPlusIncognitoCheck)
	- (void)testRegularBrowserPlusIncognitoCheck {
	// Note: Tests begin with an open regular tab. This tab is opened in setUp.
	// DWA should be enabled with first regular browser.
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"Failed to assert that DWA "
	@"was enabled.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
	@"Failed to record test "
	@"entry metric.");

	// Opening an incognito browser should disable DwaRecorder and metrics
	// should be purged.
	[self openNewIncognitoTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA "
	@"was not enabled.");
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");

	// Opening another regular tab mustn't enabled DWA.
	[self openNewRegularTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");

	// Opening and closing another incognito browser must not enable DWA.
	[self openNewIncognitoTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");

	[self closeCurrentIncognitoTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");

	// TODO(crbug.com/41271925): Due to continuous animations, it is not feasible
	// (i) to use the tab switcher to switch between modes or (ii) to omit the
	// below code block and simply call [ChromeEarlGrey closeAllIncognitoTabs];
	// from incognito mode.
	[self openNewRegularTab];
	[ChromeEarlGrey closeCurrentTab];
	[ChromeEarlGrey closeCurrentTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA "
	@"was not enabled.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");

	// At this point, there is one open regular tab and one open incognito tab.
	[ChromeEarlGrey closeAllIncognitoTabs];
	// All incognito tabs have been closed, so DWA should be enabled.
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"Failed to assert that DWA "
	@"was enabled.");
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:NO],
	@"DWA Recorder should not "
	@"have any entries.");
	[MetricsAppInterface recordTestDWAEntryMetric];
	GREYAssert([MetricsAppInterface DWARecorderHasEntries:YES],
	@"Failed to record test "
	@"entry metric.");
	}
	// LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:RegularBrowserPlusIncognitoCheck)

	// Make sure opening a regular browser after Incognito doesn't enable DWA.
	// LINT.IfChange(IncognitoBrowserPlusRegularCheck)
	- (void)testIncognitoBrowserPlusRegularCheck {
	// Note: Tests begin with an open regular tab. This tab is opened in setUp.

	// TODO(crbug.com/41271925): Due to continuous animations, it is not feasible
	// to close the regular tab that is already open. The functions closeAllTabs,
	// closeCurrentTab, and closeAllTabsInCurrentMode close the tab and then hang.
	// As a workaround, we open an incognito tab and then close the regular tab to
	// get to a state in which a single incognito tab is open.

	// Opening an incognito browser should disable DwaRecorder and metrics should
	// be purged.
	[self openNewIncognitoTab];
	[ChromeEarlGrey closeAllNormalTabs];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");

	// Opening another regular browser must not enable DWA.
	[self openNewRegularTab];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:NO],
	@"Failed to assert that DWA was not enabled.");

	// All incognito tabs have been closed, so DWA should be enabled.
	[ChromeEarlGrey closeAllIncognitoTabs];
	GREYAssert([MetricsAppInterface checkDWARecordingEnabled:YES],
	@"Failed to assert that DWA was enabled.");
	}
	// LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:IncognitoBrowserPlusRegularCheck)

	// Tests that disabling MSBB UKM consent disables and purges DWA.
	// Additionally tests that DWA is disabled until all UKM consents are enabled.
	// LINT.IfChange(UkmMsbbConsentChangeCheck)
	- (void)testUkmMsbbConsentChangeCheck {
	// Note: Tests begin with an open regular tab. This tab is opened in setUp.
	[MetricsAppInterface recordTestDWAEntryMetric];
	[self assertDwaIsEnabledAndAllowed];
	[self assertDwaRecorderHasMetrics];

	[ChromeEarlGreyUI openSettingsMenu];
	[ChromeEarlGrey waitForSufficientlyVisibleElementWithMatcher:
	GoogleServicesSettingsButton()];

	// Open Google services settings.
	[ChromeEarlGreyUI tapSettingsMenuButton:GoogleServicesSettingsButton()];
	[ChromeEarlGreyUI waitForAppToIdle];

	// Toggle "Make searches and browsing better" switch off.
	[self turnOffMsbbSwitch];
	[self assertDwaIsDisabledAndDisallowed];
	[self assertDwaRecorderIsEmpty];

	// Toggle "Make searches and browsing better" switch on.
	[self turnOnMsbbSwitch];
	[self assertDwaIsEnabledAndAllowed];
	[self assertDwaRecorderIsEmpty];

	// Validate DWA entries is able to be recorded when all consents are enabled.
	[MetricsAppInterface recordTestDWAEntryMetric];
	[self assertDwaRecorderHasMetrics];

	[[EarlGrey selectElementWithMatcher:SettingsDoneButton()]
	performAction:grey_tap()];
	}
	// LINT.ThenChange(/chrome/browser/metrics/dwa_browsertest.cc:UkmMsbbConsentChangeCheck)

	@end