Make the Linux sandbox process initialize WebKit before using the WebKit api.

content/browser/renderer_host/render_sandbox_host_linux.cc

 // 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.
 
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <stdint.h>
 #include <unistd.h>
@@ skipping 13 matching lines @@
 #include "base/pickle.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "content/common/font_config_ipc_linux.h"
 #include "content/common/sandbox_methods_linux.h"
 #include "content/common/unix_domain_socket_posix.h"
 #include "skia/ext/SkFontHost_fontconfig_direct.h"
 #include "third_party/npapi/bindings/npapi_extensions.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebFontInfo.h"
+#include "webkit/glue/webkitclient_impl.h"
 
 using WebKit::WebCString;
 using WebKit::WebFontInfo;
 using WebKit::WebUChar;
 
 // http://code.google.com/p/chromium/wiki/LinuxSandboxIPC
 
 // BEWARE: code in this file run across *processes* (not just threads).
 
 // This code runs in a child process
@@ skipping 16 matching lines @@
     multimap.push_back(base::InjectionArc(0, browser_socket, false));
 
     base::CloseSuperfluousFds(multimap);
 
     if (!sandbox_cmd.empty()) {
       sandbox_cmd_.push_back(sandbox_cmd);
       sandbox_cmd_.push_back(base::kFindInodeSwitch);
     }
   }
 
+  ~SandboxIPCProcess();
+
   void Run() {
     struct pollfd pfds[2];
     pfds[0].fd = lifeline_fd_;
     pfds[0].events = POLLIN;
     pfds[1].fd = browser_socket_;
     pfds[1].events = POLLIN;
 
     int failed_polls = 0;
     for (;;) {
       const int r = HANDLE_EINTR(poll(pfds, 2, -1));
@@ skipping 13 matching lines @@
         _exit(0);
       }
 
       if (pfds[1].revents) {
         HandleRequestFromRenderer(browser_socket_);
       }
     }
   }
 
  private:
+  void EnsureWebKitInitialized();
+
   // ---------------------------------------------------------------------------
   // Requests from the renderer...
 
   void HandleRequestFromRenderer(int fd) {
     std::vector<int> fds;
 
     // A FontConfigIPC::METHOD_MATCH message could be kMaxFontFamilyLength
     // bytes long (this is the largest message type).
     // 128 bytes padding are necessary so recvmsg() does not return MSG_TRUNC
     // error for a maximum length message.
@@ skipping 124 matching lines @@
 
     // We don't want a corrupt renderer asking too much of us, it might
     // overflow later in the code.
     static const int kMaxChars = 4096;
     if (num_chars < 1 || num_chars > kMaxChars) {
       LOG(WARNING) << "HandleGetFontFamilyForChars: too many chars: "
                    << num_chars;
       return;
     }
 
+    EnsureWebKitInitialized();
     scoped_array<WebUChar> chars(new WebUChar[num_chars]);
 
     for (int i = 0; i < num_chars; ++i) {
       uint32_t c;
       if (!pickle.ReadUInt32(&iter, &c)) {
         return;
       }
 
       chars[i] = c;
     }
@@ skipping 18 matching lines @@
   void HandleGetStyleForStrike(int fd, const Pickle& pickle, void* iter,
                                std::vector<int>& fds) {
     std::string family;
     int sizeAndStyle;
 
     if (!pickle.ReadString(&iter, &family) ||
         !pickle.ReadInt(&iter, &sizeAndStyle)) {
       return;
     }
 
+    EnsureWebKitInitialized();
     WebKit::WebFontRenderStyle style;
     WebFontInfo::renderStyleForStrike(family.c_str(), sizeAndStyle, &style);
 
     Pickle reply;
     reply.WriteInt(style.useBitmaps);
     reply.WriteInt(style.useAutoHint);
     reply.WriteInt(style.useHinting);
     reply.WriteInt(style.hintStyle);
     reply.WriteInt(style.useAntiAlias);
     reply.WriteInt(style.useSubpixel);
@@ skipping 334 matching lines @@
     if (HANDLE_EINTR(sendmsg(fds[0], &msg, MSG_DONTWAIT)) < 0)
       PLOG(ERROR) << "sendmsg";
   }
 
   // ---------------------------------------------------------------------------
 
   const int lifeline_fd_;
   const int browser_socket_;
   FontConfigDirect* const font_config_;
   std::vector<std::string> sandbox_cmd_;
+  scoped_ptr<webkit_glue::WebKitClientImpl> webkit_client_;
 };
 
+SandboxIPCProcess::~SandboxIPCProcess() {
+  if (webkit_client_.get())
+    WebKit::shutdown();
+}
+
+void SandboxIPCProcess::EnsureWebKitInitialized() {
+  if (webkit_client_.get())
+    return;
+  webkit_client_.reset(new webkit_glue::WebKitClientImpl);
+  WebKit::initialize(webkit_client_.get());
+}
+
 // -----------------------------------------------------------------------------
 
 // Runs on the main thread at startup.
 RenderSandboxHostLinux::RenderSandboxHostLinux()
     : initialized_(false),
       renderer_socket_(0),
       childs_lifeline_fd_(0),
       pid_(0) {
 }
 
@@ skipping 39 matching lines @@
 }
 
 RenderSandboxHostLinux::~RenderSandboxHostLinux() {
   if (initialized_) {
     if (HANDLE_EINTR(close(renderer_socket_)) < 0)
       PLOG(ERROR) << "close";
     if (HANDLE_EINTR(close(childs_lifeline_fd_)) < 0)
       PLOG(ERROR) << "close";
   }
 }