src/chrome/renderer/chrome_render_process_observer.cc

   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 "chrome/renderer/chrome_render_process_observer.h"
   6
   7 #include <limits>
   8 #include <vector>
   9
  10 #include "base/allocator/allocator_extension.h"
  11 #include "base/bind.h"
  12 #include "base/command_line.h"
  13 #include "base/files/file_util.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/metrics/field_trial.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/metrics/statistics_recorder.h"
  19 #include "base/native_library.h"
  20 #include "base/path_service.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/threading/platform_thread.h"
  23 #include "chrome/common/child_process_logging.h"
  24 #include "chrome/common/chrome_paths.h"
  25 #include "chrome/common/chrome_switches.h"
  26 #include "chrome/common/net/net_resource_provider.h"
  27 #include "chrome/common/render_messages.h"
  28 #include "chrome/common/url_constants.h"
  29 #include "chrome/common/variations/variations_util.h"
  30 #include "chrome/renderer/content_settings_observer.h"
  31 #include "chrome/renderer/security_filter_peer.h"
  32 #include "content/public/child/resource_dispatcher_delegate.h"
  33 #include "content/public/renderer/render_thread.h"
  34 #include "content/public/renderer/render_view.h"
  35 #include "content/public/renderer/render_view_visitor.h"
  36 #include "crypto/nss_util.h"
  37 #include "net/base/net_errors.h"
  38 #include "net/base/net_module.h"
  39 #include "third_party/WebKit/public/web/WebCache.h"
  40 #include "third_party/WebKit/public/web/WebDocument.h"
  41 #include "third_party/WebKit/public/web/WebFrame.h"
  42 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
  43 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
  44 #include "third_party/WebKit/public/web/WebView.h"
  45
  46 #if defined(OS_WIN)
  47 #include "base/win/iat_patch_function.h"
  48 #endif
  49
  50 #if defined(ENABLE_EXTENSIONS)
  51 #include "chrome/renderer/extensions/extension_localization_peer.h"
  52 #endif
  53
  54 using blink::WebCache;
  55 using blink::WebRuntimeFeatures;
  56 using blink::WebSecurityPolicy;
  57 using blink::WebString;
  58 using content::RenderThread;
  59
  60 namespace {
  61
  62 const int kCacheStatsDelayMS = 2000;
  63
  64 class RendererResourceDelegate : public content::ResourceDispatcherDelegate {
  65  public:
  66   RendererResourceDelegate()
  67       : weak_factory_(this) {
  68   }
  69
  70   virtual content::RequestPeer* OnRequestComplete(
  71       content::RequestPeer* current_peer,
  72       content::ResourceType resource_type,
  73       int error_code) OVERRIDE {
  74     // Update the browser about our cache.
  75     // Rate limit informing the host of our cache stats.
  76     if (!weak_factory_.HasWeakPtrs()) {
  77       base::MessageLoop::current()->PostDelayedTask(
  78           FROM_HERE,
  79           base::Bind(&RendererResourceDelegate::InformHostOfCacheStats,
  80                      weak_factory_.GetWeakPtr()),
  81           base::TimeDelta::FromMilliseconds(kCacheStatsDelayMS));
  82     }
  83
  84     if (error_code == net::ERR_ABORTED) {
  85       return NULL;
  86     }
  87
  88     // Resource canceled with a specific error are filtered.
  89     return SecurityFilterPeer::CreateSecurityFilterPeerForDeniedRequest(
  90         resource_type, current_peer, error_code);
  91   }
  92
  93   virtual content::RequestPeer* OnReceivedResponse(
  94       content::RequestPeer* current_peer,
  95       const std::string& mime_type,
  96       const GURL& url) OVERRIDE {
  97 #if defined(ENABLE_EXTENSIONS)
  98     return ExtensionLocalizationPeer::CreateExtensionLocalizationPeer(
  99         current_peer, RenderThread::Get(), mime_type, url);
 100 #else
 101     return NULL;
 102 #endif
 103   }
 104
 105  private:
 106   void InformHostOfCacheStats() {
 107     WebCache::UsageStats stats;
 108     WebCache::getUsageStats(&stats);
 109     RenderThread::Get()->Send(new ChromeViewHostMsg_UpdatedCacheStats(stats));
 110   }
 111
 112   base::WeakPtrFactory<RendererResourceDelegate> weak_factory_;
 113
 114   DISALLOW_COPY_AND_ASSIGN(RendererResourceDelegate);
 115 };
 116
 117 #if defined(OS_WIN)
 118 static base::win::IATPatchFunction g_iat_patch_createdca;
 119 HDC WINAPI CreateDCAPatch(LPCSTR driver_name,
 120                           LPCSTR device_name,
 121                           LPCSTR output,
 122                           const void* init_data) {
 123   DCHECK(std::string("DISPLAY") == std::string(driver_name));
 124   DCHECK(!device_name);
 125   DCHECK(!output);
 126   DCHECK(!init_data);
 127
 128   // CreateDC fails behind the sandbox, but not CreateCompatibleDC.
 129   return CreateCompatibleDC(NULL);
 130 }
 131
 132 static base::win::IATPatchFunction g_iat_patch_get_font_data;
 133 DWORD WINAPI GetFontDataPatch(HDC hdc,
 134                               DWORD table,
 135                               DWORD offset,
 136                               LPVOID buffer,
 137                               DWORD length) {
 138   int rv = GetFontData(hdc, table, offset, buffer, length);
 139   if (rv == GDI_ERROR && hdc) {
 140     HFONT font = static_cast<HFONT>(GetCurrentObject(hdc, OBJ_FONT));
 141
 142     LOGFONT logfont;
 143     if (GetObject(font, sizeof(LOGFONT), &logfont)) {
 144       std::vector<char> font_data;
 145       RenderThread::Get()->PreCacheFont(logfont);
 146       rv = GetFontData(hdc, table, offset, buffer, length);
 147       RenderThread::Get()->ReleaseCachedFonts();
 148     }
 149   }
 150   return rv;
 151 }
 152 #endif  // OS_WIN
 153
 154 static const int kWaitForWorkersStatsTimeoutMS = 20;
 155
 156 class HeapStatisticsCollector {
 157  public:
 158   HeapStatisticsCollector() : round_id_(0) {}
 159
 160   void InitiateCollection();
 161   static HeapStatisticsCollector* Instance();
 162
 163  private:
 164   void CollectOnWorkerThread(scoped_refptr<base::TaskRunner> master,
 165                              int round_id);
 166   void ReceiveStats(int round_id, size_t total_size, size_t used_size);
 167   void SendStatsToBrowser(int round_id);
 168
 169   size_t total_bytes_;
 170   size_t used_bytes_;
 171   int workers_to_go_;
 172   int round_id_;
 173 };
 174
 175 HeapStatisticsCollector* HeapStatisticsCollector::Instance() {
 176   CR_DEFINE_STATIC_LOCAL(HeapStatisticsCollector, instance, ());
 177   return &instance;
 178 }
 179
 180 void HeapStatisticsCollector::InitiateCollection() {
 181   v8::HeapStatistics heap_stats;
 182   v8::Isolate::GetCurrent()->GetHeapStatistics(&heap_stats);
 183   total_bytes_ = heap_stats.total_heap_size();
 184   used_bytes_ = heap_stats.used_heap_size();
 185   base::Closure collect = base::Bind(
 186       &HeapStatisticsCollector::CollectOnWorkerThread,
 187       base::Unretained(this),
 188       base::MessageLoopProxy::current(),
 189       round_id_);
 190   workers_to_go_ = RenderThread::Get()->PostTaskToAllWebWorkers(collect);
 191   if (workers_to_go_) {
 192     // The guard task to send out partial stats
 193     // in case some workers are not responsive.
 194     base::MessageLoopProxy::current()->PostDelayedTask(
 195         FROM_HERE,
 196         base::Bind(&HeapStatisticsCollector::SendStatsToBrowser,
 197                    base::Unretained(this),
 198                    round_id_),
 199         base::TimeDelta::FromMilliseconds(kWaitForWorkersStatsTimeoutMS));
 200   } else {
 201     // No worker threads so just send out the main thread data right away.
 202     SendStatsToBrowser(round_id_);
 203   }
 204 }
 205
 206 void HeapStatisticsCollector::CollectOnWorkerThread(
 207     scoped_refptr<base::TaskRunner> master,
 208     int round_id) {
 209
 210   size_t total_bytes = 0;
 211   size_t used_bytes = 0;
 212   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 213   if (isolate) {
 214     v8::HeapStatistics heap_stats;
 215     isolate->GetHeapStatistics(&heap_stats);
 216     total_bytes = heap_stats.total_heap_size();
 217     used_bytes = heap_stats.used_heap_size();
 218   }
 219   master->PostTask(
 220       FROM_HERE,
 221       base::Bind(&HeapStatisticsCollector::ReceiveStats,
 222                  base::Unretained(this),
 223                  round_id,
 224                  total_bytes,
 225                  used_bytes));
 226 }
 227
 228 void HeapStatisticsCollector::ReceiveStats(int round_id,
 229                                            size_t total_bytes,
 230                                            size_t used_bytes) {
 231   if (round_id != round_id_)
 232     return;
 233   total_bytes_ += total_bytes;
 234   used_bytes_ += used_bytes;
 235   if (!--workers_to_go_)
 236     SendStatsToBrowser(round_id);
 237 }
 238
 239 void HeapStatisticsCollector::SendStatsToBrowser(int round_id) {
 240   if (round_id != round_id_)
 241     return;
 242   // TODO(alph): Do caching heap stats and use the cache if we haven't got
 243   //             reply from a worker.
 244   //             Currently a busy worker stats are not counted.
 245   RenderThread::Get()->Send(new ChromeViewHostMsg_V8HeapStats(
 246       total_bytes_, used_bytes_));
 247   ++round_id_;
 248 }
 249
 250 }  // namespace
 251
 252 bool ChromeRenderProcessObserver::is_incognito_process_ = false;
 253
 254 ChromeRenderProcessObserver::ChromeRenderProcessObserver(
 255     ChromeContentRendererClient* client)
 256     : client_(client),
 257       webkit_initialized_(false) {
 258   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 259
 260 #if defined(ENABLE_AUTOFILL_DIALOG)
 261   WebRuntimeFeatures::enableRequestAutocomplete(true);
 262 #endif
 263
 264   if (command_line.HasSwitch(switches::kEnableShowModalDialog))
 265     WebRuntimeFeatures::enableShowModalDialog(true);
 266
 267   if (command_line.HasSwitch(switches::kJavaScriptHarmony)) {
 268     std::string flag("--harmony");
 269     v8::V8::SetFlagsFromString(flag.c_str(), static_cast<int>(flag.size()));
 270   }
 271
 272   RenderThread* thread = RenderThread::Get();
 273   resource_delegate_.reset(new RendererResourceDelegate());
 274   thread->SetResourceDispatcherDelegate(resource_delegate_.get());
 275
 276   // Configure modules that need access to resources.
 277   net::NetModule::SetResourceProvider(chrome_common_net::NetResourceProvider);
 278
 279 #if defined(OS_WIN)
 280   // Need to patch a few functions for font loading to work correctly.
 281   base::FilePath pdf;
 282   if (PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf) &&
 283       base::PathExists(pdf)) {
 284     g_iat_patch_createdca.Patch(
 285         pdf.value().c_str(), "gdi32.dll", "CreateDCA", CreateDCAPatch);
 286     g_iat_patch_get_font_data.Patch(
 287         pdf.value().c_str(), "gdi32.dll", "GetFontData", GetFontDataPatch);
 288   }
 289 #endif
 290
 291 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(USE_NSS)
 292   // On platforms where we use system NSS shared libraries,
 293   // initialize NSS now because it won't be able to load the .so's
 294   // after we engage the sandbox.
 295   if (!command_line.HasSwitch(switches::kSingleProcess))
 296     crypto::InitNSSSafely();
 297 #elif defined(OS_WIN)
 298   // crypt32.dll is used to decode X509 certificates for Chromoting.
 299   // Only load this library when the feature is enabled.
 300   base::LoadNativeLibrary(base::FilePath(L"crypt32.dll"), NULL);
 301 #endif
 302   // Setup initial set of crash dump data for Field Trials in this renderer.
 303   chrome_variations::SetChildProcessLoggingVariationList();
 304 }
 305
 306 ChromeRenderProcessObserver::~ChromeRenderProcessObserver() {
 307 }
 308
 309 bool ChromeRenderProcessObserver::OnControlMessageReceived(
 310     const IPC::Message& message) {
 311   bool handled = true;
 312   IPC_BEGIN_MESSAGE_MAP(ChromeRenderProcessObserver, message)
 313     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetIsIncognitoProcess,
 314                         OnSetIsIncognitoProcess)
 315     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetFieldTrialGroup, OnSetFieldTrialGroup)
 316     IPC_MESSAGE_HANDLER(ChromeViewMsg_GetV8HeapStats, OnGetV8HeapStats)
 317     IPC_MESSAGE_HANDLER(ChromeViewMsg_GetCacheResourceStats,
 318                         OnGetCacheResourceStats)
 319     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetContentSettingRules,
 320                         OnSetContentSettingRules)
 321     IPC_MESSAGE_UNHANDLED(handled = false)
 322   IPC_END_MESSAGE_MAP()
 323   return handled;
 324 }
 325
 326 void ChromeRenderProcessObserver::WebKitInitialized() {
 327   webkit_initialized_ = true;
 328   // chrome-native: is a scheme used for placeholder navigations that allow
 329   // UIs to be drawn with platform native widgets instead of HTML.  These pages
 330   // should not be accessible, and should also be treated as empty documents
 331   // that can commit synchronously.  No code should be runnable in these pages,
 332   // so it should not need to access anything nor should it allow javascript
 333   // URLs since it should never be visible to the user.
 334   WebString native_scheme(base::ASCIIToUTF16(chrome::kChromeNativeScheme));
 335   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(native_scheme);
 336   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(native_scheme);
 337   WebSecurityPolicy::registerURLSchemeAsNoAccess(native_scheme);
 338   WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
 339       native_scheme);
 340 }
 341
 342 void ChromeRenderProcessObserver::OnRenderProcessShutdown() {
 343   webkit_initialized_ = false;
 344 }
 345
 346 void ChromeRenderProcessObserver::OnSetIsIncognitoProcess(
 347     bool is_incognito_process) {
 348   is_incognito_process_ = is_incognito_process;
 349 }
 350
 351 void ChromeRenderProcessObserver::OnSetContentSettingRules(
 352     const RendererContentSettingRules& rules) {
 353   content_setting_rules_ = rules;
 354 }
 355
 356 void ChromeRenderProcessObserver::OnGetCacheResourceStats() {
 357   WebCache::ResourceTypeStats stats;
 358   if (webkit_initialized_)
 359     WebCache::getResourceTypeStats(&stats);
 360   RenderThread::Get()->Send(new ChromeViewHostMsg_ResourceTypeStats(stats));
 361 }
 362
 363 void ChromeRenderProcessObserver::OnSetFieldTrialGroup(
 364     const std::string& field_trial_name,
 365     const std::string& group_name) {
 366   base::FieldTrial* trial =
 367       base::FieldTrialList::CreateFieldTrial(field_trial_name, group_name);
 368   // TODO(mef): Remove this check after the investigation of 359406 is complete.
 369   CHECK(trial) << field_trial_name << ":" << group_name;
 370   // Ensure the trial is marked as "used" by calling group() on it. This is
 371   // needed to ensure the trial is properly reported in renderer crash reports.
 372   trial->group();
 373   chrome_variations::SetChildProcessLoggingVariationList();
 374 }
 375
 376 void ChromeRenderProcessObserver::OnGetV8HeapStats() {
 377   HeapStatisticsCollector::Instance()->InitiateCollection();
 378 }
 379
 380 const RendererContentSettingRules*
 381 ChromeRenderProcessObserver::content_setting_rules() const {
 382   return &content_setting_rules_;
 383 }