blob: a58fecf5741ba03e60f7d9a4987b4c1bc04198d2 (
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
|
// Copyright (c) 2011 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 CONTENT_COMMON_CHILD_THREAD_H_
#define CONTENT_COMMON_CHILD_THREAD_H_
#pragma once
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/shared_memory.h"
#include "content/common/content_export.h"
#include "content/common/message_router.h"
#include "webkit/glue/resource_loader_bridge.h"
class FileSystemDispatcher;
class MessageLoop;
class NotificationService;
class QuotaDispatcher;
class ResourceDispatcher;
class SocketStreamDispatcher;
namespace IPC {
class SyncChannel;
class SyncMessageFilter;
}
// The main thread of a child process derives from this class.
class CONTENT_EXPORT ChildThread : public IPC::Channel::Listener,
public IPC::Message::Sender {
public:
// Creates the thread.
ChildThread();
// Used for single-process mode.
explicit ChildThread(const std::string& channel_name);
virtual ~ChildThread();
// IPC::Message::Sender implementation:
virtual bool Send(IPC::Message* msg);
// See documentation on MessageRouter for AddRoute and RemoveRoute
void AddRoute(int32 routing_id, IPC::Channel::Listener* listener);
void RemoveRoute(int32 routing_id);
IPC::Channel::Listener* ResolveRoute(int32 routing_id);
IPC::SyncChannel* channel() { return channel_.get(); }
// Creates a ResourceLoaderBridge.
// Tests can override this method if they want a custom loading behavior.
virtual webkit_glue::ResourceLoaderBridge* CreateBridge(
const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info);
// Allocates a block of shared memory of the given size and
// maps in into the address space. Returns NULL of failure.
// Note: On posix, this requires a sync IPC to the browser process,
// but on windows the child process directly allocates the block.
base::SharedMemory* AllocateSharedMemory(size_t buf_size);
ResourceDispatcher* resource_dispatcher();
SocketStreamDispatcher* socket_stream_dispatcher() {
return socket_stream_dispatcher_.get();
}
FileSystemDispatcher* file_system_dispatcher() const {
return file_system_dispatcher_.get();
}
QuotaDispatcher* quota_dispatcher() const {
return quota_dispatcher_.get();
}
// Safe to call on any thread, as long as it's guaranteed that the thread's
// lifetime is less than the main thread.
IPC::SyncMessageFilter* sync_message_filter();
MessageLoop* message_loop();
// Returns the one child thread.
static ChildThread* current();
protected:
friend class ChildProcess;
// Called when the process refcount is 0.
void OnProcessFinalRelease();
virtual bool OnControlMessageReceived(const IPC::Message& msg);
virtual void OnAskBeforeShutdown();
virtual void OnShutdown();
#ifdef IPC_MESSAGE_LOG_ENABLED
virtual void OnSetIPCLoggingEnabled(bool enable);
#endif
virtual void OnDumpHandles();
void set_on_channel_error_called(bool on_channel_error_called) {
on_channel_error_called_ = on_channel_error_called;
}
private:
void Init();
// IPC::Channel::Listener implementation:
virtual bool OnMessageReceived(const IPC::Message& msg);
virtual void OnChannelError();
std::string channel_name_;
scoped_ptr<IPC::SyncChannel> channel_;
// Allows threads other than the main thread to send sync messages.
scoped_refptr<IPC::SyncMessageFilter> sync_message_filter_;
// Implements message routing functionality to the consumers of ChildThread.
MessageRouter router_;
// Handles resource loads for this process.
scoped_ptr<ResourceDispatcher> resource_dispatcher_;
// Handles SocketStream for this process.
scoped_ptr<SocketStreamDispatcher> socket_stream_dispatcher_;
// If true, checks with the browser process before shutdown. This avoids race
// conditions if the process refcount is 0 but there's an IPC message inflight
// that would addref it.
bool check_with_browser_before_shutdown_;
// The OnChannelError() callback was invoked - the channel is dead, don't
// attempt to communicate.
bool on_channel_error_called_;
MessageLoop* message_loop_;
scoped_ptr<NotificationService> notification_service_;
scoped_ptr<FileSystemDispatcher> file_system_dispatcher_;
scoped_ptr<QuotaDispatcher> quota_dispatcher_;
DISALLOW_COPY_AND_ASSIGN(ChildThread);
};
#endif // CONTENT_COMMON_CHILD_THREAD_H_
|
