| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/profile_resetter/automatic_profile_resetter.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/memory/ref_counted.h" | |
| 11 #include "base/metrics/field_trial.h" | |
| 12 #include "base/metrics/histogram.h" | |
| 13 #include "base/metrics/sparse_histogram.h" | |
| 14 #include "base/prefs/pref_service.h" | |
| 15 #include "base/strings/string_number_conversions.h" | |
| 16 #include "base/strings/string_util.h" | |
| 17 #include "base/task_runner.h" | |
| 18 #include "base/task_runner_util.h" | |
| 19 #include "base/threading/sequenced_worker_pool.h" | |
| 20 #include "base/time/time.h" | |
| 21 #include "base/timer/elapsed_timer.h" | |
| 22 #include "base/values.h" | |
| 23 #include "chrome/browser/browser_process.h" | |
| 24 #include "chrome/browser/profile_resetter/automatic_profile_resetter_delegate.h" | |
| 25 #include "chrome/browser/profile_resetter/jtl_interpreter.h" | |
| 26 #include "chrome/browser/profiles/profile.h" | |
| 27 #include "chrome/browser/search_engines/template_url_service.h" | |
| 28 #include "chrome/browser/search_engines/template_url_service_factory.h" | |
| 29 #include "components/variations/variations_associated_data.h" | |
| 30 #include "content/public/browser/browser_thread.h" | |
| 31 #include "grit/browser_resources.h" | |
| 32 #include "ui/base/resource/resource_bundle.h" | |
| 33 | |
| 34 | |
| 35 // Helpers ------------------------------------------------------------------- | |
| 36 | |
| 37 namespace { | |
| 38 | |
| 39 // Name constants for the field trial behind which we enable this feature. | |
| 40 const char kAutomaticProfileResetStudyName[] = "AutomaticProfileReset"; | |
| 41 const char kAutomaticProfileResetStudyDryRunGroupName[] = "DryRun"; | |
| 42 const char kAutomaticProfileResetStudyEnabledGroupName[] = "Enabled"; | |
| 43 #if defined(GOOGLE_CHROME_BUILD) | |
| 44 const char kAutomaticProfileResetStudyProgramParameterName[] = "program"; | |
| 45 const char kAutomaticProfileResetStudyHashSeedParameterName[] = "hash_seed"; | |
| 46 #endif | |
| 47 | |
| 48 // How long to wait after start-up before unleashing the evaluation flow. | |
| 49 const int64 kEvaluationFlowDelayInSeconds = 55; | |
| 50 | |
| 51 // Keys used in the input dictionary of the program. | |
| 52 const char kDefaultSearchProviderKey[] = "default_search_provider"; | |
| 53 const char kDefaultSearchProviderIsUserControlledKey[] = | |
| 54 "default_search_provider_iuc"; | |
| 55 const char kLoadedModuleDigestsKey[] = "loaded_modules"; | |
| 56 const char kLocalStateKey[] = "local_state"; | |
| 57 const char kLocalStateIsUserControlledKey[] = "local_state_iuc"; | |
| 58 const char kSearchProvidersKey[] = "search_providers"; | |
| 59 const char kUserPreferencesKey[] = "preferences"; | |
| 60 const char kUserPreferencesIsUserControlledKey[] = "preferences_iuc"; | |
| 61 | |
| 62 // Keys used in the output dictionary of the program. | |
| 63 const char kCombinedStatusMaskKeyPrefix[] = "combined_status_mask_bit"; | |
| 64 const char kHadPromptedAlreadyKey[] = "had_prompted_already"; | |
| 65 const char kShouldPromptKey[] = "should_prompt"; | |
| 66 const char kSatisfiedCriteriaMaskKeyPrefix[] = "satisfied_criteria_mask_bit"; | |
| 67 | |
| 68 // Keys used in both the input and output dictionary of the program. | |
| 69 const char kMementoValueInFileKey[] = "memento_value_in_file"; | |
| 70 const char kMementoValueInLocalStateKey[] = "memento_value_in_local_state"; | |
| 71 const char kMementoValueInPrefsKey[] = "memento_value_in_prefs"; | |
| 72 | |
| 73 // Number of bits, and maximum value (exclusive) for the mask whose bits | |
| 74 // indicate which of reset criteria were satisfied. | |
| 75 const size_t kSatisfiedCriteriaMaskNumberOfBits = 5u; | |
| 76 const uint32 kSatisfiedCriteriaMaskMaximumValue = | |
| 77 (1u << kSatisfiedCriteriaMaskNumberOfBits); | |
| 78 | |
| 79 // Number of bits, and maximum value (exclusive) for the mask whose bits | |
| 80 // indicate if any of reset criteria were satisfied, and which of the mementos | |
| 81 // were already present. | |
| 82 const size_t kCombinedStatusMaskNumberOfBits = 4u; | |
| 83 const uint32 kCombinedStatusMaskMaximumValue = | |
| 84 (1u << kCombinedStatusMaskNumberOfBits); | |
| 85 | |
| 86 // Returns whether or not a dry-run shall be performed. | |
| 87 bool ShouldPerformDryRun() { | |
| 88 return StartsWithASCII( | |
| 89 base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName), | |
| 90 kAutomaticProfileResetStudyDryRunGroupName, true); | |
| 91 } | |
| 92 | |
| 93 // Returns whether or not a live-run shall be performed. | |
| 94 bool ShouldPerformLiveRun() { | |
| 95 return StartsWithASCII( | |
| 96 base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName), | |
| 97 kAutomaticProfileResetStudyEnabledGroupName, true); | |
| 98 } | |
| 99 | |
| 100 // If the currently active experiment group prescribes a |program| and | |
| 101 // |hash_seed| to use instead of the baked-in ones, retrieves those and returns | |
| 102 // true. Otherwise, returns false. | |
| 103 bool GetProgramAndHashSeedOverridesFromExperiment(std::string* program, | |
| 104 std::string* hash_seed) { | |
| 105 DCHECK(program); | |
| 106 DCHECK(hash_seed); | |
| 107 #if defined(GOOGLE_CHROME_BUILD) | |
| 108 std::map<std::string, std::string> params; | |
| 109 chrome_variations::GetVariationParams(kAutomaticProfileResetStudyName, | |
| 110 ¶ms); | |
| 111 if (params.count(kAutomaticProfileResetStudyProgramParameterName) && | |
| 112 params.count(kAutomaticProfileResetStudyHashSeedParameterName)) { | |
| 113 program->swap(params[kAutomaticProfileResetStudyProgramParameterName]); | |
| 114 hash_seed->swap(params[kAutomaticProfileResetStudyHashSeedParameterName]); | |
| 115 return true; | |
| 116 } | |
| 117 #endif | |
| 118 return false; | |
| 119 } | |
| 120 | |
| 121 // Takes |pref_name_to_value_map|, which shall be a deep-copy of all preferences | |
| 122 // in |source| without path expansion; and (1.) creates a sub-tree from it named | |
| 123 // |value_tree_key| in |target_dictionary| with path expansion, and (2.) also | |
| 124 // creates an isomorphic sub-tree under the key |is_user_controlled_tree_key| | |
| 125 // that contains only Boolean values indicating whether or not the corresponding | |
| 126 // preference is coming from the 'user' PrefStore. | |
| 127 void BuildSubTreesFromPreferences( | |
| 128 scoped_ptr<base::DictionaryValue> pref_name_to_value_map, | |
| 129 const PrefService* source, | |
| 130 const char* value_tree_key, | |
| 131 const char* is_user_controlled_tree_key, | |
| 132 base::DictionaryValue* target_dictionary) { | |
| 133 std::vector<std::string> pref_names; | |
| 134 pref_names.reserve(pref_name_to_value_map->size()); | |
| 135 for (base::DictionaryValue::Iterator it(*pref_name_to_value_map); | |
| 136 !it.IsAtEnd(); it.Advance()) | |
| 137 pref_names.push_back(it.key()); | |
| 138 | |
| 139 base::DictionaryValue* value_tree = new base::DictionaryValue; | |
| 140 base::DictionaryValue* is_user_controlled_tree = new base::DictionaryValue; | |
| 141 for (std::vector<std::string>::const_iterator it = pref_names.begin(); | |
| 142 it != pref_names.end(); ++it) { | |
| 143 scoped_ptr<base::Value> pref_value_owned; | |
| 144 if (pref_name_to_value_map->RemoveWithoutPathExpansion(*it, | |
| 145 &pref_value_owned)) { | |
| 146 value_tree->Set(*it, pref_value_owned.release()); | |
| 147 const PrefService::Preference* pref = source->FindPreference(it->c_str()); | |
| 148 is_user_controlled_tree->Set( | |
| 149 *it, new base::FundamentalValue(pref->IsUserControlled())); | |
| 150 } | |
| 151 } | |
| 152 target_dictionary->Set(value_tree_key, value_tree); | |
| 153 target_dictionary->Set(is_user_controlled_tree_key, is_user_controlled_tree); | |
| 154 } | |
| 155 | |
| 156 } // namespace | |
| 157 | |
| 158 | |
| 159 // AutomaticProfileResetter::InputBuilder ------------------------------------ | |
| 160 | |
| 161 // Collects all the information that is required by the evaluator program to | |
| 162 // assess whether or not the conditions for showing the reset prompt are met. | |
| 163 // | |
| 164 // This necessitates a lot of work that has to be performed on the UI thread, | |
| 165 // such as: accessing the Preferences, Local State, and TemplateURLService. | |
| 166 // In order to keep the browser responsive, the UI thread shall not be blocked | |
| 167 // for long consecutive periods of time. Unfortunately, we cannot reduce the | |
| 168 // total amount of work. Instead, what this class does is to split the work into | |
| 169 // shorter tasks that are posted one-at-a-time to the UI thread in a serial | |
| 170 // fashion, so as to give a chance to run other tasks that have accumulated in | |
| 171 // the meantime. | |
| 172 class AutomaticProfileResetter::InputBuilder | |
| 173 : public base::SupportsWeakPtr<InputBuilder> { | |
| 174 public: | |
| 175 typedef base::Callback<void(scoped_ptr<base::DictionaryValue>)> | |
| 176 ProgramInputCallback; | |
| 177 | |
| 178 // The dependencies must have been initialized through |delegate|, i.e. the | |
| 179 // RequestCallback[...] methods must have already fired before calling this. | |
| 180 InputBuilder(Profile* profile, AutomaticProfileResetterDelegate* delegate) | |
| 181 : profile_(profile), | |
| 182 delegate_(delegate), | |
| 183 memento_in_prefs_(profile_), | |
| 184 memento_in_local_state_(profile_), | |
| 185 memento_in_file_(profile_) {} | |
| 186 ~InputBuilder() {} | |
| 187 | |
| 188 // Assembles the data required by the evaluator program into a dictionary | |
| 189 // format, and posts it back to the UI thread with |callback| once ready. In | |
| 190 // order not to block the UI thread for long consecutive periods of time, the | |
| 191 // work is divided into smaller tasks, see class comment above for details. | |
| 192 // It is safe to destroy |this| immediately from within the |callback|. | |
| 193 void BuildEvaluatorProgramInput(const ProgramInputCallback& callback) { | |
| 194 DCHECK(!data_); | |
| 195 DCHECK(!callback.is_null()); | |
| 196 data_.reset(new base::DictionaryValue); | |
| 197 callback_ = callback; | |
| 198 | |
| 199 AddAsyncTask(base::Bind(&InputBuilder::IncludeMementoValues, AsWeakPtr())); | |
| 200 AddTask(base::Bind(&InputBuilder::IncludeUserPreferences, AsWeakPtr())); | |
| 201 AddTask(base::Bind(&InputBuilder::IncludeLocalState, AsWeakPtr())); | |
| 202 AddTask(base::Bind(&InputBuilder::IncludeSearchEngines, AsWeakPtr())); | |
| 203 AddTask(base::Bind(&InputBuilder::IncludeLoadedModules, AsWeakPtr())); | |
| 204 | |
| 205 // Each task will post the next one. Just trigger the chain reaction. | |
| 206 PostNextTask(); | |
| 207 } | |
| 208 | |
| 209 private: | |
| 210 // Asynchronous task that includes memento values (or empty strings in case | |
| 211 // mementos are not there). | |
| 212 void IncludeMementoValues() { | |
| 213 data_->SetString(kMementoValueInPrefsKey, memento_in_prefs_.ReadValue()); | |
| 214 data_->SetString(kMementoValueInLocalStateKey, | |
| 215 memento_in_local_state_.ReadValue()); | |
| 216 memento_in_file_.ReadValue(base::Bind( | |
| 217 &InputBuilder::IncludeFileBasedMementoCallback, AsWeakPtr())); | |
| 218 } | |
| 219 | |
| 220 // Called back by |memento_in_file_| once the |memento_value| has been read. | |
| 221 void IncludeFileBasedMementoCallback(const std::string& memento_value) { | |
| 222 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 223 data_->SetString(kMementoValueInFileKey, memento_value); | |
| 224 // As an asynchronous task, we need to take care of posting the next task. | |
| 225 PostNextTask(); | |
| 226 } | |
| 227 | |
| 228 // Task that includes all user (i.e. profile-specific) preferences, along with | |
| 229 // information about whether the value is coming from the 'user' PrefStore. | |
| 230 // This is the most expensive operation, so it is itself split into two parts. | |
| 231 void IncludeUserPreferences() { | |
| 232 PrefService* prefs = profile_->GetPrefs(); | |
| 233 DCHECK(prefs); | |
| 234 scoped_ptr<base::DictionaryValue> pref_name_to_value_map( | |
| 235 prefs->GetPreferenceValuesWithoutPathExpansion()); | |
| 236 AddTask(base::Bind(&InputBuilder::IncludeUserPreferencesPartTwo, | |
| 237 AsWeakPtr(), | |
| 238 base::Passed(&pref_name_to_value_map))); | |
| 239 } | |
| 240 | |
| 241 // Second part to above. | |
| 242 void IncludeUserPreferencesPartTwo( | |
| 243 scoped_ptr<base::DictionaryValue> pref_name_to_value_map) { | |
| 244 PrefService* prefs = profile_->GetPrefs(); | |
| 245 DCHECK(prefs); | |
| 246 BuildSubTreesFromPreferences( | |
| 247 pref_name_to_value_map.Pass(), | |
| 248 prefs, | |
| 249 kUserPreferencesKey, | |
| 250 kUserPreferencesIsUserControlledKey, | |
| 251 data_.get()); | |
| 252 } | |
| 253 | |
| 254 // Task that includes all local state (i.e. shared) preferences, along with | |
| 255 // information about whether the value is coming from the 'user' PrefStore. | |
| 256 void IncludeLocalState() { | |
| 257 PrefService* local_state = g_browser_process->local_state(); | |
| 258 DCHECK(local_state); | |
| 259 scoped_ptr<base::DictionaryValue> pref_name_to_value_map( | |
| 260 local_state->GetPreferenceValuesWithoutPathExpansion()); | |
| 261 BuildSubTreesFromPreferences( | |
| 262 pref_name_to_value_map.Pass(), | |
| 263 local_state, | |
| 264 kLocalStateKey, | |
| 265 kLocalStateIsUserControlledKey, | |
| 266 data_.get()); | |
| 267 } | |
| 268 | |
| 269 // Task that includes all information related to search engines. | |
| 270 void IncludeSearchEngines() { | |
| 271 scoped_ptr<base::DictionaryValue> default_search_provider_details( | |
| 272 delegate_->GetDefaultSearchProviderDetails()); | |
| 273 data_->Set(kDefaultSearchProviderKey, | |
| 274 default_search_provider_details.release()); | |
| 275 | |
| 276 scoped_ptr<base::ListValue> search_providers_details( | |
| 277 delegate_->GetPrepopulatedSearchProvidersDetails()); | |
| 278 data_->Set(kSearchProvidersKey, search_providers_details.release()); | |
| 279 | |
| 280 data_->SetBoolean(kDefaultSearchProviderIsUserControlledKey, | |
| 281 !delegate_->IsDefaultSearchProviderManaged()); | |
| 282 } | |
| 283 | |
| 284 // Task that includes information about loaded modules. | |
| 285 void IncludeLoadedModules() { | |
| 286 scoped_ptr<base::ListValue> loaded_module_digests( | |
| 287 delegate_->GetLoadedModuleNameDigests()); | |
| 288 data_->Set(kLoadedModuleDigestsKey, loaded_module_digests.release()); | |
| 289 } | |
| 290 | |
| 291 // ------------------------------------------------------------------------- | |
| 292 | |
| 293 // Adds a |task| that can do as much asynchronous processing as it wants, but | |
| 294 // will need to finally call PostNextTask() on the UI thread when done. | |
| 295 void AddAsyncTask(const base::Closure& task) { | |
| 296 task_queue_.push(task); | |
| 297 } | |
| 298 | |
| 299 // Convenience wrapper for synchronous tasks. | |
| 300 void SynchronousTaskWrapper(const base::Closure& task) { | |
| 301 base::ElapsedTimer timer; | |
| 302 task.Run(); | |
| 303 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 304 "AutomaticProfileReset.InputBuilder.TaskDuration", | |
| 305 timer.Elapsed(), | |
| 306 base::TimeDelta::FromMilliseconds(1), | |
| 307 base::TimeDelta::FromSeconds(2), | |
| 308 50); | |
| 309 PostNextTask(); | |
| 310 } | |
| 311 | |
| 312 // Adds a task that needs to finish synchronously. In exchange, PostNextTask() | |
| 313 // is called automatically when the |task| returns, and execution time is | |
| 314 // measured. | |
| 315 void AddTask(const base::Closure& task) { | |
| 316 task_queue_.push( | |
| 317 base::Bind(&InputBuilder::SynchronousTaskWrapper, AsWeakPtr(), task)); | |
| 318 } | |
| 319 | |
| 320 // Posts the next task from the |task_queue_|, unless it is exhausted, in | |
| 321 // which case it posts |callback_| to return with the results. | |
| 322 void PostNextTask() { | |
| 323 base::Closure next_task; | |
| 324 if (task_queue_.empty()) { | |
| 325 next_task = base::Bind(callback_, base::Passed(&data_)); | |
| 326 } else { | |
| 327 next_task = task_queue_.front(); | |
| 328 task_queue_.pop(); | |
| 329 } | |
| 330 content::BrowserThread::PostTask( | |
| 331 content::BrowserThread::UI, FROM_HERE, next_task); | |
| 332 } | |
| 333 | |
| 334 Profile* profile_; | |
| 335 AutomaticProfileResetterDelegate* delegate_; | |
| 336 ProgramInputCallback callback_; | |
| 337 | |
| 338 PreferenceHostedPromptMemento memento_in_prefs_; | |
| 339 LocalStateHostedPromptMemento memento_in_local_state_; | |
| 340 FileHostedPromptMemento memento_in_file_; | |
| 341 | |
| 342 scoped_ptr<base::DictionaryValue> data_; | |
| 343 std::queue<base::Closure> task_queue_; | |
| 344 | |
| 345 DISALLOW_COPY_AND_ASSIGN(InputBuilder); | |
| 346 }; | |
| 347 | |
| 348 | |
| 349 // AutomaticProfileResetter::EvaluationResults ------------------------------- | |
| 350 | |
| 351 // Encapsulates the output values extracted from the evaluator program. | |
| 352 struct AutomaticProfileResetter::EvaluationResults { | |
| 353 EvaluationResults() | |
| 354 : should_prompt(false), | |
| 355 had_prompted_already(false), | |
| 356 satisfied_criteria_mask(0), | |
| 357 combined_status_mask(0) {} | |
| 358 | |
| 359 std::string memento_value_in_prefs; | |
| 360 std::string memento_value_in_local_state; | |
| 361 std::string memento_value_in_file; | |
| 362 | |
| 363 bool should_prompt; | |
| 364 bool had_prompted_already; | |
| 365 uint32 satisfied_criteria_mask; | |
| 366 uint32 combined_status_mask; | |
| 367 }; | |
| 368 | |
| 369 | |
| 370 // AutomaticProfileResetter -------------------------------------------------- | |
| 371 | |
| 372 AutomaticProfileResetter::AutomaticProfileResetter(Profile* profile) | |
| 373 : profile_(profile), | |
| 374 state_(STATE_UNINITIALIZED), | |
| 375 enumeration_of_loaded_modules_ready_(false), | |
| 376 template_url_service_ready_(false), | |
| 377 has_already_dismissed_prompt_(false), | |
| 378 should_show_reset_banner_(false), | |
| 379 weak_ptr_factory_(this) { | |
| 380 DCHECK(profile_); | |
| 381 } | |
| 382 | |
| 383 AutomaticProfileResetter::~AutomaticProfileResetter() {} | |
| 384 | |
| 385 void AutomaticProfileResetter::Initialize() { | |
| 386 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 387 DCHECK_EQ(state_, STATE_UNINITIALIZED); | |
| 388 | |
| 389 if (!ShouldPerformDryRun() && !ShouldPerformLiveRun()) { | |
| 390 state_ = STATE_DISABLED; | |
| 391 return; | |
| 392 } | |
| 393 | |
| 394 if (!GetProgramAndHashSeedOverridesFromExperiment(&program_, &hash_seed_)) { | |
| 395 ui::ResourceBundle& resources(ui::ResourceBundle::GetSharedInstance()); | |
| 396 if (ShouldPerformLiveRun()) { | |
| 397 program_ = resources.GetRawDataResource( | |
| 398 IDR_AUTOMATIC_PROFILE_RESET_RULES).as_string(); | |
| 399 hash_seed_ = resources.GetRawDataResource( | |
| 400 IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED).as_string(); | |
| 401 } else { // ShouldPerformDryRun() | |
| 402 program_ = resources.GetRawDataResource( | |
| 403 IDR_AUTOMATIC_PROFILE_RESET_RULES_DRY).as_string(); | |
| 404 hash_seed_ = resources.GetRawDataResource( | |
| 405 IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED_DRY).as_string(); | |
| 406 } | |
| 407 } | |
| 408 | |
| 409 delegate_.reset(new AutomaticProfileResetterDelegateImpl( | |
| 410 profile_, ProfileResetter::ALL)); | |
| 411 task_runner_for_waiting_ = | |
| 412 content::BrowserThread::GetMessageLoopProxyForThread( | |
| 413 content::BrowserThread::UI); | |
| 414 | |
| 415 state_ = STATE_INITIALIZED; | |
| 416 } | |
| 417 | |
| 418 void AutomaticProfileResetter::Activate() { | |
| 419 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 420 DCHECK(state_ == STATE_INITIALIZED || state_ == STATE_DISABLED); | |
| 421 | |
| 422 if (state_ == STATE_INITIALIZED) { | |
| 423 if (!program_.empty()) { | |
| 424 // Some steps in the flow (e.g. loaded modules, file-based memento) are | |
| 425 // IO-intensive, so defer execution until some time later. | |
| 426 task_runner_for_waiting_->PostDelayedTask( | |
| 427 FROM_HERE, | |
| 428 base::Bind(&AutomaticProfileResetter::PrepareEvaluationFlow, | |
| 429 weak_ptr_factory_.GetWeakPtr()), | |
| 430 base::TimeDelta::FromSeconds(kEvaluationFlowDelayInSeconds)); | |
| 431 } else { | |
| 432 // Terminate early if there is no program included (nor set by tests). | |
| 433 state_ = STATE_DISABLED; | |
| 434 } | |
| 435 } | |
| 436 } | |
| 437 | |
| 438 void AutomaticProfileResetter::TriggerProfileReset(bool send_feedback) { | |
| 439 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 440 DCHECK_EQ(state_, STATE_HAS_SHOWN_BUBBLE); | |
| 441 | |
| 442 state_ = STATE_PERFORMING_RESET; | |
| 443 should_show_reset_banner_ = false; | |
| 444 | |
| 445 ReportPromptResult(PROMPT_ACTION_RESET); | |
| 446 delegate_->TriggerProfileSettingsReset( | |
| 447 send_feedback, | |
| 448 base::Bind(&AutomaticProfileResetter::OnProfileSettingsResetCompleted, | |
| 449 weak_ptr_factory_.GetWeakPtr())); | |
| 450 } | |
| 451 | |
| 452 void AutomaticProfileResetter::SkipProfileReset() { | |
| 453 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 454 DCHECK_EQ(state_, STATE_HAS_SHOWN_BUBBLE); | |
| 455 | |
| 456 should_show_reset_banner_ = false; | |
| 457 | |
| 458 ReportPromptResult(PROMPT_ACTION_NO_RESET); | |
| 459 delegate_->DismissPrompt(); | |
| 460 FinishResetPromptFlow(); | |
| 461 } | |
| 462 | |
| 463 bool AutomaticProfileResetter::IsResetPromptFlowActive() const { | |
| 464 return state_ == STATE_HAS_TRIGGERED_PROMPT || | |
| 465 state_ == STATE_HAS_SHOWN_BUBBLE; | |
| 466 } | |
| 467 | |
| 468 bool AutomaticProfileResetter::ShouldShowResetBanner() const { | |
| 469 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 470 return should_show_reset_banner_ && ShouldPerformLiveRun(); | |
| 471 } | |
| 472 | |
| 473 void AutomaticProfileResetter::NotifyDidShowResetBubble() { | |
| 474 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 475 DCHECK_EQ(state_, STATE_HAS_TRIGGERED_PROMPT); | |
| 476 | |
| 477 state_ = STATE_HAS_SHOWN_BUBBLE; | |
| 478 | |
| 479 PersistMementos(); | |
| 480 ReportPromptResult(PROMPT_SHOWN_BUBBLE); | |
| 481 } | |
| 482 | |
| 483 void AutomaticProfileResetter::NotifyDidOpenWebUIResetDialog() { | |
| 484 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 485 | |
| 486 // This notification is invoked unconditionally by the WebUI, only care about | |
| 487 // it when the prompt flow is currently active (and not yet resetting). | |
| 488 if (state_ == STATE_HAS_TRIGGERED_PROMPT || | |
| 489 state_ == STATE_HAS_SHOWN_BUBBLE) { | |
| 490 has_already_dismissed_prompt_ = true; | |
| 491 delegate_->DismissPrompt(); | |
| 492 } | |
| 493 } | |
| 494 | |
| 495 void AutomaticProfileResetter::NotifyDidCloseWebUIResetDialog( | |
| 496 bool performed_reset) { | |
| 497 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 498 | |
| 499 // This notification is invoked unconditionally by the WebUI, only care about | |
| 500 // it when the prompt flow is currently active (and not yet resetting). | |
| 501 if (state_ == STATE_HAS_TRIGGERED_PROMPT || | |
| 502 state_ == STATE_HAS_SHOWN_BUBBLE) { | |
| 503 if (!has_already_dismissed_prompt_) | |
| 504 delegate_->DismissPrompt(); | |
| 505 if (state_ == STATE_HAS_TRIGGERED_PROMPT) { | |
| 506 PersistMementos(); | |
| 507 ReportPromptResult(performed_reset ? | |
| 508 PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_RESET : | |
| 509 PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_NO_RESET); | |
| 510 } else { // if (state_ == STATE_HAS_SHOWN_PROMPT) | |
| 511 ReportPromptResult(performed_reset ? | |
| 512 PROMPT_FOLLOWED_BY_WEBUI_RESET : | |
| 513 PROMPT_FOLLOWED_BY_WEBUI_NO_RESET); | |
| 514 } | |
| 515 FinishResetPromptFlow(); | |
| 516 } | |
| 517 } | |
| 518 | |
| 519 void AutomaticProfileResetter::NotifyDidCloseWebUIResetBanner() { | |
| 520 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 521 should_show_reset_banner_ = false; | |
| 522 } | |
| 523 | |
| 524 void AutomaticProfileResetter::SetProgramForTesting( | |
| 525 const std::string& program) { | |
| 526 program_ = program; | |
| 527 } | |
| 528 | |
| 529 void AutomaticProfileResetter::SetHashSeedForTesting( | |
| 530 const std::string& hash_key) { | |
| 531 hash_seed_ = hash_key; | |
| 532 } | |
| 533 | |
| 534 void AutomaticProfileResetter::SetDelegateForTesting( | |
| 535 scoped_ptr<AutomaticProfileResetterDelegate> delegate) { | |
| 536 delegate_ = delegate.Pass(); | |
| 537 } | |
| 538 | |
| 539 void AutomaticProfileResetter::SetTaskRunnerForWaitingForTesting( | |
| 540 const scoped_refptr<base::TaskRunner>& task_runner) { | |
| 541 task_runner_for_waiting_ = task_runner; | |
| 542 } | |
| 543 | |
| 544 void AutomaticProfileResetter::Shutdown() { | |
| 545 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 546 | |
| 547 // We better not do anything substantial at this point. The metrics service | |
| 548 // has already been shut down; and local state has already been commited to | |
| 549 // file (in the regular fashion) for the last time. | |
| 550 | |
| 551 state_ = STATE_DISABLED; | |
| 552 | |
| 553 weak_ptr_factory_.InvalidateWeakPtrs(); | |
| 554 delegate_.reset(); | |
| 555 } | |
| 556 | |
| 557 void AutomaticProfileResetter::PrepareEvaluationFlow() { | |
| 558 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 559 DCHECK_EQ(state_, STATE_INITIALIZED); | |
| 560 | |
| 561 state_ = STATE_WAITING_ON_DEPENDENCIES; | |
| 562 | |
| 563 delegate_->RequestCallbackWhenTemplateURLServiceIsLoaded( | |
| 564 base::Bind(&AutomaticProfileResetter::OnTemplateURLServiceIsLoaded, | |
| 565 weak_ptr_factory_.GetWeakPtr())); | |
| 566 delegate_->RequestCallbackWhenLoadedModulesAreEnumerated( | |
| 567 base::Bind(&AutomaticProfileResetter::OnLoadedModulesAreEnumerated, | |
| 568 weak_ptr_factory_.GetWeakPtr())); | |
| 569 delegate_->LoadTemplateURLServiceIfNeeded(); | |
| 570 delegate_->EnumerateLoadedModulesIfNeeded(); | |
| 571 } | |
| 572 | |
| 573 void AutomaticProfileResetter::OnTemplateURLServiceIsLoaded() { | |
| 574 template_url_service_ready_ = true; | |
| 575 OnDependencyIsReady(); | |
| 576 } | |
| 577 | |
| 578 void AutomaticProfileResetter::OnLoadedModulesAreEnumerated() { | |
| 579 enumeration_of_loaded_modules_ready_ = true; | |
| 580 OnDependencyIsReady(); | |
| 581 } | |
| 582 | |
| 583 void AutomaticProfileResetter::OnDependencyIsReady() { | |
| 584 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 585 DCHECK_EQ(state_, STATE_WAITING_ON_DEPENDENCIES); | |
| 586 | |
| 587 if (template_url_service_ready_ && enumeration_of_loaded_modules_ready_) { | |
| 588 state_ = STATE_READY; | |
| 589 content::BrowserThread::PostTask( | |
| 590 content::BrowserThread::UI, | |
| 591 FROM_HERE, | |
| 592 base::Bind(&AutomaticProfileResetter::BeginEvaluationFlow, | |
| 593 weak_ptr_factory_.GetWeakPtr())); | |
| 594 } | |
| 595 } | |
| 596 | |
| 597 void AutomaticProfileResetter::BeginEvaluationFlow() { | |
| 598 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 599 DCHECK_EQ(state_, STATE_READY); | |
| 600 DCHECK(!program_.empty()); | |
| 601 DCHECK(!input_builder_); | |
| 602 | |
| 603 state_ = STATE_EVALUATING_CONDITIONS; | |
| 604 | |
| 605 input_builder_.reset(new InputBuilder(profile_, delegate_.get())); | |
| 606 input_builder_->BuildEvaluatorProgramInput( | |
| 607 base::Bind(&AutomaticProfileResetter::ContinueWithEvaluationFlow, | |
| 608 weak_ptr_factory_.GetWeakPtr())); | |
| 609 } | |
| 610 | |
| 611 void AutomaticProfileResetter::ContinueWithEvaluationFlow( | |
| 612 scoped_ptr<base::DictionaryValue> program_input) { | |
| 613 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 614 DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS); | |
| 615 | |
| 616 input_builder_.reset(); | |
| 617 | |
| 618 base::SequencedWorkerPool* blocking_pool = | |
| 619 content::BrowserThread::GetBlockingPool(); | |
| 620 scoped_refptr<base::TaskRunner> task_runner = | |
| 621 blocking_pool->GetTaskRunnerWithShutdownBehavior( | |
| 622 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); | |
| 623 | |
| 624 base::PostTaskAndReplyWithResult( | |
| 625 task_runner.get(), | |
| 626 FROM_HERE, | |
| 627 base::Bind(&EvaluateConditionsOnWorkerPoolThread, | |
| 628 hash_seed_, | |
| 629 program_, | |
| 630 base::Passed(&program_input)), | |
| 631 base::Bind(&AutomaticProfileResetter::FinishEvaluationFlow, | |
| 632 weak_ptr_factory_.GetWeakPtr())); | |
| 633 } | |
| 634 | |
| 635 // static | |
| 636 scoped_ptr<AutomaticProfileResetter::EvaluationResults> | |
| 637 AutomaticProfileResetter::EvaluateConditionsOnWorkerPoolThread( | |
| 638 const std::string& hash_seed, | |
| 639 const std::string& program, | |
| 640 scoped_ptr<base::DictionaryValue> program_input) { | |
| 641 JtlInterpreter interpreter(hash_seed, program, program_input.get()); | |
| 642 interpreter.Execute(); | |
| 643 UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.InterpreterResult", | |
| 644 interpreter.result(), | |
| 645 JtlInterpreter::RESULT_MAX); | |
| 646 UMA_HISTOGRAM_SPARSE_SLOWLY("AutomaticProfileReset.ProgramChecksum", | |
| 647 interpreter.CalculateProgramChecksum()); | |
| 648 | |
| 649 // In each case below, the respective field in result originally contains the | |
| 650 // default, so if the getter fails, we still have the correct value there. | |
| 651 scoped_ptr<EvaluationResults> results(new EvaluationResults); | |
| 652 interpreter.GetOutputBoolean(kShouldPromptKey, &results->should_prompt); | |
| 653 interpreter.GetOutputBoolean(kHadPromptedAlreadyKey, | |
| 654 &results->had_prompted_already); | |
| 655 interpreter.GetOutputString(kMementoValueInPrefsKey, | |
| 656 &results->memento_value_in_prefs); | |
| 657 interpreter.GetOutputString(kMementoValueInLocalStateKey, | |
| 658 &results->memento_value_in_local_state); | |
| 659 interpreter.GetOutputString(kMementoValueInFileKey, | |
| 660 &results->memento_value_in_file); | |
| 661 for (size_t i = 0; i < kCombinedStatusMaskNumberOfBits; ++i) { | |
| 662 bool flag = false; | |
| 663 std::string mask_i_th_bit_key = | |
| 664 kCombinedStatusMaskKeyPrefix + base::IntToString(i + 1); | |
| 665 if (interpreter.GetOutputBoolean(mask_i_th_bit_key, &flag) && flag) | |
| 666 results->combined_status_mask |= (1 << i); | |
| 667 } | |
| 668 for (size_t i = 0; i < kSatisfiedCriteriaMaskNumberOfBits; ++i) { | |
| 669 bool flag = false; | |
| 670 std::string mask_i_th_bit_key = | |
| 671 kSatisfiedCriteriaMaskKeyPrefix + base::IntToString(i + 1); | |
| 672 if (interpreter.GetOutputBoolean(mask_i_th_bit_key, &flag) && flag) | |
| 673 results->satisfied_criteria_mask |= (1 << i); | |
| 674 } | |
| 675 return results.Pass(); | |
| 676 } | |
| 677 | |
| 678 void AutomaticProfileResetter::ReportStatistics(uint32 satisfied_criteria_mask, | |
| 679 uint32 combined_status_mask) { | |
| 680 UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.SatisfiedCriteriaMask", | |
| 681 satisfied_criteria_mask, | |
| 682 kSatisfiedCriteriaMaskMaximumValue); | |
| 683 UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.CombinedStatusMask", | |
| 684 combined_status_mask, | |
| 685 kCombinedStatusMaskMaximumValue); | |
| 686 } | |
| 687 | |
| 688 void AutomaticProfileResetter::FinishEvaluationFlow( | |
| 689 scoped_ptr<EvaluationResults> results) { | |
| 690 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 691 DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS); | |
| 692 | |
| 693 ReportStatistics(results->satisfied_criteria_mask, | |
| 694 results->combined_status_mask); | |
| 695 | |
| 696 if (results->should_prompt) | |
| 697 should_show_reset_banner_ = true; | |
| 698 | |
| 699 if (results->should_prompt && !results->had_prompted_already) { | |
| 700 evaluation_results_ = results.Pass(); | |
| 701 BeginResetPromptFlow(); | |
| 702 } else { | |
| 703 state_ = STATE_DONE; | |
| 704 } | |
| 705 } | |
| 706 | |
| 707 void AutomaticProfileResetter::BeginResetPromptFlow() { | |
| 708 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 709 DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS); | |
| 710 | |
| 711 state_ = STATE_HAS_TRIGGERED_PROMPT; | |
| 712 | |
| 713 if (ShouldPerformLiveRun() && delegate_->TriggerPrompt()) { | |
| 714 // Start fetching the brandcoded default settings speculatively in the | |
| 715 // background, so as to reduce waiting time if the user chooses to go | |
| 716 // through with the reset. | |
| 717 delegate_->FetchBrandcodedDefaultSettingsIfNeeded(); | |
| 718 } else { | |
| 719 PersistMementos(); | |
| 720 ReportPromptResult(PROMPT_NOT_TRIGGERED); | |
| 721 FinishResetPromptFlow(); | |
| 722 } | |
| 723 } | |
| 724 | |
| 725 void AutomaticProfileResetter::OnProfileSettingsResetCompleted() { | |
| 726 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 727 DCHECK_EQ(state_, STATE_PERFORMING_RESET); | |
| 728 | |
| 729 delegate_->DismissPrompt(); | |
| 730 FinishResetPromptFlow(); | |
| 731 } | |
| 732 | |
| 733 void AutomaticProfileResetter::ReportPromptResult(PromptResult result) { | |
| 734 UMA_HISTOGRAM_ENUMERATION( | |
| 735 "AutomaticProfileReset.PromptResult", result, PROMPT_RESULT_MAX); | |
| 736 } | |
| 737 | |
| 738 void AutomaticProfileResetter::PersistMementos() { | |
| 739 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 740 DCHECK(state_ == STATE_HAS_TRIGGERED_PROMPT || | |
| 741 state_ == STATE_HAS_SHOWN_BUBBLE); | |
| 742 DCHECK(evaluation_results_); | |
| 743 | |
| 744 PreferenceHostedPromptMemento memento_in_prefs(profile_); | |
| 745 LocalStateHostedPromptMemento memento_in_local_state(profile_); | |
| 746 FileHostedPromptMemento memento_in_file(profile_); | |
| 747 | |
| 748 memento_in_prefs.StoreValue(evaluation_results_->memento_value_in_prefs); | |
| 749 memento_in_local_state.StoreValue( | |
| 750 evaluation_results_->memento_value_in_local_state); | |
| 751 memento_in_file.StoreValue(evaluation_results_->memento_value_in_file); | |
| 752 | |
| 753 evaluation_results_.reset(); | |
| 754 } | |
| 755 | |
| 756 void AutomaticProfileResetter::FinishResetPromptFlow() { | |
| 757 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 758 DCHECK(state_ == STATE_HAS_TRIGGERED_PROMPT || | |
| 759 state_ == STATE_HAS_SHOWN_BUBBLE || | |
| 760 state_ == STATE_PERFORMING_RESET); | |
| 761 DCHECK(!evaluation_results_); | |
| 762 | |
| 763 state_ = STATE_DONE; | |
| 764 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 271673006:
Eliminate all code related to the AutomaticProfileResetter. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src