blob: e2d69815f5bbc106de004b09e19eb72c67aae5b5 (
plain)
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
153
154
155
156
157
158
159
160
161
162
163
|
// Copyright (c) 2012 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_BROWSER_CHROMEOS_POLICY_DEVICE_CLOUD_POLICY_MANAGER_CHROMEOS_H_
#define CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_CLOUD_POLICY_MANAGER_CHROMEOS_H_
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/observer_list.h"
#include "chrome/browser/chromeos/policy/server_backed_state_keys_broker.h"
#include "components/policy/core/common/cloud/cloud_policy_client.h"
#include "components/policy/core/common/cloud/cloud_policy_manager.h"
namespace base {
class SequencedTaskRunner;
}
namespace chromeos {
namespace attestation {
class AttestationPolicyObserver;
}
}
class PrefRegistrySimple;
class PrefService;
namespace policy {
class DeviceCloudPolicyStoreChromeOS;
class EnterpriseInstallAttributes;
class HeartbeatScheduler;
class StatusUploader;
class SystemLogUploader;
// CloudPolicyManager specialization for device policy on Chrome OS.
class DeviceCloudPolicyManagerChromeOS : public CloudPolicyManager {
public:
class Observer {
public:
// Invoked when the device cloud policy manager connects.
virtual void OnDeviceCloudPolicyManagerConnected() = 0;
// Invoked when the device cloud policy manager disconnects.
virtual void OnDeviceCloudPolicyManagerDisconnected() = 0;
};
using UnregisterCallback = base::Callback<void(bool)>;
// |task_runner| is the runner for policy refresh, heartbeat, and status
// upload tasks.
DeviceCloudPolicyManagerChromeOS(
scoped_ptr<DeviceCloudPolicyStoreChromeOS> store,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
ServerBackedStateKeysBroker* state_keys_broker);
~DeviceCloudPolicyManagerChromeOS() override;
// Initializes state keys and requisition information.
void Initialize(PrefService* local_state);
void AddDeviceCloudPolicyManagerObserver(Observer* observer);
void RemoveDeviceCloudPolicyManagerObserver(Observer* observer);
// TODO(davidyu): Move these two functions to a more appropriate place. See
// http://crbug.com/383695.
// Gets/Sets the device requisition.
std::string GetDeviceRequisition() const;
void SetDeviceRequisition(const std::string& requisition);
bool IsRemoraRequisition() const;
bool IsSharkRequisition() const;
// If set, the device will start the enterprise enrollment OOBE.
void SetDeviceEnrollmentAutoStart();
// CloudPolicyManager:
void Shutdown() override;
// Pref registration helper.
static void RegisterPrefs(PrefRegistrySimple* registry);
// Returns the device serial number, or an empty string if not available.
static std::string GetMachineID();
// Returns the machine model, or an empty string if not available.
static std::string GetMachineModel();
// Returns the robot 'email address' associated with the device robot
// account (sometimes called a service account) associated with this device
// during enterprise enrollment.
std::string GetRobotAccountId();
// Starts the connection via |client_to_connect|.
void StartConnection(scoped_ptr<CloudPolicyClient> client_to_connect,
EnterpriseInstallAttributes* install_attributes);
// Sends the unregister request. |callback| is invoked with a boolean
// parameter indicating the result when done.
virtual void Unregister(const UnregisterCallback& callback);
// Disconnects the manager.
virtual void Disconnect();
DeviceCloudPolicyStoreChromeOS* device_store() {
return device_store_.get();
}
// Return the StatusUploader used to communicate device status to the
// policy server.
StatusUploader* GetStatusUploader() const { return status_uploader_.get(); }
private:
// Saves the state keys received from |session_manager_client_|.
void OnStateKeysUpdated();
// Initializes requisition settings at OOBE with values from VPD.
void InitializeRequisition();
void NotifyConnected();
void NotifyDisconnected();
// Factory function to create the StatusUploader.
void CreateStatusUploader();
// Points to the same object as the base CloudPolicyManager::store(), but with
// actual device policy specific type.
scoped_ptr<DeviceCloudPolicyStoreChromeOS> device_store_;
ServerBackedStateKeysBroker* state_keys_broker_;
// Helper object that handles updating the server with our current device
// state.
scoped_ptr<StatusUploader> status_uploader_;
// Helper object that handles uploading system logs to the server.
scoped_ptr<SystemLogUploader> syslog_uploader_;
// Helper object that handles sending heartbeats over the GCM channel to
// the server, to monitor connectivity.
scoped_ptr<HeartbeatScheduler> heartbeat_scheduler_;
// The TaskRunner used to do device status and log uploads.
scoped_refptr<base::SequencedTaskRunner> task_runner_;
ServerBackedStateKeysBroker::Subscription state_keys_update_subscription_;
// PrefService instance to read the policy refresh rate from.
PrefService* local_state_;
scoped_ptr<chromeos::attestation::AttestationPolicyObserver>
attestation_policy_observer_;
base::ObserverList<Observer, true> observers_;
DISALLOW_COPY_AND_ASSIGN(DeviceCloudPolicyManagerChromeOS);
};
} // namespace policy
#endif // CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_CLOUD_POLICY_MANAGER_CHROMEOS_H_
|
