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
|
// Copyright 2013 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_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
#define CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
#include "base/basictypes.h"
#include "base/memory/shared_memory.h"
#include "content/public/browser/browser_message_filter.h"
namespace net {
class URLRequestContextGetter;
} // namespace net
class PartialCircularBuffer;
class Profile;
class RenderProcessHost;
typedef std::map<std::string, std::string> MetaDataMap;
// WebRtcLoggingHandlerHost handles operations regarding the WebRTC logging:
// - Opens a shared memory buffer that the handler in the render process
// writes to.
// - Writes basic machine info to the log.
// - Informs the handler in the render process when to stop logging.
// - Closes the shared memory (and thereby discarding it) or triggers uploading
// of the log.
// - Detects when channel, i.e. renderer, is going away and possibly triggers
// uploading the log.
class WebRtcLoggingHandlerHost : public content::BrowserMessageFilter {
public:
typedef base::Callback<void(bool, const std::string&)> GenericDoneCallback;
typedef base::Callback<void(bool, const std::string&, const std::string&)>
UploadDoneCallback;
explicit WebRtcLoggingHandlerHost(Profile* profile);
// Sets meta data that will be uploaded along with the log and also written
// in the beginning of the log. Must be called on the IO thread before calling
// StartLogging.
void SetMetaData(const MetaDataMap& meta_data,
const GenericDoneCallback& callback);
// Opens a log and starts logging. Must be called on the IO thread.
void StartLogging(const GenericDoneCallback& callback);
// Stops logging. Log will remain open until UploadLog or DiscardLog is
// called. Must be called on the IO thread.
void StopLogging(const GenericDoneCallback& callback);
// Uploads the log and discards the local copy. May only be called after
// logging has stopped. Must be called on the IO thread.
void UploadLog(const UploadDoneCallback& callback);
// Called by WebRtcLogUploader when uploading has finished. Must be called on
// the IO thread.
void UploadLogDone();
// Discards the log. May only be called after logging has stopped. Must be
// called on the IO thread.
void DiscardLog(const GenericDoneCallback& callback);
// May be called on any thread. |upload_log_on_render_close_| is used
// for decision making and it's OK if it changes before the execution based
// on that decision has finished.
void set_upload_log_on_render_close(bool should_upload) {
upload_log_on_render_close_ = should_upload;
}
private:
// States used for protecting from function calls made at non-allowed points
// in time. For example, StartLogging() is only allowed in CLOSED state.
// Transitions: SetMetaData(): CLOSED -> CLOSED.
// StartLogging(): CLOSED -> STARTING.
// Start done: STARTING -> STARTED.
// StopLogging(): STARTED -> STOPPING.
// Stop done: STOPPING -> STOPPED.
// UploadLog(): STOPPED -> UPLOADING.
// Upload done: UPLOADING -> CLOSED.
// DiscardLog(): STOPPED -> CLOSED.
enum LoggingState {
CLOSED, // Logging not started, no log in memory.
STARTING, // Start logging is in progress.
STARTED, // Logging started.
STOPPING, // Stop logging is in progress.
STOPPED, // Logging has been stopped, log still open in memory.
UPLOADING // Uploading log is in progress.
};
friend class content::BrowserThread;
friend class base::DeleteHelper<WebRtcLoggingHandlerHost>;
virtual ~WebRtcLoggingHandlerHost();
// BrowserMessageFilter implementation.
virtual void OnChannelClosing() OVERRIDE;
virtual void OnDestruct() const OVERRIDE;
virtual bool OnMessageReceived(const IPC::Message& message,
bool* message_was_ok) OVERRIDE;
void OnAddLogMessage(const std::string& message);
void OnLoggingStoppedInRenderer();
void StartLoggingIfAllowed();
void DoStartLogging();
void LogMachineInfo();
void NotifyLoggingStarted();
// Writes a formatted log |message| to the |circular_buffer_|.
void LogToCircularBuffer(const std::string& message);
void TriggerUploadLog();
void FireGenericDoneCallback(GenericDoneCallback* callback,
bool success,
const std::string& error_message);
scoped_refptr<net::URLRequestContextGetter> system_request_context_;
scoped_ptr<unsigned char[]> log_buffer_;
scoped_ptr<PartialCircularBuffer> circular_buffer_;
// The profile associated with our renderer process.
Profile* profile_;
// These are only accessed on the IO thread, except when in STARTING state. In
// this state we are protected since entering any function that alters the
// state is not allowed.
MetaDataMap meta_data_;
// These are only accessed on the IO thread.
GenericDoneCallback start_callback_;
GenericDoneCallback stop_callback_;
UploadDoneCallback upload_callback_;
// Only accessed on the IO thread, except when in STARTING, STOPPING or
// UPLOADING state if the action fails and the state must be reset. In these
// states however, we are protected since entering any function that alters
// the state is not allowed.
LoggingState logging_state_;
// Only accessed on the IO thread.
bool upload_log_on_render_close_;
// This is the handle to be passed to the render process. It's stored so that
// it doesn't have to be passed on when posting messages between threads.
// It's only accessed on the IO thread.
base::SharedMemoryHandle foreign_memory_handle_;
DISALLOW_COPY_AND_ASSIGN(WebRtcLoggingHandlerHost);
};
#endif // CHROME_BROWSER_MEDIA_WEBRTC_LOGGING_HANDLER_HOST_H_
|
