blob: 9f4e39aa2f33753b1fe28da2e9074c4b762de438 [file] [log] [blame]
// 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.
#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 Profile;
class RenderProcessHost;
// 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 {
typedef base::Callback<void(bool, const std::string&)> GenericDoneCallback;
typedef base::Callback<void(bool, const std::string&, const std::string&)>
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 std::map<std::string, std::string>& 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;
// 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 OnLoggingStoppedInRenderer();
void StartLoggingIfAllowed();
void DoStartLogging();
void LogMachineInfo();
void NotifyLoggingStarted();
void TriggerUploadLog();
void FireGenericDoneCallback(GenericDoneCallback* callback,
bool success,
const std::string& error_message);
scoped_refptr<net::URLRequestContextGetter> system_request_context_;
scoped_ptr<base::SharedMemory> shared_memory_;
// 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.
std::map<std::string, std::string> 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_;