variations_service.cc revision 010d83a9304c5a91596085d917d248abff47903a
1558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// Use of this source code is governed by a BSD-style license that can be 3558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// found in the LICENSE file. 4558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch 5558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "chrome/browser/metrics/variations/variations_service.h" 6558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch 7ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include <set> 8ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 9558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "base/build_time.h" 10424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#include "base/command_line.h" 11558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "base/metrics/histogram.h" 12ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include "base/metrics/sparse_histogram.h" 13424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#include "base/prefs/pref_registry_simple.h" 14558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "base/prefs/pref_service.h" 15424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#include "base/sys_info.h" 16558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "base/version.h" 17ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include "chrome/browser/browser_process.h" 18ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include "chrome/browser/network_time/network_time_tracker.h" 19ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include "chrome/common/chrome_switches.h" 20f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles)#include "chrome/common/pref_names.h" 21424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#include "components/user_prefs/pref_registry_syncable.h" 22558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "components/variations/proto/variations_seed.pb.h" 2358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "components/variations/variations_seed_processor.h" 24558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "content/public/browser/browser_thread.h" 25558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/base/load_flags.h" 26558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/base/net_errors.h" 27558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/base/network_change_notifier.h" 28558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/base/url_util.h" 29558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/http/http_response_headers.h" 30558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#include "net/http/http_status_code.h" 3158537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "net/http/http_util.h" 32ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#include "net/url_request/url_fetcher.h" 3358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "net/url_request/url_request_status.h" 3458537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "ui/base/device_form_factor.h" 3558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "url/gurl.h" 3658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) 3758537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#if defined(OS_CHROMEOS) 3858537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#include "chrome/browser/chromeos/settings/cros_settings.h" 3958537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)#endif 4058537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) 4158537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)namespace chrome_variations { 4258537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) 4358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)namespace { 44ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 4558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)// Default server of Variations seed info. 4658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)const char kDefaultVariationsServerURL[] = 47ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch "https://clients4.google.com/chrome-variations/seed"; 48ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdochconst int kMaxRetrySeedFetch = 5; 49424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 50ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// TODO(mad): To be removed when we stop updating the NetworkTimeTracker. 51ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// For the HTTP date headers, the resolution of the server time is 1 second. 52ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdochconst int64 kServerTimeResolutionMs = 1000; 53424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 5458537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)// Wrapper around channel checking, used to enable channel mocking for 55ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// testing. If the current browser channel is not UNKNOWN, this will return 5658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)// that channel value. Otherwise, if the fake channel flag is provided, this 57ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// will return the fake channel. Failing that, this will return the UNKNOWN 5858537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)// channel. 5958537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)Study_Channel GetChannelForVariations() { 600f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) switch (chrome::VersionInfo::GetChannel()) { 610f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) case chrome::VersionInfo::CHANNEL_CANARY: 62558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return Study_Channel_CANARY; 63558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch case chrome::VersionInfo::CHANNEL_DEV: 64558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return Study_Channel_DEV; 65558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch case chrome::VersionInfo::CHANNEL_BETA: 66558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return Study_Channel_BETA; 67558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch case chrome::VersionInfo::CHANNEL_STABLE: 68424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_Channel_STABLE; 69558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch case chrome::VersionInfo::CHANNEL_UNKNOWN: 70558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch break; 71424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 72424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const std::string forced_channel = 73424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 74424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) switches::kFakeVariationsChannel); 75424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (forced_channel == "stable") 76424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_Channel_STABLE; 77424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (forced_channel == "beta") 78424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_Channel_BETA; 79424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (forced_channel == "dev") 80424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_Channel_DEV; 81424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (forced_channel == "canary") 82424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_Channel_CANARY; 83558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DVLOG(1) << "Invalid channel provided: " << forced_channel; 84558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return Study_Channel_UNKNOWN; 85558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch} 86558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch 87558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// Returns a string that will be used for the value of the 'osname' URL param 88558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// to the variations server. 89558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdochstd::string GetPlatformString() { 90558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#if defined(OS_WIN) 91558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return "win"; 92558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#elif defined(OS_IOS) 93558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch return "ios"; 94558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#elif defined(OS_MACOSX) 95424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return "mac"; 96558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#elif defined(OS_CHROMEOS) 97ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return "chromeos"; 98ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#elif defined(OS_ANDROID) 99424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return "android"; 100ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#elif defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS) 101ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch // Default BSD and SOLARIS to Linux to not break those builds, although these 102ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch // platforms are not officially supported by Chrome. 103ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return "linux"; 104ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#else 105558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch#error Unknown platform 106ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#endif 107558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch} 108558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch 109558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// Gets the restrict parameter from |policy_pref_service| or from Chrome OS 110558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch// settings in the case of that platform. 111ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdochstd::string GetRestrictParameterPref(PrefService* policy_pref_service) { 112ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch std::string parameter; 113ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#if defined(OS_CHROMEOS) 114ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch chromeos::CrosSettings::Get()->GetString( 115ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch chromeos::kVariationsRestrictParameter, ¶meter); 116ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#else 117ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch if (policy_pref_service) { 118424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) parameter = 119ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch policy_pref_service->GetString(prefs::kVariationsRestrictParameter); 120ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch } 121ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch#endif 122ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return parameter; 123ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch} 124ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 125ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdochenum ResourceRequestsAllowedState { 126ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_ALLOWED, 127ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_NOT_ALLOWED, 128ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_ALLOWED_NOTIFIED, 129ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED, 130ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN, 131ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED, 132ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE, 133ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch}; 134ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 135ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// Records UMA histogram with the current resource requests allowed state. 136558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdochvoid RecordRequestsAllowedHistogram(ResourceRequestsAllowedState state) { 137558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch UMA_HISTOGRAM_ENUMERATION("Variations.ResourceRequestsAllowed", state, 138ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE); 139ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch} 140ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 141ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// Converts ResourceRequestAllowedNotifier::State to the corresponding 142ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// ResourceRequestsAllowedState value. 143ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben MurdochResourceRequestsAllowedState ResourceRequestStateToHistogramValue( 144ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch ResourceRequestAllowedNotifier::State state) { 145ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch switch (state) { 146ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch case ResourceRequestAllowedNotifier::DISALLOWED_EULA_NOT_ACCEPTED: 147ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED; 148ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch case ResourceRequestAllowedNotifier::DISALLOWED_NETWORK_DOWN: 149424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN; 150ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch case ResourceRequestAllowedNotifier::DISALLOWED_COMMAND_LINE_DISABLED: 151ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED; 152ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch case ResourceRequestAllowedNotifier::ALLOWED: 153ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return RESOURCE_REQUESTS_ALLOWED; 154ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch } 155ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch NOTREACHED(); 156ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return RESOURCE_REQUESTS_NOT_ALLOWED; 157ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch} 158ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 159ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch 160ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// Gets current form factor and converts it from enum DeviceFormFactor to enum 161ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch// Study_FormFactor. 162ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben MurdochStudy_FormFactor GetCurrentFormFactor() { 163ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch switch (ui::GetDeviceFormFactor()) { 164ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch case ui::DEVICE_FORM_FACTOR_PHONE: 165424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_FormFactor_PHONE; 166424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) case ui::DEVICE_FORM_FACTOR_TABLET: 167ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16Ben Murdoch return Study_FormFactor_TABLET; 168424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) case ui::DEVICE_FORM_FACTOR_DESKTOP: 169424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_FormFactor_DESKTOP; 170424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 171424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) NOTREACHED(); 172424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return Study_FormFactor_DESKTOP; 173424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 174424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 175424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Gets the hardware class and returns it as a string. This returns an empty 176424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// string if the client is not ChromeOS. 177424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)std::string GetHardwareClass() { 178424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#if defined(OS_CHROMEOS) 179424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return base::SysInfo::GetLsbReleaseBoard(); 180424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)#endif // OS_CHROMEOS 181424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return std::string(); 182424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 183424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 184424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Returns the date that should be used by the VariationsSeedProcessor to do 185424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// expiry and start date checks. 186424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)base::Time GetReferenceDateForExpiryChecks(PrefService* local_state) { 187424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const int64 date_value = local_state->GetInt64(prefs::kVariationsSeedDate); 188424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const base::Time seed_date = base::Time::FromInternalValue(date_value); 189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const base::Time build_time = base::GetBuildTime(); 190424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Use the build time for date checks if either the seed date is invalid or 191424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // the build time is newer than the seed date. 192424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) base::Time reference_date = seed_date; 193424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (seed_date.is_null() || seed_date < build_time) 194424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) reference_date = build_time; 195424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return reference_date; 196424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 197424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 198424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} // namespace 199424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 200424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)VariationsService::VariationsService(PrefService* local_state) 201424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : local_state_(local_state), 202424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) policy_pref_service_(local_state), 203424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) seed_store_(local_state), 204424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) create_trials_from_seed_called_(false), 205424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) initial_request_completed_(false), 206558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch resource_request_allowed_notifier_( 207558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch new ResourceRequestAllowedNotifier) { 208558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch resource_request_allowed_notifier_->Init(this); 209} 210 211VariationsService::VariationsService(ResourceRequestAllowedNotifier* notifier, 212 PrefService* local_state) 213 : local_state_(local_state), 214 policy_pref_service_(local_state), 215 seed_store_(local_state), 216 create_trials_from_seed_called_(false), 217 initial_request_completed_(false), 218 resource_request_allowed_notifier_(notifier) { 219 resource_request_allowed_notifier_->Init(this); 220} 221 222VariationsService::~VariationsService() { 223} 224 225bool VariationsService::CreateTrialsFromSeed() { 226 create_trials_from_seed_called_ = true; 227 228 VariationsSeed seed; 229 if (!seed_store_.LoadSeed(&seed)) 230 return false; 231 232 const chrome::VersionInfo current_version_info; 233 if (!current_version_info.is_valid()) 234 return false; 235 236 const base::Version current_version(current_version_info.Version()); 237 if (!current_version.IsValid()) 238 return false; 239 240 VariationsSeedProcessor().CreateTrialsFromSeed( 241 seed, g_browser_process->GetApplicationLocale(), 242 GetReferenceDateForExpiryChecks(local_state_), current_version, 243 GetChannelForVariations(), GetCurrentFormFactor(), GetHardwareClass()); 244 245 // Log the "freshness" of the seed that was just used. The freshness is the 246 // time between the last successful seed download and now. 247 const int64 last_fetch_time_internal = 248 local_state_->GetInt64(prefs::kVariationsLastFetchTime); 249 if (last_fetch_time_internal) { 250 const base::Time now = base::Time::Now(); 251 const base::TimeDelta delta = 252 now - base::Time::FromInternalValue(last_fetch_time_internal); 253 // Log the value in number of minutes. 254 UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(), 255 1, base::TimeDelta::FromDays(30).InMinutes(), 50); 256 } 257 258 return true; 259} 260 261void VariationsService::StartRepeatedVariationsSeedFetch() { 262 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 263 264 // Initialize the Variations server URL. 265 variations_server_url_ = GetVariationsServerURL(policy_pref_service_); 266 267 // Check that |CreateTrialsFromSeed| was called, which is necessary to 268 // retrieve the serial number that will be sent to the server. 269 DCHECK(create_trials_from_seed_called_); 270 271 DCHECK(!request_scheduler_.get()); 272 // Note that the act of instantiating the scheduler will start the fetch, if 273 // the scheduler deems appropriate. Using Unretained is fine here since the 274 // lifespan of request_scheduler_ is guaranteed to be shorter than that of 275 // this service. 276 request_scheduler_.reset(VariationsRequestScheduler::Create( 277 base::Bind(&VariationsService::FetchVariationsSeed, 278 base::Unretained(this)), local_state_)); 279 request_scheduler_->Start(); 280} 281 282// TODO(rkaplow): Handle this and the similar event in metrics_service by 283// observing an 'OnAppEnterForeground' event in RequestScheduler instead of 284// requiring the frontend code to notify each service individually. Since the 285// scheduler will handle it directly the VariationService shouldn't need to 286// know details of this anymore. 287void VariationsService::OnAppEnterForeground() { 288 request_scheduler_->OnAppEnterForeground(); 289} 290 291// static 292GURL VariationsService::GetVariationsServerURL( 293 PrefService* policy_pref_service) { 294 std::string server_url_string(CommandLine::ForCurrentProcess()-> 295 GetSwitchValueASCII(switches::kVariationsServerURL)); 296 if (server_url_string.empty()) 297 server_url_string = kDefaultVariationsServerURL; 298 GURL server_url = GURL(server_url_string); 299 300 const std::string restrict_param = 301 GetRestrictParameterPref(policy_pref_service); 302 if (!restrict_param.empty()) { 303 server_url = net::AppendOrReplaceQueryParameter(server_url, 304 "restrict", 305 restrict_param); 306 } 307 308 server_url = net::AppendOrReplaceQueryParameter(server_url, "osname", 309 GetPlatformString()); 310 311 DCHECK(server_url.is_valid()); 312 return server_url; 313} 314 315#if defined(OS_WIN) 316void VariationsService::StartGoogleUpdateRegistrySync() { 317 registry_syncer_.RequestRegistrySync(); 318} 319#endif 320 321void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) { 322 create_trials_from_seed_called_ = called; 323} 324 325// static 326std::string VariationsService::GetDefaultVariationsServerURLForTesting() { 327 return kDefaultVariationsServerURL; 328} 329 330// static 331void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) { 332 VariationsSeedStore::RegisterPrefs(registry); 333 registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0); 334 // This preference will only be written by the policy service, which will fill 335 // it according to a value stored in the User Policy. 336 registry->RegisterStringPref(prefs::kVariationsRestrictParameter, 337 std::string()); 338} 339 340// static 341void VariationsService::RegisterProfilePrefs( 342 user_prefs::PrefRegistrySyncable* registry) { 343 // This preference will only be written by the policy service, which will fill 344 // it according to a value stored in the User Policy. 345 registry->RegisterStringPref( 346 prefs::kVariationsRestrictParameter, 347 std::string(), 348 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 349} 350 351// static 352VariationsService* VariationsService::Create(PrefService* local_state) { 353#if !defined(GOOGLE_CHROME_BUILD) 354 // Unless the URL was provided, unsupported builds should return NULL to 355 // indicate that the service should not be used. 356 if (!CommandLine::ForCurrentProcess()->HasSwitch( 357 switches::kVariationsServerURL)) { 358 DVLOG(1) << "Not creating VariationsService in unofficial build without --" 359 << switches::kVariationsServerURL << " specified."; 360 return NULL; 361 } 362#endif 363 return new VariationsService(local_state); 364} 365 366void VariationsService::DoActualFetch() { 367 pending_seed_request_.reset(net::URLFetcher::Create( 368 0, variations_server_url_, net::URLFetcher::GET, this)); 369 pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES | 370 net::LOAD_DO_NOT_SAVE_COOKIES); 371 pending_seed_request_->SetRequestContext( 372 g_browser_process->system_request_context()); 373 pending_seed_request_->SetMaxRetriesOn5xx(kMaxRetrySeedFetch); 374 if (!seed_store_.variations_serial_number().empty()) { 375 pending_seed_request_->AddExtraRequestHeader( 376 "If-Match:" + seed_store_.variations_serial_number()); 377 } 378 pending_seed_request_->Start(); 379 380 const base::TimeTicks now = base::TimeTicks::Now(); 381 base::TimeDelta time_since_last_fetch; 382 // Record a time delta of 0 (default value) if there was no previous fetch. 383 if (!last_request_started_time_.is_null()) 384 time_since_last_fetch = now - last_request_started_time_; 385 UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt", 386 time_since_last_fetch.InMinutes(), 0, 387 base::TimeDelta::FromDays(7).InMinutes(), 50); 388 last_request_started_time_ = now; 389} 390 391void VariationsService::StoreSeed(const std::string& seed_data, 392 const std::string& seed_signature, 393 const base::Time& date_fetched) { 394 if (!seed_store_.StoreSeedData(seed_data, seed_signature, date_fetched)) 395 return; 396 RecordLastFetchTime(); 397} 398 399void VariationsService::FetchVariationsSeed() { 400 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 401 402 const ResourceRequestAllowedNotifier::State state = 403 resource_request_allowed_notifier_->GetResourceRequestsAllowedState(); 404 RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state)); 405 if (state != ResourceRequestAllowedNotifier::ALLOWED) { 406 DVLOG(1) << "Resource requests were not allowed. Waiting for notification."; 407 return; 408 } 409 410 DoActualFetch(); 411} 412 413void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) { 414 DCHECK_EQ(pending_seed_request_.get(), source); 415 416 const bool is_first_request = !initial_request_completed_; 417 initial_request_completed_ = true; 418 419 // The fetcher will be deleted when the request is handled. 420 scoped_ptr<const net::URLFetcher> request(pending_seed_request_.release()); 421 const net::URLRequestStatus& request_status = request->GetStatus(); 422 if (request_status.status() != net::URLRequestStatus::SUCCESS) { 423 UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode", 424 -request_status.error()); 425 DVLOG(1) << "Variations server request failed with error: " 426 << request_status.error() << ": " 427 << net::ErrorToString(request_status.error()); 428 // It's common for the very first fetch attempt to fail (e.g. the network 429 // may not yet be available). In such a case, try again soon, rather than 430 // waiting the full time interval. 431 if (is_first_request) 432 request_scheduler_->ScheduleFetchShortly(); 433 return; 434 } 435 436 // Log the response code. 437 const int response_code = request->GetResponseCode(); 438 UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.SeedFetchResponseCode", 439 response_code); 440 441 const base::TimeDelta latency = 442 base::TimeTicks::Now() - last_request_started_time_; 443 444 base::Time response_date; 445 if (response_code == net::HTTP_OK || 446 response_code == net::HTTP_NOT_MODIFIED) { 447 bool success = request->GetResponseHeaders()->GetDateValue(&response_date); 448 DCHECK(success || response_date.is_null()); 449 450 if (!response_date.is_null()) { 451 NetworkTimeTracker::BuildNotifierUpdateCallback().Run( 452 response_date, 453 base::TimeDelta::FromMilliseconds(kServerTimeResolutionMs), 454 latency); 455 } 456 } 457 458 if (response_code != net::HTTP_OK) { 459 DVLOG(1) << "Variations server request returned non-HTTP_OK response code: " 460 << response_code; 461 if (response_code == net::HTTP_NOT_MODIFIED) { 462 RecordLastFetchTime(); 463 // Update the seed date value in local state (used for expiry check on 464 // next start up), since 304 is a successful response. 465 seed_store_.UpdateSeedDateAndLogDayChange(response_date); 466 } 467 return; 468 } 469 470 std::string seed_data; 471 bool success = request->GetResponseAsString(&seed_data); 472 DCHECK(success); 473 474 std::string seed_signature; 475 request->GetResponseHeaders()->EnumerateHeader(NULL, 476 "X-Seed-Signature", 477 &seed_signature); 478 StoreSeed(seed_data, seed_signature, response_date); 479} 480 481void VariationsService::OnResourceRequestsAllowed() { 482 // Note that this only attempts to fetch the seed at most once per period 483 // (kSeedFetchPeriodHours). This works because 484 // |resource_request_allowed_notifier_| only calls this method if an 485 // attempt was made earlier that fails (which implies that the period had 486 // elapsed). After a successful attempt is made, the notifier will know not 487 // to call this method again until another failed attempt occurs. 488 RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED); 489 DVLOG(1) << "Retrying fetch."; 490 DoActualFetch(); 491 492 // This service must have created a scheduler in order for this to be called. 493 DCHECK(request_scheduler_.get()); 494 request_scheduler_->Reset(); 495} 496 497void VariationsService::RecordLastFetchTime() { 498 // local_state_ is NULL in tests, so check it first. 499 if (local_state_) { 500 local_state_->SetInt64(prefs::kVariationsLastFetchTime, 501 base::Time::Now().ToInternalValue()); 502 } 503} 504 505} // namespace chrome_variations 506