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
|
// Copyright (c) 2015 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_STATUS_UPLOADER_H_
#define CHROME_BROWSER_CHROMEOS_POLICY_STATUS_UPLOADER_H_
#include "base/cancelable_callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "chrome/browser/chromeos/settings/cros_settings.h"
#include "chrome/browser/media/media_capture_devices_dispatcher.h"
#include "components/policy/core/common/cloud/cloud_policy_constants.h"
#include "policy/proto/device_management_backend.pb.h"
namespace base {
class SequencedTaskRunner;
}
namespace policy {
class CloudPolicyClient;
class DeviceStatusCollector;
// Class responsible for periodically uploading device status from the
// passed DeviceStatusCollector.
class StatusUploader : public MediaCaptureDevicesDispatcher::Observer {
public:
// Refresh constants.
static const int64 kDefaultUploadDelayMs;
// Constructor. |client| must be registered and must stay
// valid and registered through the lifetime of this StatusUploader
// object.
StatusUploader(
CloudPolicyClient* client,
scoped_ptr<DeviceStatusCollector> collector,
const scoped_refptr<base::SequencedTaskRunner>& task_runner);
~StatusUploader() override;
// Returns the time of the last successful upload, or Time(0) if no upload
// has ever happened.
base::Time last_upload() const { return last_upload_; }
// Returns true if session data upload (screenshots, logs, etc) is allowed.
// This checks to ensure that the current session is a kiosk session, and
// that no user input (keyboard, mouse, touch, audio/video) has been received.
bool IsSessionDataUploadAllowed();
// MediaCaptureDevicesDispatcher::Observer implementation
void OnRequestUpdate(int render_process_id,
int render_frame_id,
content::MediaStreamType stream_type,
const content::MediaRequestState state) override;
private:
// Callback invoked periodically to upload the device status from the
// DeviceStatusCollector.
void UploadStatus();
// Invoked once a status upload has completed.
void OnUploadCompleted(bool success);
// Helper method that figures out when the next status upload should
// be scheduled.
void ScheduleNextStatusUpload();
// Updates the upload frequency from settings and schedules a new upload
// if appropriate.
void RefreshUploadFrequency();
// CloudPolicyClient used to issue requests to the server.
CloudPolicyClient* client_;
// DeviceStatusCollector that provides status for uploading.
scoped_ptr<DeviceStatusCollector> collector_;
// TaskRunner used for scheduling upload tasks.
const scoped_refptr<base::SequencedTaskRunner> task_runner_;
// How long to wait between status uploads.
base::TimeDelta upload_frequency_;
// Observer to changes in the upload frequency.
scoped_ptr<chromeos::CrosSettings::ObserverSubscription>
upload_frequency_observer_;
// The time the last upload was performed.
base::Time last_upload_;
// Callback invoked via a delay to upload device status.
base::CancelableClosure upload_callback_;
// True if there has been any captured media in this session.
bool has_captured_media_;
// Note: This should remain the last member so it'll be destroyed and
// invalidate the weak pointers before any other members are destroyed.
base::WeakPtrFactory<StatusUploader> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(StatusUploader);
};
} // namespace policy
#endif // CHROME_BROWSER_CHROMEOS_POLICY_STATUS_UPLOADER_H_
|
