1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// Copyright (c) 2010 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.
#ifndef CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_
#define CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_
#pragma once
#include <string>
#include "base/basictypes.h"
#include "chrome/installer/util/util_constants.h"
namespace installer {
class ChannelInfo;
class InstallerState;
}
// This class provides accessors to the Google Update 'ClientState' information
// that recorded when the user downloads the chrome installer. It is
// google_update.exe responsability to write the initial values.
class GoogleUpdateSettings {
public:
// Returns whether the user has given consent to collect UMA data and send
// crash dumps to Google. This information is collected by the web server
// used to download the chrome installer.
static bool GetCollectStatsConsent();
// Sets the user consent to send UMA and crash dumps to Google. Returns
// false if the setting could not be recorded.
static bool SetCollectStatsConsent(bool consented);
// Returns the metrics id set in the registry (that can be used in crash
// reports). If none found, returns empty string.
static bool GetMetricsId(std::wstring* metrics_id);
// Sets the metrics id to be used in crash reports.
static bool SetMetricsId(const std::wstring& metrics_id);
// Sets the machine-wide EULA consented flag required on OEM installs.
// Returns false if the setting could not be recorded.
static bool SetEULAConsent(const installer::InstallerState& installer_state,
bool consented);
// Returns the last time chrome was run in days. It uses a recorded value
// set by SetLastRunTime(). Returns -1 if the value was not found or if
// the value is corrupted.
static int GetLastRunTime();
// Stores the time that this function was last called using an encoded
// form of the system local time. Retrieve the time using GetLastRunTime().
// Returns false if the value could not be stored.
static bool SetLastRunTime();
// Removes the storage used by SetLastRunTime() and SetLastRunTime(). Returns
// false if the operation failed. Returns true if the storage was freed or
// if it never existed in the first place.
static bool RemoveLastRunTime();
// Returns in |browser| the browser used to download chrome as recorded
// Google Update. Returns false if the information is not available.
static bool GetBrowser(std::wstring* browser);
// Returns in |language| the language selected by the user when downloading
// chrome. This information is collected by the web server used to download
// the chrome installer. Returns false if the information is not available.
static bool GetLanguage(std::wstring* language);
// Returns in |brand| the RLZ brand code or distribution tag that has been
// assigned to a partner. Returns false if the information is not available.
static bool GetBrand(std::wstring* brand);
// Returns in |client| the google_update client field, which is currently
// used to track experiments. Returns false if the entry does not exist.
static bool GetClient(std::wstring* client);
// Sets the google_update client field. Unlike GetClient() this is set only
// for the current user. Returns false if the operation failed.
static bool SetClient(const std::wstring& client);
// Returns in 'client' the RLZ referral available for some distribution
// partners. This value does not exist for most chrome or chromium installs.
static bool GetReferral(std::wstring* referral);
// Overwrites the current value of the referral with an empty string. Returns
// true if this operation succeeded.
static bool ClearReferral();
// Return a human readable modifier for the version string, e.g.
// the channel (dev, beta, stable). Returns true if this operation succeeded,
// on success, channel contains one of "", "unknown", "dev" or "beta" (unless
// it is a multi-install product, in which case it will return "m",
// "unknown-m", "dev-m", or "beta-m").
static bool GetChromeChannel(bool system_install, std::wstring* channel);
// This method changes the Google Update "ap" value to move the installation
// on to or off of one of the recovery channels.
// - If incremental installer fails we append a magic string ("-full"), if
// it is not present already, so that Google Update server next time will send
// full installer to update Chrome on the local machine
// - If we are currently running full installer, we remove this magic
// string (if it is present) regardless of whether installer failed or not.
// There is no fall-back for full installer :)
// - Unconditionally remove "-multifail" since we haven't crashed.
// |state_key| should be obtained via InstallerState::state_key().
static void UpdateInstallStatus(bool system_install,
installer::ArchiveType archive_type,
int install_return_code,
const std::wstring& product_guid);
// This method updates the value for Google Update "ap" key for Chrome
// based on whether we are doing incremental install (or not) and whether
// the install succeeded.
// - If install worked, remove the magic string (if present).
// - If incremental installer failed, append a magic string (if
// not present already).
// - If full installer failed, still remove this magic
// string (if it is present already).
//
// archive_type: tells whether this is incremental install or not.
// install_return_code: if 0, means installation was successful.
// value: current value of Google Update "ap" key.
// Returns true if |value| is modified.
static bool UpdateGoogleUpdateApKey(installer::ArchiveType archive_type,
int install_return_code,
installer::ChannelInfo* value);
// For system-level installs, we need to be able to communicate the results
// of the Toast Experiments back to Google Update. The problem is just that
// the experiment is run in the context of the user, which doesn't have
// write access to the HKLM key that Google Update expects the results in.
// However, when we are about to switch contexts from system to user, we can
// duplicate the handle to the registry key and pass it (through handle
// inheritance) to the newly created child process that is launched as the
// user, allowing the child process to write to the key, with the
// WriteGoogleUpdateSystemClientKey function below.
static int DuplicateGoogleUpdateSystemClientKey();
// Takes a |handle| to a registry key and writes |value| string into the
// specified |key|. See DuplicateGoogleUpdateSystemClientKey for details.
static bool WriteGoogleUpdateSystemClientKey(int handle,
const std::wstring& key,
const std::wstring& value);
// True if a build is strictly organic, according to its brand code.
static bool IsOrganic(const std::wstring& brand);
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(GoogleUpdateSettings);
};
#endif // CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_
|
