render_message_filter.h revision a36e5920737c6adbddd3e43b760e5de8431db6e0 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_MESSAGE_FILTER_H_
6#define CONTENT_BROWSER_RENDERER_HOST_RENDER_MESSAGE_FILTER_H_
7
8#if defined(OS_WIN)
9#include <windows.h>
10#endif
11
12#include <set>
13#include <string>
14#include <vector>
15
16#include "base/files/file_path.h"
17#include "base/memory/linked_ptr.h"
18#include "base/memory/shared_memory.h"
19#include "base/sequenced_task_runner_helpers.h"
20#include "base/strings/string16.h"
21#include "build/build_config.h"
22#include "content/common/pepper_renderer_instance_data.h"
23#include "content/public/browser/browser_message_filter.h"
24#include "content/public/common/three_d_api_types.h"
25#include "media/audio/audio_parameters.h"
26#include "media/base/channel_layout.h"
27#include "net/cookies/canonical_cookie.h"
28#include "third_party/WebKit/public/web/WebPopupType.h"
29#include "ui/gfx/native_widget_types.h"
30#include "ui/surface/transport_dib.h"
31
32#if defined(OS_MACOSX)
33#include "content/common/mac/font_loader.h"
34#endif
35
36#if defined(OS_ANDROID)
37#include "base/threading/worker_pool.h"
38#endif
39
40struct FontDescriptor;
41struct ViewHostMsg_CreateWindow_Params;
42
43namespace WebKit {
44struct WebScreenInfo;
45}
46
47namespace base {
48class ProcessMetrics;
49class SharedMemory;
50class TaskRunner;
51}
52
53namespace gfx {
54class Rect;
55}
56
57namespace media {
58class AudioManager;
59struct MediaLogEvent;
60}
61
62namespace net {
63class URLRequestContext;
64class URLRequestContextGetter;
65}
66
67namespace content {
68class BrowserContext;
69class DOMStorageContextImpl;
70class MediaInternals;
71class PluginServiceImpl;
72class RenderWidgetHelper;
73class ResourceContext;
74class ResourceDispatcherHostImpl;
75struct Referrer;
76struct WebPluginInfo;
77
78// This class filters out incoming IPC messages for the renderer process on the
79// IPC thread.
80class RenderMessageFilter : public BrowserMessageFilter {
81 public:
82  // Create the filter.
83  RenderMessageFilter(int render_process_id,
84                      bool is_guest,
85                      PluginServiceImpl * plugin_service,
86                      BrowserContext* browser_context,
87                      net::URLRequestContextGetter* request_context,
88                      RenderWidgetHelper* render_widget_helper,
89                      media::AudioManager* audio_manager,
90                      MediaInternals* media_internals,
91                      DOMStorageContextImpl* dom_storage_context);
92
93  // IPC::ChannelProxy::MessageFilter methods:
94  virtual void OnChannelClosing() OVERRIDE;
95  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
96
97  // BrowserMessageFilter methods:
98  virtual bool OnMessageReceived(const IPC::Message& message,
99                                 bool* message_was_ok) OVERRIDE;
100  virtual void OnDestruct() const OVERRIDE;
101  virtual base::TaskRunner* OverrideTaskRunnerForMessage(
102      const IPC::Message& message) OVERRIDE;
103
104  bool OffTheRecord() const;
105
106  int render_process_id() const { return render_process_id_; }
107
108  // Returns the correct net::URLRequestContext depending on what type of url is
109  // given.
110  // Only call on the IO thread.
111  net::URLRequestContext* GetRequestContextForURL(const GURL& url);
112
113 private:
114  friend class BrowserThread;
115  friend class base::DeleteHelper<RenderMessageFilter>;
116
117  class OpenChannelToNpapiPluginCallback;
118
119  virtual ~RenderMessageFilter();
120
121  void OnGetProcessMemorySizes(size_t* private_bytes, size_t* shared_bytes);
122  void OnCreateWindow(const ViewHostMsg_CreateWindow_Params& params,
123                      int* route_id,
124                      int* main_frame_route_id,
125                      int* surface_id,
126                      int64* cloned_session_storage_namespace_id);
127  void OnCreateWidget(int opener_id,
128                      WebKit::WebPopupType popup_type,
129                      int* route_id,
130                      int* surface_id);
131  void OnCreateFullscreenWidget(int opener_id,
132                                int* route_id,
133                                int* surface_id);
134  void OnSetCookie(const IPC::Message& message,
135                   const GURL& url,
136                   const GURL& first_party_for_cookies,
137                   const std::string& cookie);
138  void OnGetCookies(const GURL& url,
139                    const GURL& first_party_for_cookies,
140                    IPC::Message* reply_msg);
141  void OnGetRawCookies(const GURL& url,
142                       const GURL& first_party_for_cookies,
143                       IPC::Message* reply_msg);
144  void OnDeleteCookie(const GURL& url,
145                      const std::string& cookieName);
146  void OnCookiesEnabled(const GURL& url,
147                        const GURL& first_party_for_cookies,
148                        bool* cookies_enabled);
149
150#if defined(OS_MACOSX)
151  // Messages for OOP font loading.
152  void OnLoadFont(const FontDescriptor& font, IPC::Message* reply_msg);
153  void SendLoadFontReply(IPC::Message* reply, FontLoader::Result* result);
154#endif
155
156#if defined(OS_WIN)
157  void OnPreCacheFontCharacters(const LOGFONT& log_font,
158                                const string16& characters);
159#endif
160
161  void OnGetPlugins(bool refresh, IPC::Message* reply_msg);
162  void GetPluginsCallback(IPC::Message* reply_msg,
163                          const std::vector<WebPluginInfo>& plugins);
164  void OnGetPluginInfo(int routing_id,
165                       const GURL& url,
166                       const GURL& policy_url,
167                       const std::string& mime_type,
168                       bool* found,
169                       WebPluginInfo* info,
170                       std::string* actual_mime_type);
171  void OnOpenChannelToPlugin(int routing_id,
172                             const GURL& url,
173                             const GURL& policy_url,
174                             const std::string& mime_type,
175                             IPC::Message* reply_msg);
176  void OnOpenChannelToPepperPlugin(const base::FilePath& path,
177                                   IPC::Message* reply_msg);
178  void OnDidCreateOutOfProcessPepperInstance(
179      int plugin_child_id,
180      int32 pp_instance,
181      PepperRendererInstanceData instance_data,
182      bool is_external);
183  void OnDidDeleteOutOfProcessPepperInstance(int plugin_child_id,
184                                             int32 pp_instance,
185                                             bool is_external);
186  void OnOpenChannelToPpapiBroker(int routing_id,
187                                  int request_id,
188                                  const base::FilePath& path);
189  void OnGenerateRoutingID(int* route_id);
190  void OnDownloadUrl(const IPC::Message& message,
191                     const GURL& url,
192                     const Referrer& referrer,
193                     const string16& suggested_name);
194  void OnCheckNotificationPermission(const GURL& source_origin,
195                                     int* permission_level);
196
197  void OnGetCPUUsage(int* cpu_usage);
198
199  void OnGetAudioHardwareConfig(media::AudioParameters* input_params,
200                                media::AudioParameters* output_params);
201
202  // Used to look up the monitor color profile.
203  void OnGetMonitorColorProfile(std::vector<char>* profile);
204
205  // Used to ask the browser to allocate a block of shared memory for the
206  // renderer to send back data in, since shared memory can't be created
207  // in the renderer on POSIX due to the sandbox.
208  void OnAllocateSharedMemory(uint32 buffer_size,
209                              base::SharedMemoryHandle* handle);
210  void OnResolveProxy(const GURL& url, IPC::Message* reply_msg);
211
212  // Browser side transport DIB allocation
213  void OnAllocTransportDIB(uint32 size,
214                           bool cache_in_browser,
215                           TransportDIB::Handle* result);
216  void OnFreeTransportDIB(TransportDIB::Id dib_id);
217  void OnCacheableMetadataAvailable(const GURL& url,
218                                    double expected_response_time,
219                                    const std::vector<char>& data);
220  void OnKeygen(uint32 key_size_index, const std::string& challenge_string,
221                const GURL& url, IPC::Message* reply_msg);
222  void OnKeygenOnWorkerThread(
223      int key_size_in_bits,
224      const std::string& challenge_string,
225      const GURL& url,
226      IPC::Message* reply_msg);
227  void OnAsyncOpenPepperFile(const IPC::Message& msg,
228                             const base::FilePath& path,
229                             int pp_open_flags,
230                             int message_id);
231  void AsyncOpenPepperFileOnFileThread(const base::FilePath& path,
232                                       int platform_file_flags,
233                                       int message_id,
234                                       int routing_id);
235  void OnMediaLogEvents(const std::vector<media::MediaLogEvent>&);
236
237  // Check the policy for getting cookies. Gets the cookies if allowed.
238  void CheckPolicyForCookies(const GURL& url,
239                             const GURL& first_party_for_cookies,
240                             IPC::Message* reply_msg,
241                             const net::CookieList& cookie_list);
242
243  // Writes the cookies to reply messages, and sends the message.
244  // Callback functions for getting cookies from cookie store.
245  void SendGetCookiesResponse(IPC::Message* reply_msg,
246                              const std::string& cookies);
247  void SendGetRawCookiesResponse(IPC::Message* reply_msg,
248                                 const net::CookieList& cookie_list);
249
250  bool CheckBenchmarkingEnabled() const;
251  bool CheckPreparsedJsCachingEnabled() const;
252  void OnCompletedOpenChannelToNpapiPlugin(
253      OpenChannelToNpapiPluginCallback* client);
254
255  void OnUpdateIsDelayed(const IPC::Message& msg);
256  void OnAre3DAPIsBlocked(int render_view_id,
257                          const GURL& top_origin_url,
258                          ThreeDAPIType requester,
259                          bool* blocked);
260  void OnDidLose3DContext(const GURL& top_origin_url,
261                          ThreeDAPIType context_type,
262                          int arb_robustness_status_code);
263
264#if defined(OS_ANDROID)
265  void OnWebAudioMediaCodec(base::SharedMemoryHandle encoded_data_handle,
266                            base::FileDescriptor pcm_output,
267                            uint32_t data_size);
268#endif
269
270  // Cached resource request dispatcher host and plugin service, guaranteed to
271  // be non-null if Init succeeds. We do not own the objects, they are managed
272  // by the BrowserProcess, which has a wider scope than we do.
273  ResourceDispatcherHostImpl* resource_dispatcher_host_;
274  PluginServiceImpl* plugin_service_;
275  base::FilePath profile_data_directory_;
276
277  // Contextual information to be used for requests created here.
278  scoped_refptr<net::URLRequestContextGetter> request_context_;
279
280  // The ResourceContext which is to be used on the IO thread.
281  ResourceContext* resource_context_;
282
283  scoped_refptr<RenderWidgetHelper> render_widget_helper_;
284
285  // Whether this process is used for incognito contents.
286  // This doesn't belong here; http://crbug.com/89628
287  bool incognito_;
288
289  // Initialized to 0, accessed on FILE thread only.
290  base::TimeTicks last_plugin_refresh_time_;
291
292  scoped_refptr<DOMStorageContextImpl> dom_storage_context_;
293
294  int render_process_id_;
295
296  bool is_guest_;
297
298  std::set<OpenChannelToNpapiPluginCallback*> plugin_host_clients_;
299
300  // Records the last time we sampled CPU usage of the renderer process.
301  base::TimeTicks cpu_usage_sample_time_;
302  // Records the last sampled CPU usage in percents.
303  int cpu_usage_;
304  // Used for sampling CPU usage of the renderer process.
305  scoped_ptr<base::ProcessMetrics> process_metrics_;
306
307  media::AudioManager* audio_manager_;
308  MediaInternals* media_internals_;
309
310  DISALLOW_COPY_AND_ASSIGN(RenderMessageFilter);
311};
312
313}  // namespace content
314
315#endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_MESSAGE_FILTER_H_
316