1 // Copyright (c) 2012 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/metrics/variations/variations_service.h" 6 7 #include <set> 8 9 #include "base/build_time.h" 10 #include "base/command_line.h" 11 #include "base/metrics/histogram.h" 12 #include "base/metrics/sparse_histogram.h" 13 #include "base/prefs/pref_registry_simple.h" 14 #include "base/prefs/pref_service.h" 15 #include "base/sys_info.h" 16 #include "base/task_runner_util.h" 17 #include "base/timer/elapsed_timer.h" 18 #include "base/version.h" 19 #include "chrome/browser/browser_process.h" 20 #include "chrome/browser/metrics/variations/generated_resources_map.h" 21 #include "chrome/common/chrome_switches.h" 22 #include "chrome/common/pref_names.h" 23 #include "components/metrics/metrics_state_manager.h" 24 #include "components/network_time/network_time_tracker.h" 25 #include "components/pref_registry/pref_registry_syncable.h" 26 #include "components/variations/proto/variations_seed.pb.h" 27 #include "components/variations/variations_seed_processor.h" 28 #include "components/variations/variations_seed_simulator.h" 29 #include "content/public/browser/browser_thread.h" 30 #include "net/base/load_flags.h" 31 #include "net/base/net_errors.h" 32 #include "net/base/network_change_notifier.h" 33 #include "net/base/url_util.h" 34 #include "net/http/http_response_headers.h" 35 #include "net/http/http_status_code.h" 36 #include "net/http/http_util.h" 37 #include "net/url_request/url_fetcher.h" 38 #include "net/url_request/url_request_status.h" 39 #include "ui/base/device_form_factor.h" 40 #include "ui/base/resource/resource_bundle.h" 41 #include "url/gurl.h" 42 43 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS) 44 #include "chrome/browser/upgrade_detector_impl.h" 45 #endif 46 47 #if defined(OS_CHROMEOS) 48 #include "chrome/browser/chromeos/settings/cros_settings.h" 49 #endif 50 51 namespace chrome_variations { 52 53 namespace { 54 55 // Default server of Variations seed info. 56 const char kDefaultVariationsServerURL[] = 57 "https://clients4.google.com/chrome-variations/seed"; 58 const int kMaxRetrySeedFetch = 5; 59 60 // TODO(mad): To be removed when we stop updating the NetworkTimeTracker. 61 // For the HTTP date headers, the resolution of the server time is 1 second. 62 const int64 kServerTimeResolutionMs = 1000; 63 64 // Wrapper around channel checking, used to enable channel mocking for 65 // testing. If the current browser channel is not UNKNOWN, this will return 66 // that channel value. Otherwise, if the fake channel flag is provided, this 67 // will return the fake channel. Failing that, this will return the UNKNOWN 68 // channel. 69 variations::Study_Channel GetChannelForVariations() { 70 switch (chrome::VersionInfo::GetChannel()) { 71 case chrome::VersionInfo::CHANNEL_CANARY: 72 return variations::Study_Channel_CANARY; 73 case chrome::VersionInfo::CHANNEL_DEV: 74 return variations::Study_Channel_DEV; 75 case chrome::VersionInfo::CHANNEL_BETA: 76 return variations::Study_Channel_BETA; 77 case chrome::VersionInfo::CHANNEL_STABLE: 78 return variations::Study_Channel_STABLE; 79 case chrome::VersionInfo::CHANNEL_UNKNOWN: 80 break; 81 } 82 const std::string forced_channel = 83 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 84 switches::kFakeVariationsChannel); 85 if (forced_channel == "stable") 86 return variations::Study_Channel_STABLE; 87 if (forced_channel == "beta") 88 return variations::Study_Channel_BETA; 89 if (forced_channel == "dev") 90 return variations::Study_Channel_DEV; 91 if (forced_channel == "canary") 92 return variations::Study_Channel_CANARY; 93 DVLOG(1) << "Invalid channel provided: " << forced_channel; 94 return variations::Study_Channel_UNKNOWN; 95 } 96 97 // Returns a string that will be used for the value of the 'osname' URL param 98 // to the variations server. 99 std::string GetPlatformString() { 100 #if defined(OS_WIN) 101 return "win"; 102 #elif defined(OS_IOS) 103 return "ios"; 104 #elif defined(OS_MACOSX) 105 return "mac"; 106 #elif defined(OS_CHROMEOS) 107 return "chromeos"; 108 #elif defined(OS_ANDROID) 109 return "android"; 110 #elif defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS) 111 // Default BSD and SOLARIS to Linux to not break those builds, although these 112 // platforms are not officially supported by Chrome. 113 return "linux"; 114 #else 115 #error Unknown platform 116 #endif 117 } 118 119 // Gets the version number to use for variations seed simulation. Must be called 120 // on a thread where IO is allowed. 121 base::Version GetVersionForSimulation() { 122 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS) 123 const base::Version installed_version = 124 UpgradeDetectorImpl::GetCurrentlyInstalledVersion(); 125 if (installed_version.IsValid()) 126 return installed_version; 127 #endif // !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS) 128 129 // TODO(asvitkine): Get the version that will be used on restart instead of 130 // the current version on Android, iOS and ChromeOS. 131 return base::Version(chrome::VersionInfo().Version()); 132 } 133 134 // Gets the restrict parameter from |policy_pref_service| or from Chrome OS 135 // settings in the case of that platform. 136 std::string GetRestrictParameterPref(PrefService* policy_pref_service) { 137 std::string parameter; 138 #if defined(OS_CHROMEOS) 139 chromeos::CrosSettings::Get()->GetString( 140 chromeos::kVariationsRestrictParameter, ¶meter); 141 #else 142 if (policy_pref_service) { 143 parameter = 144 policy_pref_service->GetString(prefs::kVariationsRestrictParameter); 145 } 146 #endif 147 return parameter; 148 } 149 150 enum ResourceRequestsAllowedState { 151 RESOURCE_REQUESTS_ALLOWED, 152 RESOURCE_REQUESTS_NOT_ALLOWED, 153 RESOURCE_REQUESTS_ALLOWED_NOTIFIED, 154 RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED, 155 RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN, 156 RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED, 157 RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE, 158 }; 159 160 // Records UMA histogram with the current resource requests allowed state. 161 void RecordRequestsAllowedHistogram(ResourceRequestsAllowedState state) { 162 UMA_HISTOGRAM_ENUMERATION("Variations.ResourceRequestsAllowed", state, 163 RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE); 164 } 165 166 // Converts ResourceRequestAllowedNotifier::State to the corresponding 167 // ResourceRequestsAllowedState value. 168 ResourceRequestsAllowedState ResourceRequestStateToHistogramValue( 169 ResourceRequestAllowedNotifier::State state) { 170 switch (state) { 171 case ResourceRequestAllowedNotifier::DISALLOWED_EULA_NOT_ACCEPTED: 172 return RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED; 173 case ResourceRequestAllowedNotifier::DISALLOWED_NETWORK_DOWN: 174 return RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN; 175 case ResourceRequestAllowedNotifier::DISALLOWED_COMMAND_LINE_DISABLED: 176 return RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED; 177 case ResourceRequestAllowedNotifier::ALLOWED: 178 return RESOURCE_REQUESTS_ALLOWED; 179 } 180 NOTREACHED(); 181 return RESOURCE_REQUESTS_NOT_ALLOWED; 182 } 183 184 185 // Gets current form factor and converts it from enum DeviceFormFactor to enum 186 // Study_FormFactor. 187 variations::Study_FormFactor GetCurrentFormFactor() { 188 switch (ui::GetDeviceFormFactor()) { 189 case ui::DEVICE_FORM_FACTOR_PHONE: 190 return variations::Study_FormFactor_PHONE; 191 case ui::DEVICE_FORM_FACTOR_TABLET: 192 return variations::Study_FormFactor_TABLET; 193 case ui::DEVICE_FORM_FACTOR_DESKTOP: 194 return variations::Study_FormFactor_DESKTOP; 195 } 196 NOTREACHED(); 197 return variations::Study_FormFactor_DESKTOP; 198 } 199 200 // Gets the hardware class and returns it as a string. This returns an empty 201 // string if the client is not ChromeOS. 202 std::string GetHardwareClass() { 203 #if defined(OS_CHROMEOS) 204 return base::SysInfo::GetLsbReleaseBoard(); 205 #endif // OS_CHROMEOS 206 return std::string(); 207 } 208 209 // Returns the date that should be used by the VariationsSeedProcessor to do 210 // expiry and start date checks. 211 base::Time GetReferenceDateForExpiryChecks(PrefService* local_state) { 212 const int64 date_value = local_state->GetInt64(prefs::kVariationsSeedDate); 213 const base::Time seed_date = base::Time::FromInternalValue(date_value); 214 const base::Time build_time = base::GetBuildTime(); 215 // Use the build time for date checks if either the seed date is invalid or 216 // the build time is newer than the seed date. 217 base::Time reference_date = seed_date; 218 if (seed_date.is_null() || seed_date < build_time) 219 reference_date = build_time; 220 return reference_date; 221 } 222 223 // Overrides the string resource sepecified by |hash| with |string| in the 224 // resource bundle. Used as a callback passed to the variations seed processor. 225 void OverrideUIString(uint32_t hash, const base::string16& string) { 226 int resource_id = GetResourceIndex(hash); 227 if (resource_id == -1) 228 return; 229 230 ui::ResourceBundle::GetSharedInstance().OverrideLocaleStringResource( 231 resource_id, string); 232 } 233 234 } // namespace 235 236 VariationsService::VariationsService( 237 ResourceRequestAllowedNotifier* notifier, 238 PrefService* local_state, 239 metrics::MetricsStateManager* state_manager) 240 : local_state_(local_state), 241 state_manager_(state_manager), 242 policy_pref_service_(local_state), 243 seed_store_(local_state), 244 create_trials_from_seed_called_(false), 245 initial_request_completed_(false), 246 resource_request_allowed_notifier_(notifier), 247 weak_ptr_factory_(this) { 248 resource_request_allowed_notifier_->Init(this); 249 } 250 251 VariationsService::~VariationsService() { 252 } 253 254 bool VariationsService::CreateTrialsFromSeed() { 255 create_trials_from_seed_called_ = true; 256 257 variations::VariationsSeed seed; 258 if (!seed_store_.LoadSeed(&seed)) 259 return false; 260 261 const chrome::VersionInfo current_version_info; 262 if (!current_version_info.is_valid()) 263 return false; 264 265 const base::Version current_version(current_version_info.Version()); 266 if (!current_version.IsValid()) 267 return false; 268 269 variations::VariationsSeedProcessor().CreateTrialsFromSeed( 270 seed, 271 g_browser_process->GetApplicationLocale(), 272 GetReferenceDateForExpiryChecks(local_state_), 273 current_version, 274 GetChannelForVariations(), 275 GetCurrentFormFactor(), 276 GetHardwareClass(), 277 base::Bind(&OverrideUIString)); 278 279 const base::Time now = base::Time::Now(); 280 281 // Log the "freshness" of the seed that was just used. The freshness is the 282 // time between the last successful seed download and now. 283 const int64 last_fetch_time_internal = 284 local_state_->GetInt64(prefs::kVariationsLastFetchTime); 285 if (last_fetch_time_internal) { 286 const base::TimeDelta delta = 287 now - base::Time::FromInternalValue(last_fetch_time_internal); 288 // Log the value in number of minutes. 289 UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(), 290 1, base::TimeDelta::FromDays(30).InMinutes(), 50); 291 } 292 293 // Log the skew between the seed date and the system clock/build time to 294 // analyze whether either could be used to make old variations seeds expire 295 // after some time. 296 const int64 seed_date_internal = 297 local_state_->GetInt64(prefs::kVariationsSeedDate); 298 if (seed_date_internal) { 299 const base::Time seed_date = 300 base::Time::FromInternalValue(seed_date_internal); 301 const int system_clock_delta_days = (now - seed_date).InDays(); 302 if (system_clock_delta_days < 0) { 303 UMA_HISTOGRAM_COUNTS_100("Variations.SeedDateSkew.SystemClockBehindBy", 304 -system_clock_delta_days); 305 } else { 306 UMA_HISTOGRAM_COUNTS_100("Variations.SeedDateSkew.SystemClockAheadBy", 307 system_clock_delta_days); 308 } 309 310 const int build_time_delta_days = 311 (base::GetBuildTime() - seed_date).InDays(); 312 if (build_time_delta_days < 0) { 313 UMA_HISTOGRAM_COUNTS_100("Variations.SeedDateSkew.BuildTimeBehindBy", 314 -build_time_delta_days); 315 } else { 316 UMA_HISTOGRAM_COUNTS_100("Variations.SeedDateSkew.BuildTimeAheadBy", 317 build_time_delta_days); 318 } 319 } 320 321 return true; 322 } 323 324 void VariationsService::StartRepeatedVariationsSeedFetch() { 325 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 326 327 // Initialize the Variations server URL. 328 variations_server_url_ = GetVariationsServerURL(policy_pref_service_); 329 330 // Check that |CreateTrialsFromSeed| was called, which is necessary to 331 // retrieve the serial number that will be sent to the server. 332 DCHECK(create_trials_from_seed_called_); 333 334 DCHECK(!request_scheduler_.get()); 335 // Note that the act of instantiating the scheduler will start the fetch, if 336 // the scheduler deems appropriate. Using Unretained is fine here since the 337 // lifespan of request_scheduler_ is guaranteed to be shorter than that of 338 // this service. 339 request_scheduler_.reset(VariationsRequestScheduler::Create( 340 base::Bind(&VariationsService::FetchVariationsSeed, 341 base::Unretained(this)), local_state_)); 342 request_scheduler_->Start(); 343 } 344 345 void VariationsService::AddObserver(Observer* observer) { 346 observer_list_.AddObserver(observer); 347 } 348 349 void VariationsService::RemoveObserver(Observer* observer) { 350 observer_list_.RemoveObserver(observer); 351 } 352 353 // TODO(rkaplow): Handle this and the similar event in metrics_service by 354 // observing an 'OnAppEnterForeground' event in RequestScheduler instead of 355 // requiring the frontend code to notify each service individually. Since the 356 // scheduler will handle it directly the VariationService shouldn't need to 357 // know details of this anymore. 358 void VariationsService::OnAppEnterForeground() { 359 request_scheduler_->OnAppEnterForeground(); 360 } 361 362 #if defined(OS_WIN) 363 void VariationsService::StartGoogleUpdateRegistrySync() { 364 registry_syncer_.RequestRegistrySync(); 365 } 366 #endif 367 368 void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) { 369 create_trials_from_seed_called_ = called; 370 } 371 372 // static 373 GURL VariationsService::GetVariationsServerURL( 374 PrefService* policy_pref_service) { 375 std::string server_url_string(CommandLine::ForCurrentProcess()-> 376 GetSwitchValueASCII(switches::kVariationsServerURL)); 377 if (server_url_string.empty()) 378 server_url_string = kDefaultVariationsServerURL; 379 GURL server_url = GURL(server_url_string); 380 381 const std::string restrict_param = 382 GetRestrictParameterPref(policy_pref_service); 383 if (!restrict_param.empty()) { 384 server_url = net::AppendOrReplaceQueryParameter(server_url, 385 "restrict", 386 restrict_param); 387 } 388 389 server_url = net::AppendOrReplaceQueryParameter(server_url, "osname", 390 GetPlatformString()); 391 392 DCHECK(server_url.is_valid()); 393 return server_url; 394 } 395 396 // static 397 std::string VariationsService::GetDefaultVariationsServerURLForTesting() { 398 return kDefaultVariationsServerURL; 399 } 400 401 // static 402 void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) { 403 VariationsSeedStore::RegisterPrefs(registry); 404 registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0); 405 // This preference will only be written by the policy service, which will fill 406 // it according to a value stored in the User Policy. 407 registry->RegisterStringPref(prefs::kVariationsRestrictParameter, 408 std::string()); 409 } 410 411 // static 412 void VariationsService::RegisterProfilePrefs( 413 user_prefs::PrefRegistrySyncable* registry) { 414 // This preference will only be written by the policy service, which will fill 415 // it according to a value stored in the User Policy. 416 registry->RegisterStringPref( 417 prefs::kVariationsRestrictParameter, 418 std::string(), 419 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 420 } 421 422 // static 423 scoped_ptr<VariationsService> VariationsService::Create( 424 PrefService* local_state, 425 metrics::MetricsStateManager* state_manager) { 426 scoped_ptr<VariationsService> result; 427 #if !defined(GOOGLE_CHROME_BUILD) 428 // Unless the URL was provided, unsupported builds should return NULL to 429 // indicate that the service should not be used. 430 if (!CommandLine::ForCurrentProcess()->HasSwitch( 431 switches::kVariationsServerURL)) { 432 DVLOG(1) << "Not creating VariationsService in unofficial build without --" 433 << switches::kVariationsServerURL << " specified."; 434 return result.Pass(); 435 } 436 #endif 437 result.reset(new VariationsService( 438 new ResourceRequestAllowedNotifier, local_state, state_manager)); 439 return result.Pass(); 440 } 441 442 void VariationsService::DoActualFetch() { 443 pending_seed_request_.reset(net::URLFetcher::Create( 444 0, variations_server_url_, net::URLFetcher::GET, this)); 445 pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES | 446 net::LOAD_DO_NOT_SAVE_COOKIES); 447 pending_seed_request_->SetRequestContext( 448 g_browser_process->system_request_context()); 449 pending_seed_request_->SetMaxRetriesOn5xx(kMaxRetrySeedFetch); 450 if (!seed_store_.variations_serial_number().empty()) { 451 pending_seed_request_->AddExtraRequestHeader( 452 "If-Match:" + seed_store_.variations_serial_number()); 453 } 454 pending_seed_request_->Start(); 455 456 const base::TimeTicks now = base::TimeTicks::Now(); 457 base::TimeDelta time_since_last_fetch; 458 // Record a time delta of 0 (default value) if there was no previous fetch. 459 if (!last_request_started_time_.is_null()) 460 time_since_last_fetch = now - last_request_started_time_; 461 UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt", 462 time_since_last_fetch.InMinutes(), 0, 463 base::TimeDelta::FromDays(7).InMinutes(), 50); 464 last_request_started_time_ = now; 465 } 466 467 void VariationsService::StoreSeed(const std::string& seed_data, 468 const std::string& seed_signature, 469 const base::Time& date_fetched) { 470 scoped_ptr<variations::VariationsSeed> seed(new variations::VariationsSeed); 471 if (!seed_store_.StoreSeedData(seed_data, seed_signature, date_fetched, 472 seed.get())) { 473 return; 474 } 475 RecordLastFetchTime(); 476 477 // Perform seed simulation only if |state_manager_| is not-NULL. The state 478 // manager may be NULL for some unit tests. 479 if (!state_manager_) 480 return; 481 482 base::PostTaskAndReplyWithResult( 483 content::BrowserThread::GetBlockingPool(), 484 FROM_HERE, 485 base::Bind(&GetVersionForSimulation), 486 base::Bind(&VariationsService::PerformSimulationWithVersion, 487 weak_ptr_factory_.GetWeakPtr(), base::Passed(&seed))); 488 } 489 490 void VariationsService::FetchVariationsSeed() { 491 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 492 493 const ResourceRequestAllowedNotifier::State state = 494 resource_request_allowed_notifier_->GetResourceRequestsAllowedState(); 495 RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state)); 496 if (state != ResourceRequestAllowedNotifier::ALLOWED) { 497 DVLOG(1) << "Resource requests were not allowed. Waiting for notification."; 498 return; 499 } 500 501 DoActualFetch(); 502 } 503 504 void VariationsService::NotifyObservers( 505 const variations::VariationsSeedSimulator::Result& result) { 506 if (result.kill_critical_group_change_count > 0) { 507 FOR_EACH_OBSERVER(Observer, observer_list_, 508 OnExperimentChangesDetected(Observer::CRITICAL)); 509 } else if (result.kill_best_effort_group_change_count > 0) { 510 FOR_EACH_OBSERVER(Observer, observer_list_, 511 OnExperimentChangesDetected(Observer::BEST_EFFORT)); 512 } 513 } 514 515 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) { 516 DCHECK_EQ(pending_seed_request_.get(), source); 517 518 const bool is_first_request = !initial_request_completed_; 519 initial_request_completed_ = true; 520 521 // The fetcher will be deleted when the request is handled. 522 scoped_ptr<const net::URLFetcher> request(pending_seed_request_.release()); 523 const net::URLRequestStatus& request_status = request->GetStatus(); 524 if (request_status.status() != net::URLRequestStatus::SUCCESS) { 525 UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode", 526 -request_status.error()); 527 DVLOG(1) << "Variations server request failed with error: " 528 << request_status.error() << ": " 529 << net::ErrorToString(request_status.error()); 530 // It's common for the very first fetch attempt to fail (e.g. the network 531 // may not yet be available). In such a case, try again soon, rather than 532 // waiting the full time interval. 533 if (is_first_request) 534 request_scheduler_->ScheduleFetchShortly(); 535 return; 536 } 537 538 // Log the response code. 539 const int response_code = request->GetResponseCode(); 540 UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.SeedFetchResponseCode", 541 response_code); 542 543 const base::TimeDelta latency = 544 base::TimeTicks::Now() - last_request_started_time_; 545 546 base::Time response_date; 547 if (response_code == net::HTTP_OK || 548 response_code == net::HTTP_NOT_MODIFIED) { 549 bool success = request->GetResponseHeaders()->GetDateValue(&response_date); 550 DCHECK(success || response_date.is_null()); 551 552 if (!response_date.is_null()) { 553 g_browser_process->network_time_tracker()->UpdateNetworkTime( 554 response_date, 555 base::TimeDelta::FromMilliseconds(kServerTimeResolutionMs), 556 latency, 557 base::TimeTicks::Now()); 558 } 559 } 560 561 if (response_code != net::HTTP_OK) { 562 DVLOG(1) << "Variations server request returned non-HTTP_OK response code: " 563 << response_code; 564 if (response_code == net::HTTP_NOT_MODIFIED) { 565 RecordLastFetchTime(); 566 // Update the seed date value in local state (used for expiry check on 567 // next start up), since 304 is a successful response. 568 seed_store_.UpdateSeedDateAndLogDayChange(response_date); 569 } 570 return; 571 } 572 573 std::string seed_data; 574 bool success = request->GetResponseAsString(&seed_data); 575 DCHECK(success); 576 577 std::string seed_signature; 578 request->GetResponseHeaders()->EnumerateHeader(NULL, 579 "X-Seed-Signature", 580 &seed_signature); 581 StoreSeed(seed_data, seed_signature, response_date); 582 } 583 584 void VariationsService::OnResourceRequestsAllowed() { 585 // Note that this only attempts to fetch the seed at most once per period 586 // (kSeedFetchPeriodHours). This works because 587 // |resource_request_allowed_notifier_| only calls this method if an 588 // attempt was made earlier that fails (which implies that the period had 589 // elapsed). After a successful attempt is made, the notifier will know not 590 // to call this method again until another failed attempt occurs. 591 RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED); 592 DVLOG(1) << "Retrying fetch."; 593 DoActualFetch(); 594 595 // This service must have created a scheduler in order for this to be called. 596 DCHECK(request_scheduler_.get()); 597 request_scheduler_->Reset(); 598 } 599 600 void VariationsService::PerformSimulationWithVersion( 601 scoped_ptr<variations::VariationsSeed> seed, 602 const base::Version& version) { 603 if (!version.IsValid()) 604 return; 605 606 const base::ElapsedTimer timer; 607 608 scoped_ptr<const base::FieldTrial::EntropyProvider> entropy_provider = 609 state_manager_->CreateEntropyProvider(); 610 variations::VariationsSeedSimulator seed_simulator(*entropy_provider); 611 612 const variations::VariationsSeedSimulator::Result result = 613 seed_simulator.SimulateSeedStudies( 614 *seed, g_browser_process->GetApplicationLocale(), 615 GetReferenceDateForExpiryChecks(local_state_), version, 616 GetChannelForVariations(), GetCurrentFormFactor(), 617 GetHardwareClass()); 618 619 UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.NormalChanges", 620 result.normal_group_change_count); 621 UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillBestEffortChanges", 622 result.kill_best_effort_group_change_count); 623 UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillCriticalChanges", 624 result.kill_critical_group_change_count); 625 626 UMA_HISTOGRAM_TIMES("Variations.SimulateSeed.Duration", timer.Elapsed()); 627 628 NotifyObservers(result); 629 } 630 631 void VariationsService::RecordLastFetchTime() { 632 // local_state_ is NULL in tests, so check it first. 633 if (local_state_) { 634 local_state_->SetInt64(prefs::kVariationsLastFetchTime, 635 base::Time::Now().ToInternalValue()); 636 } 637 } 638 639 } // namespace chrome_variations 640