Home | History | Annotate | Download | only in renderer 
      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 
     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 
     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 
    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 
    116 void RenderProcessImpl::AddBindings(int bindings) {
    117   enabled_bindings_ |= bindings;
    118 }
    119 
    120 int RenderProcessImpl::GetEnabledBindings() const {
    121   return enabled_bindings_;
    122 }
    123 
    124 // -----------------------------------------------------------------------------
    125 // Platform specific code for dealing with bitmap transport...
    126 
    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 
    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 
    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 
    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 
    199 bool RenderProcessImpl::UseInProcessPlugins() const {
    200   return in_process_plugins_;
    201 }
    202 
    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 
    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 
    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 
    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