• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "content/renderer/render_process_impl.h"
6 
7 #include "build/build_config.h"
8 
9 #if defined(OS_WIN)
10 #include <windows.h>
11 #include <objidl.h>
12 #include <mlang.h>
13 #endif
14 
15 #include "base/basictypes.h"
16 #include "base/command_line.h"
17 #include "base/compiler_specific.h"
18 #include "base/message_loop/message_loop.h"
19 #include "base/strings/utf_string_conversions.h"
20 #include "base/sys_info.h"
21 #include "content/child/child_thread.h"
22 #include "content/child/npapi/plugin_instance.h"
23 #include "content/child/npapi/plugin_lib.h"
24 #include "content/child/site_isolation_policy.h"
25 #include "content/common/view_messages.h"
26 #include "content/public/common/content_switches.h"
27 #include "content/public/renderer/content_renderer_client.h"
28 #include "ipc/ipc_channel.h"
29 #include "ipc/ipc_message_utils.h"
30 #include "skia/ext/platform_canvas.h"
31 #include "third_party/WebKit/public/web/WebFrame.h"
32 #include "ui/surface/transport_dib.h"
33 #include "webkit/glue/webkit_glue.h"
34 
35 #if defined(OS_MACOSX)
36 #include "base/mac/mac_util.h"
37 #endif
38 
39 #if defined(OS_ANDROID)
40 #include "base/android/sys_utils.h"
41 #endif
42 
43 namespace content {
44 
RenderProcessImpl()45 RenderProcessImpl::RenderProcessImpl()
46     : shared_mem_cache_cleaner_(
47           FROM_HERE, base::TimeDelta::FromSeconds(5),
48           this, &RenderProcessImpl::ClearTransportDIBCache),
49       transport_dib_next_sequence_number_(0),
50       enabled_bindings_(0) {
51   in_process_plugins_ = InProcessPlugins();
52   for (size_t i = 0; i < arraysize(shared_mem_cache_); ++i)
53     shared_mem_cache_[i] = NULL;
54 
55 #if defined(OS_WIN)
56   // HACK:  See http://b/issue?id=1024307 for rationale.
57   if (GetModuleHandle(L"LPK.DLL") == NULL) {
58     // Makes sure lpk.dll is loaded by gdi32 to make sure ExtTextOut() works
59     // when buffering into a EMF buffer for printing.
60     typedef BOOL (__stdcall *GdiInitializeLanguagePack)(int LoadedShapingDLLs);
61     GdiInitializeLanguagePack gdi_init_lpk =
62         reinterpret_cast<GdiInitializeLanguagePack>(GetProcAddress(
63             GetModuleHandle(L"GDI32.DLL"),
64             "GdiInitializeLanguagePack"));
65     DCHECK(gdi_init_lpk);
66     if (gdi_init_lpk) {
67       gdi_init_lpk(0);
68     }
69   }
70 #endif
71 
72   // Out of process dev tools rely upon auto break behavior.
73   webkit_glue::SetJavaScriptFlags("--debugger-auto-break");
74 
75 #if defined(OS_ANDROID)
76   if (base::android::SysUtils::IsLowEndDevice())
77     webkit_glue::SetJavaScriptFlags("--optimize-for-size");
78 #endif
79 
80   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
81   if (command_line.HasSwitch(switches::kJavaScriptFlags)) {
82     webkit_glue::SetJavaScriptFlags(
83         command_line.GetSwitchValueASCII(switches::kJavaScriptFlags));
84   }
85 
86   // Turn on cross-site document blocking for renderer processes.
87   SiteIsolationPolicy::SetPolicyEnabled(
88       GetContentClient()->renderer()->ShouldEnableSiteIsolationPolicy());
89 }
90 
~RenderProcessImpl()91 RenderProcessImpl::~RenderProcessImpl() {
92 #ifndef NDEBUG
93   int count = blink::WebFrame::instanceCount();
94   if (count)
95     DLOG(ERROR) << "WebFrame LEAKED " << count << " TIMES";
96 #endif
97 
98   GetShutDownEvent()->Signal();
99   ClearTransportDIBCache();
100 }
101 
InProcessPlugins()102 bool RenderProcessImpl::InProcessPlugins() {
103   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
104 #if defined(OS_LINUX) || defined(OS_OPENBSD)
105   // Plugin processes require a UI message loop, and the Linux message loop
106   // implementation only allows one UI loop per process.
107   if (command_line.HasSwitch(switches::kInProcessPlugins))
108     NOTIMPLEMENTED() << ": in process plugins not supported on Linux";
109   return command_line.HasSwitch(switches::kInProcessPlugins);
110 #else
111   return command_line.HasSwitch(switches::kInProcessPlugins) ||
112          command_line.HasSwitch(switches::kSingleProcess);
113 #endif
114 }
115 
AddBindings(int bindings)116 void RenderProcessImpl::AddBindings(int bindings) {
117   enabled_bindings_ |= bindings;
118 }
119 
GetEnabledBindings() const120 int RenderProcessImpl::GetEnabledBindings() const {
121   return enabled_bindings_;
122 }
123 
124 // -----------------------------------------------------------------------------
125 // Platform specific code for dealing with bitmap transport...
126 
CreateTransportDIB(size_t size)127 TransportDIB* RenderProcessImpl::CreateTransportDIB(size_t size) {
128 #if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
129   // POSIX creates transport DIBs in the browser, so we need to do a sync IPC to
130   // get one.  The TransportDIB is cached in the browser.
131   TransportDIB::Handle handle;
132   IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(size, true, &handle);
133   if (!main_thread()->Send(msg))
134     return NULL;
135   if (handle.fd < 0)
136     return NULL;
137   return TransportDIB::Map(handle);
138 #else
139   // Windows, legacy GTK and Android create transport DIBs inside the
140   // renderer.
141   return TransportDIB::Create(size, transport_dib_next_sequence_number_++);
142 #endif
143 }
144 
FreeTransportDIB(TransportDIB * dib)145 void RenderProcessImpl::FreeTransportDIB(TransportDIB* dib) {
146   if (!dib)
147     return;
148 
149 #if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
150   // On POSIX we need to tell the browser that it can drop a reference to the
151   // shared memory.
152   IPC::Message* msg = new ViewHostMsg_FreeTransportDIB(dib->id());
153   main_thread()->Send(msg);
154 #endif
155 
156   delete dib;
157 }
158 
159 // -----------------------------------------------------------------------------
160 
161 
GetDrawingCanvas(TransportDIB ** memory,const gfx::Rect & rect)162 skia::PlatformCanvas* RenderProcessImpl::GetDrawingCanvas(
163     TransportDIB** memory, const gfx::Rect& rect) {
164   int width = rect.width();
165   int height = rect.height();
166   const size_t stride = skia::PlatformCanvasStrideForWidth(rect.width());
167 #if defined(OS_LINUX) || defined(OS_OPENBSD)
168   const size_t max_size = base::SysInfo::MaxSharedMemorySize();
169 #else
170   const size_t max_size = 0;
171 #endif
172 
173   // If the requested size is too big, reduce the height. Ideally we might like
174   // to reduce the width as well to make the size reduction more "balanced", but
175   // it rarely comes up in practice.
176   if ((max_size != 0) && (height * stride > max_size))
177     height = max_size / stride;
178 
179   const size_t size = height * stride;
180 
181   if (!GetTransportDIBFromCache(memory, size)) {
182     *memory = CreateTransportDIB(size);
183     if (!*memory)
184       return NULL;
185   }
186 
187   return (*memory)->GetPlatformCanvas(width, height);
188 }
189 
ReleaseTransportDIB(TransportDIB * mem)190 void RenderProcessImpl::ReleaseTransportDIB(TransportDIB* mem) {
191   if (PutSharedMemInCache(mem)) {
192     shared_mem_cache_cleaner_.Reset();
193     return;
194   }
195 
196   FreeTransportDIB(mem);
197 }
198 
UseInProcessPlugins() const199 bool RenderProcessImpl::UseInProcessPlugins() const {
200   return in_process_plugins_;
201 }
202 
GetTransportDIBFromCache(TransportDIB ** mem,size_t size)203 bool RenderProcessImpl::GetTransportDIBFromCache(TransportDIB** mem,
204                                              size_t size) {
205   // look for a cached object that is suitable for the requested size.
206   for (size_t i = 0; i < arraysize(shared_mem_cache_); ++i) {
207     if (shared_mem_cache_[i] &&
208         size <= shared_mem_cache_[i]->size()) {
209       *mem = shared_mem_cache_[i];
210       shared_mem_cache_[i] = NULL;
211       return true;
212     }
213   }
214 
215   return false;
216 }
217 
FindFreeCacheSlot(size_t size)218 int RenderProcessImpl::FindFreeCacheSlot(size_t size) {
219   // simple algorithm:
220   //  - look for an empty slot to store mem, or
221   //  - if full, then replace smallest entry which is smaller than |size|
222   for (size_t i = 0; i < arraysize(shared_mem_cache_); ++i) {
223     if (shared_mem_cache_[i] == NULL)
224       return i;
225   }
226 
227   size_t smallest_size = size;
228   int smallest_index = -1;
229 
230   for (size_t i = 1; i < arraysize(shared_mem_cache_); ++i) {
231     const size_t entry_size = shared_mem_cache_[i]->size();
232     if (entry_size < smallest_size) {
233       smallest_size = entry_size;
234       smallest_index = i;
235     }
236   }
237 
238   if (smallest_index != -1) {
239     FreeTransportDIB(shared_mem_cache_[smallest_index]);
240     shared_mem_cache_[smallest_index] = NULL;
241   }
242 
243   return smallest_index;
244 }
245 
PutSharedMemInCache(TransportDIB * mem)246 bool RenderProcessImpl::PutSharedMemInCache(TransportDIB* mem) {
247   const int slot = FindFreeCacheSlot(mem->size());
248   if (slot == -1)
249     return false;
250 
251   shared_mem_cache_[slot] = mem;
252   return true;
253 }
254 
ClearTransportDIBCache()255 void RenderProcessImpl::ClearTransportDIBCache() {
256   for (size_t i = 0; i < arraysize(shared_mem_cache_); ++i) {
257     if (shared_mem_cache_[i]) {
258       FreeTransportDIB(shared_mem_cache_[i]);
259       shared_mem_cache_[i] = NULL;
260     }
261   }
262 }
263 
264 }  // namespace content
265