Integrate UI and reset logic into AutomaticProfileResetter.

chrome/browser/profile_resetter/automatic_profile_resetter_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/profile_resetter/automatic_profile_resetter.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 14 matching lines @@
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
-using testing::Invoke;
 
 namespace {
 
 const char kAutomaticProfileResetStudyName[] = "AutomaticProfileReset";
 const char kStudyDisabledGroupName[] = "Disabled";
 const char kStudyDryRunGroupName[] = "DryRun";
 const char kStudyEnabledGroupName[] = "Enabled";
 
 const char kTestHashSeed[] = "testing-hash-seed";
 const char kTestMementoValue[] = "01234567890123456789012345678901";
@@ skipping 13 matching lines @@
 
 // A testing version of the AutomaticProfileResetter that differs from the real
 // one only in that it has its statistics reporting mocked out for verification.
 class AutomaticProfileResetterUnderTest : public AutomaticProfileResetter {
  public:
   explicit AutomaticProfileResetterUnderTest(Profile* profile)
       : AutomaticProfileResetter(profile) {}
   virtual ~AutomaticProfileResetterUnderTest() {}
 
   MOCK_METHOD2(ReportStatistics, void(uint32, uint32));
+  MOCK_METHOD1(ReportPromptResult,
+      void(AutomaticProfileResetter::PromptResult));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterUnderTest);
 };
 
 class MockProfileResetterDelegate : public AutomaticProfileResetterDelegate {
  public:
   MockProfileResetterDelegate()
-      : emulated_default_search_provider_is_managed_(false) {}
+      : emulated_is_default_search_provider_managed_(false) {}
   virtual ~MockProfileResetterDelegate() {}
 
   MOCK_METHOD0(EnumerateLoadedModulesIfNeeded, void());
   MOCK_CONST_METHOD1(RequestCallbackWhenLoadedModulesAreEnumerated,
                      void(const base::Closure&));
 
   MOCK_METHOD0(LoadTemplateURLServiceIfNeeded, void());
   MOCK_CONST_METHOD1(RequestCallbackWhenTemplateURLServiceIsLoaded,
                      void(const base::Closure&));
 
+  MOCK_METHOD0(FetchBrandcodedDefaultSettingsIfNeeded, void());
+  MOCK_CONST_METHOD1(RequestCallbackWhenBrandcodedDefaultsAreFetched,
+                     void(const base::Closure&));
+
   MOCK_CONST_METHOD0(OnGetLoadedModuleNameDigestsCalled, void());
   MOCK_CONST_METHOD0(OnGetDefaultSearchProviderDetailsCalled, void());
   MOCK_CONST_METHOD0(OnIsDefaultSearchProviderManagedCalled, void());
   MOCK_CONST_METHOD0(OnGetPrepopulatedSearchProvidersDetailsCalled, void());
 
-  MOCK_METHOD0(ShowPrompt, void());
+  MOCK_METHOD0(TriggerPrompt, bool());
+  MOCK_METHOD2(TriggerProfileSettingsReset, void(bool, const base::Closure&));
+  MOCK_METHOD0(DismissPrompt, void());
 
   virtual scoped_ptr<base::ListValue>
       GetLoadedModuleNameDigests() const OVERRIDE {
     OnGetLoadedModuleNameDigestsCalled();
     return scoped_ptr<base::ListValue>(
         emulated_loaded_module_digests_.DeepCopy());
   }
 
   virtual scoped_ptr<base::DictionaryValue>
       GetDefaultSearchProviderDetails() const OVERRIDE {
     OnGetDefaultSearchProviderDetailsCalled();
     return scoped_ptr<base::DictionaryValue>(
         emulated_default_search_provider_details_.DeepCopy());
   }
 
   virtual bool IsDefaultSearchProviderManaged() const OVERRIDE {
     OnIsDefaultSearchProviderManagedCalled();
-    return emulated_default_search_provider_is_managed_;
+    return emulated_is_default_search_provider_managed_;
   }
 
   virtual scoped_ptr<base::ListValue>
       GetPrepopulatedSearchProvidersDetails() const OVERRIDE {
     OnGetPrepopulatedSearchProvidersDetailsCalled();
     return scoped_ptr<base::ListValue>(
         emulated_search_providers_details_.DeepCopy());
   }
 
   static void ClosureInvoker(const base::Closure& closure) { closure.Run(); }
 
   void ExpectCallsToDependenciesSetUpMethods() {
     EXPECT_CALL(*this, EnumerateLoadedModulesIfNeeded());
     EXPECT_CALL(*this, LoadTemplateURLServiceIfNeeded());
     EXPECT_CALL(*this, RequestCallbackWhenLoadedModulesAreEnumerated(_))
-        .WillOnce(Invoke(ClosureInvoker));
+        .WillOnce(testing::Invoke(ClosureInvoker));
     EXPECT_CALL(*this, RequestCallbackWhenTemplateURLServiceIsLoaded(_))
-        .WillOnce(Invoke(ClosureInvoker));
+        .WillOnce(testing::Invoke(ClosureInvoker));
   }
 
   void ExpectCallsToGetterMethods() {
     EXPECT_CALL(*this, OnGetLoadedModuleNameDigestsCalled());
     EXPECT_CALL(*this, OnGetDefaultSearchProviderDetailsCalled());
     EXPECT_CALL(*this, OnIsDefaultSearchProviderManagedCalled());
     EXPECT_CALL(*this, OnGetPrepopulatedSearchProvidersDetailsCalled());
   }
 
+  void ExpectCallToShowPrompt() {
+    EXPECT_CALL(*this, TriggerPrompt()).WillOnce(testing::Return(true));
+    EXPECT_CALL(*this, FetchBrandcodedDefaultSettingsIfNeeded());
+  }
+
+  void ExpectCallToTriggerReset(bool send_feedback) {
+    EXPECT_CALL(*this, TriggerProfileSettingsReset(send_feedback, _))
+        .WillOnce(testing::SaveArg<1>(&reset_completion_));
+  }
+
   base::DictionaryValue& emulated_default_search_provider_details() {
     return emulated_default_search_provider_details_;
   }
 
   base::ListValue& emulated_search_providers_details() {
     return emulated_search_providers_details_;
   }
 
   base::ListValue& emulated_loaded_module_digests() {
     return emulated_loaded_module_digests_;
   }
 
-  void set_emulated_default_search_provider_is_managed(bool value) {
-    emulated_default_search_provider_is_managed_ = value;
+  void set_emulated_is_default_search_provider_managed(bool value) {
+    emulated_is_default_search_provider_managed_ = value;
+  }
+
+  void EmulateProfileResetCompleted() {
+    reset_completion_.Run();
   }
 
  private:
   base::DictionaryValue emulated_default_search_provider_details_;
   base::ListValue emulated_search_providers_details_;
   base::ListValue emulated_loaded_module_digests_;
-  bool emulated_default_search_provider_is_managed_;
+  bool emulated_is_default_search_provider_managed_;
+  base::Closure reset_completion_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProfileResetterDelegate);
 };
 
 class FileHostedPromptMementoSynchronous : protected FileHostedPromptMemento {
  public:
   explicit FileHostedPromptMementoSynchronous(Profile* profile)
       : FileHostedPromptMemento(profile) {}
 
   std::string ReadValue() const {
@@ skipping 230 matching lines @@
 
 // Test fixtures -------------------------------------------------------------
 
 class AutomaticProfileResetterTestBase : public testing::Test {
  protected:
   explicit AutomaticProfileResetterTestBase(
       const std::string& experiment_group_name)
       : waiting_task_runner_(new base::TestSimpleTaskRunner),
         local_state_(TestingBrowserProcess::GetGlobal()),
         profile_(new TestingProfile()),
+        field_trials_(new base::FieldTrialList(NULL)),
+        memento_in_prefs_(new PreferenceHostedPromptMemento(profile())),
+        memento_in_local_state_(new LocalStateHostedPromptMemento(profile())),
+        memento_in_file_(new FileHostedPromptMementoSynchronous(profile())),
         experiment_group_name_(experiment_group_name),
         inject_data_through_variation_params_(false),
         mock_delegate_(NULL) {
     // Make sure the factory is not optimized away, so whatever preferences it
     // wants to register will actually get registered.
     AutomaticProfileResetterFactory::GetInstance();
 
     // Register some additional local state preferences for testing purposes.
     PrefRegistrySimple* local_state_registry = local_state_.Get()->registry();
     DCHECK(local_state_registry);
     local_state_registry->RegisterStringPref(kTestPreferencePath, "");
 
     // Register some additional user preferences for testing purposes.
     user_prefs::PrefRegistrySyncable* user_prefs_registry =
         profile_->GetTestingPrefService()->registry();
     DCHECK(user_prefs_registry);
     user_prefs_registry->RegisterStringPref(
-        kTestPreferencePath,
-        "",
+        kTestPreferencePath, std::string(),
         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   }
 
   virtual void SetUp() OVERRIDE {
-    field_trials_.reset(new base::FieldTrialList(NULL));
     chrome_variations::testing::ClearAllVariationParams();
     base::FieldTrialList::CreateFieldTrial(kAutomaticProfileResetStudyName,
                                            experiment_group_name_);
     resetter_.reset(
         new testing::StrictMock<AutomaticProfileResetterUnderTest>(profile()));
     mock_delegate_owned_.reset(
         new testing::StrictMock<MockProfileResetterDelegate>());
     mock_delegate_ = mock_delegate_owned_.get();
+
+    ExpectAllMementoValuesEqualTo(std::string());
   }
 
   void SetTestingHashSeed(const std::string& hash_seed) {
     testing_hash_seed_ = hash_seed;
   }
 
   void SetTestingProgram(const std::string& source_code) {
     testing_program_ = source_code;
   }
 
   void AllowInjectingTestDataThroughVariationParams(bool value) {
     inject_data_through_variation_params_ = value;
   }
 
+  void ExpectAllMementoValuesEqualTo(const std::string& value) {
+    EXPECT_EQ(value, memento_in_prefs_->ReadValue());
+    EXPECT_EQ(value, memento_in_local_state_->ReadValue());
+    EXPECT_EQ(value, memento_in_file_->ReadValue());
+  }
+
   void UnleashResetterAndWait() {
     if (inject_data_through_variation_params_) {
       std::map<std::string, std::string> variation_params;
       variation_params["program"] = testing_program_;
       variation_params["hash_seed"] = testing_hash_seed_;
       ASSERT_TRUE(chrome_variations::AssociateVariationParams(
           kAutomaticProfileResetStudyName,
           experiment_group_name_,
           variation_params));
     }
@@ skipping 10 matching lines @@
     if (waiting_task_runner_->HasPendingTask()) {
       ASSERT_EQ(base::TimeDelta::FromSeconds(55),
                 waiting_task_runner_->NextPendingTaskDelay());
       waiting_task_runner_->RunPendingTasks();
     }
     base::RunLoop().RunUntilIdle();
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
 
+  // Goes through an evaluation flow such that the reset criteria are satisfied.
+  // Used to reduce boilerplate for tests that need to verify behavior during
+  // the reset prompt flow.
+  void OrchestrateThroughEvaluationFlow() {
+    SetTestingProgram(ConstructProgram(true, true));
+    SetTestingHashSeed(kTestHashSeed);
+
+    mock_delegate().ExpectCallsToDependenciesSetUpMethods();
+    mock_delegate().ExpectCallsToGetterMethods();
+    mock_delegate().ExpectCallToShowPrompt();
+    EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+
+    UnleashResetterAndWait();
+
+    testing::Mock::VerifyAndClearExpectations(&resetter());
+    testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+  }
+
+  // Explicitly shut down the service to double-check that nothing explodes, but
+  // first, verify expectations to make sure the service makes no more calls to
+  // any mocked functions during or after shutdown.
+  void VerifyExpectationsThenShutdownResetter() {
+    testing::Mock::VerifyAndClearExpectations(&resetter());
+    testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+    resetter_->Shutdown();
+    resetter_.reset();
+  }
+
   TestingProfile* profile() { return profile_.get(); }
   TestingPrefServiceSimple* local_state() { return local_state_.Get(); }
 
+  PreferenceHostedPromptMemento& memento_in_prefs() {
+    return *memento_in_prefs_;
+  }
+
+  LocalStateHostedPromptMemento& memento_in_local_state() {
+    return *memento_in_local_state_;
+  }
+
+  FileHostedPromptMementoSynchronous& memento_in_file() {
+    return *memento_in_file_;
+  }
+
   MockProfileResetterDelegate& mock_delegate() { return *mock_delegate_; }
   AutomaticProfileResetterUnderTest& resetter() { return *resetter_; }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::TestSimpleTaskRunner> waiting_task_runner_;
   ScopedTestingLocalState local_state_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<base::FieldTrialList> field_trials_;
+  scoped_ptr<PreferenceHostedPromptMemento> memento_in_prefs_;
+  scoped_ptr<LocalStateHostedPromptMemento> memento_in_local_state_;
+  scoped_ptr<FileHostedPromptMementoSynchronous> memento_in_file_;
+
   std::string experiment_group_name_;
   std::string testing_program_;
   std::string testing_hash_seed_;
   bool inject_data_through_variation_params_;
 
   scoped_ptr<AutomaticProfileResetterUnderTest> resetter_;
   scoped_ptr<MockProfileResetterDelegate> mock_delegate_owned_;
   MockProfileResetterDelegate* mock_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterTestBase);
@@ skipping 15 matching lines @@
 class AutomaticProfileResetterTestDisabled
     : public AutomaticProfileResetterTestBase {
  protected:
   AutomaticProfileResetterTestDisabled()
       : AutomaticProfileResetterTestBase(kStudyDisabledGroupName) {}
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(AutomaticProfileResetterTestDisabled, NothingIsDoneWhenDisabled) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   // No calls are expected to the delegate.
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(std::string());
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, ConditionsNotSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(false, false));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, 0x00u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(std::string());
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, OneConditionSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(true, false));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x01u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, OtherConditionSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(false, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x02u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 
 #if defined(GOOGLE_CHROME_BUILD)
 TEST_F(AutomaticProfileResetterTestDryRun, ProgramSetThroughVariationParams) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
   AllowInjectingTestDataThroughVariationParams(true);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 #endif
 
 TEST_F(AutomaticProfileResetterTestDryRun,
        ConditionsSatisfiedAndInvalidMementos) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_prefs.StoreValue(kTestInvalidMementoValue);
-  memento_in_local_state.StoreValue(kTestInvalidMementoValue);
-  memento_in_file.StoreValue(kTestInvalidMementoValue);
+  memento_in_prefs().StoreValue(kTestInvalidMementoValue);
+  memento_in_local_state().StoreValue(kTestInvalidMementoValue);
+  memento_in_file().StoreValue(kTestInvalidMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadPrefHostedMemento) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_prefs.StoreValue(kTestMementoValue);
+  memento_in_prefs().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x03u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_prefs().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadLocalStateHostedMemento) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_local_state.StoreValue(kTestMementoValue);
+  memento_in_local_state().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x05u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_local_state().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadFileHostedMemento) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_file.StoreValue(kTestMementoValue);
+  memento_in_file().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x09u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTestDryRun, DoNothingWhenResourcesAreMissing) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  SetTestingProgram("");
-  SetTestingHashSeed("");
+  SetTestingProgram(std::string());
+  SetTestingHashSeed(std::string());
 
   // No calls are expected to the delegate.
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(std::string());
 }
 
 TEST_F(AutomaticProfileResetterTest, ConditionsNotSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(false, false));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, 0x00u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(std::string());
 }
 
 TEST_F(AutomaticProfileResetterTest, OneConditionSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(true, false));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  EXPECT_CALL(mock_delegate(), ShowPrompt());
+  mock_delegate().ExpectCallToShowPrompt();
   EXPECT_CALL(resetter(), ReportStatistics(0x01u, 0x01u));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  VerifyExpectationsThenShutdownResetter();
 }
 
 TEST_F(AutomaticProfileResetterTest, OtherConditionSatisfied) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(false, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  EXPECT_CALL(mock_delegate(), ShowPrompt());
+  mock_delegate().ExpectCallToShowPrompt();
   EXPECT_CALL(resetter(), ReportStatistics(0x02u, 0x01u));
 
   UnleashResetterAndWait();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  VerifyExpectationsThenShutdownResetter();
 }
 
 #if defined(GOOGLE_CHROME_BUILD)
 TEST_F(AutomaticProfileResetterTest, ProgramSetThroughVariationParams) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
-
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
   AllowInjectingTestDataThroughVariationParams(true);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  EXPECT_CALL(mock_delegate(), ShowPrompt());
+  mock_delegate().ExpectCallToShowPrompt();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
 
   UnleashResetterAndWait();
+  resetter().NotifyDidShowResetBubble();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 #endif
 
 TEST_F(AutomaticProfileResetterTest, ConditionsSatisfiedAndInvalidMementos) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_prefs.StoreValue(kTestInvalidMementoValue);
-  memento_in_local_state.StoreValue(kTestInvalidMementoValue);
-  memento_in_file.StoreValue(kTestInvalidMementoValue);
+  memento_in_prefs().StoreValue(kTestInvalidMementoValue);
+  memento_in_local_state().StoreValue(kTestInvalidMementoValue);
+  memento_in_file().StoreValue(kTestInvalidMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  EXPECT_CALL(mock_delegate(), ShowPrompt());
+  mock_delegate().ExpectCallToShowPrompt();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
 
   UnleashResetterAndWait();
+  resetter().NotifyDidShowResetBubble();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 
 TEST_F(AutomaticProfileResetterTest, PrefHostedMementoPreventsPrompt) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_prefs.StoreValue(kTestMementoValue);
+  memento_in_prefs().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x03u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_prefs().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTest, LocalStateHostedMementoPreventsPrompt) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_local_state.StoreValue(kTestMementoValue);
+  memento_in_local_state().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x05u));
 
   UnleashResetterAndWait();
+  VerifyExpectationsThenShutdownResetter();
 
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_local_state().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTest, FileHostedMementoPreventsPrompt) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  memento_in_file.StoreValue(kTestMementoValue);
+  memento_in_file().StoreValue(kTestMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x09u));
 
   UnleashResetterAndWait();
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+  VerifyExpectationsThenShutdownResetter();
+
+  EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
+  EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_file().ReadValue());
 }
 
 TEST_F(AutomaticProfileResetterTest, DoNothingWhenResourcesAreMissing) {
-  PreferenceHostedPromptMemento memento_in_prefs(profile());
-  LocalStateHostedPromptMemento memento_in_local_state(profile());
-  FileHostedPromptMementoSynchronous memento_in_file(profile());
-
-  SetTestingProgram("");
-  SetTestingHashSeed("");
+  SetTestingProgram(std::string());
+  SetTestingHashSeed(std::string());
 
   // No calls are expected to the delegate.
 
   UnleashResetterAndWait();
-
-  EXPECT_EQ("", memento_in_prefs.ReadValue());
-  EXPECT_EQ("", memento_in_local_state.ReadValue());
-  EXPECT_EQ("", memento_in_file.ReadValue());
+  VerifyExpectationsThenShutdownResetter();
+
+  ExpectAllMementoValuesEqualTo(std::string());
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptSuppressed) {
+  OrchestrateThroughEvaluationFlow();
+
+  VerifyExpectationsThenShutdownResetter();
+
+  ExpectAllMementoValuesEqualTo(std::string());
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptNotSupported) {
+  SetTestingProgram(ConstructProgram(true, true));
+  SetTestingHashSeed(kTestHashSeed);
+
+  mock_delegate().ExpectCallsToDependenciesSetUpMethods();
+  mock_delegate().ExpectCallsToGetterMethods();
+  EXPECT_CALL(mock_delegate(), TriggerPrompt())
+      .WillOnce(testing::Return(false));
+  EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
+
+  UnleashResetterAndWait();
+
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptIgnored) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptActionReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  mock_delegate().ExpectCallToTriggerReset(false);
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_ACTION_RESET));
+  resetter().TriggerProfileReset(false /*send_feedback*/);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  mock_delegate().EmulateProfileResetCompleted();
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptActionResetWithFeedback) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  mock_delegate().ExpectCallToTriggerReset(true);
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_ACTION_RESET));
+  resetter().TriggerProfileReset(true /*send_feedback*/);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  mock_delegate().EmulateProfileResetCompleted();
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptActionNoReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_ACTION_NO_RESET));
+  resetter().SkipProfileReset();
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptFollowedByWebUIReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  resetter().NotifyDidOpenWebUIResetDialog();
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_RESET));
+  resetter().NotifyDidCloseWebUIResetDialog(true);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptFollowedByWebUINoReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  resetter().NotifyDidOpenWebUIResetDialog();
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_NO_RESET));
+  resetter().NotifyDidCloseWebUIResetDialog(false);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptFollowedByIncidentalWebUIReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
+  resetter().NotifyDidShowResetBubble();
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  testing::Mock::VerifyAndClearExpectations(&resetter());
+
+  // Missing NotifyDidOpenWebUIResetDialog().
+  // This can arise if a settings page was already opened at the time the prompt
+  // was triggered, and it used to initiate reset after dismissing the prompt.
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_RESET));
+  resetter().NotifyDidCloseWebUIResetDialog(true);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptSuppressedButHadWebUIReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  resetter().NotifyDidOpenWebUIResetDialog();
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(resetter(), ReportPromptResult(
+      AutomaticProfileResetter::PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_RESET));
+  resetter().NotifyDidCloseWebUIResetDialog(true);
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
+}
+
+TEST_F(AutomaticProfileResetterTest, PromptSuppressedButHadWebUINoReset) {
+  OrchestrateThroughEvaluationFlow();
+
+  EXPECT_CALL(mock_delegate(), DismissPrompt());
+  resetter().NotifyDidOpenWebUIResetDialog();
+  testing::Mock::VerifyAndClearExpectations(&mock_delegate());
+
+  EXPECT_CALL(resetter(), ReportPromptResult(AutomaticProfileResetter::
+      PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_NO_RESET));
+  resetter().NotifyDidCloseWebUIResetDialog(false);
+  ExpectAllMementoValuesEqualTo(kTestMementoValue);
+  VerifyExpectationsThenShutdownResetter();
 }
 
 // Please see comments above ConstructProgramToCheckPreferences() to understand
 // how the following tests work.
 
 TEST_F(AutomaticProfileResetterTest, InputUserPreferencesCorrect) {
   SetTestingProgram(ConstructProgramToCheckPreferences());
   SetTestingHashSeed(kTestHashSeed);
 
   PrefService* prefs = profile()->GetPrefs();
   prefs->SetString(kTestPreferencePath, kTestPreferenceValue);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  uint32 expected_mask =
-      HAS_EXPECTED_USER_PREFERENCE | USER_PREFERENCE_IS_USER_CONTROLLED;
+  uint32 expected_mask = HAS_EXPECTED_USER_PREFERENCE |
+                         USER_PREFERENCE_IS_USER_CONTROLLED;
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
 
   UnleashResetterAndWait();
 }
 
 TEST_F(AutomaticProfileResetterTest, InputLocalStateCorrect) {
   SetTestingProgram(ConstructProgramToCheckPreferences());
   SetTestingHashSeed(kTestHashSeed);
 
   PrefService* prefs = local_state();
   prefs->SetString(kTestPreferencePath, kTestPreferenceValue);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
-  uint32 expected_mask =
-      HAS_EXPECTED_LOCAL_STATE_PREFERENCE | LOCAL_STATE_IS_USER_CONTROLLED;
+  uint32 expected_mask = HAS_EXPECTED_LOCAL_STATE_PREFERENCE |
+                         LOCAL_STATE_IS_USER_CONTROLLED;
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
 
   UnleashResetterAndWait();
 }
 
 TEST_F(AutomaticProfileResetterTest, InputManagedUserPreferencesCorrect) {
   SetTestingProgram(ConstructProgramToCheckPreferences());
   SetTestingHashSeed(kTestHashSeed);
 
   TestingPrefServiceSyncable* prefs = profile()->GetTestingPrefService();
@@ skipping 42 matching lines @@
 
   UnleashResetterAndWait();
 }
 
 TEST_F(AutomaticProfileResetterTest, InputSearchProviderManagedCorrect) {
   SetTestingProgram(ConstructProgramToCheckSearchEngines());
   SetTestingHashSeed(kTestHashSeed);
 
   mock_delegate().emulated_default_search_provider_details().SetString(
       kSearchURLAttributeKey, kTestSearchURL);
-  mock_delegate().set_emulated_default_search_provider_is_managed(true);
+  mock_delegate().set_emulated_is_default_search_provider_managed(true);
 
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   uint32 expected_mask = HAS_EXPECTED_DEFAULT_SEARCH_PROVIDER;
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
 
   UnleashResetterAndWait();
 }
 
 TEST_F(AutomaticProfileResetterTest, InputSearchProvidersCorrect) {
@@ skipping 32 matching lines @@
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   uint32 expected_mask =
       HAS_EXPECTED_MODULE_DIGEST_1 | HAS_EXPECTED_MODULE_DIGEST_2;
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
 
   UnleashResetterAndWait();
 }
 
 }  // namespace