src/content/browser/renderer_host/render_message_filter.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 "content/browser/renderer_host/render_message_filter.h"
   6
   7 #include <map>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/command_line.h"
  12 #include "base/debug/alias.h"
  13 #include "base/strings/sys_string_conversions.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/threading/thread.h"
  16 #include "base/threading/worker_pool.h"
  17 #include "content/browser/browser_main_loop.h"
  18 #include "content/browser/child_process_security_policy_impl.h"
  19 #include "content/browser/dom_storage/dom_storage_context_wrapper.h"
  20 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
  21 #include "content/browser/download/download_stats.h"
  22 #include "content/browser/gpu/gpu_data_manager_impl.h"
  23 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  24 #include "content/browser/media/media_internals.h"
  25 #include "content/browser/plugin_process_host.h"
  26 #include "content/browser/plugin_service_impl.h"
  27 #include "content/browser/ppapi_plugin_process_host.h"
  28 #include "content/browser/renderer_host/pepper/pepper_security_helper.h"
  29 #include "content/browser/renderer_host/render_process_host_impl.h"
  30 #include "content/browser/renderer_host/render_view_host_delegate.h"
  31 #include "content/browser/renderer_host/render_widget_helper.h"
  32 #include "content/common/child_process_host_impl.h"
  33 #include "content/common/child_process_messages.h"
  34 #include "content/common/cookie_data.h"
  35 #include "content/common/desktop_notification_messages.h"
  36 #include "content/common/frame_messages.h"
  37 #include "content/common/host_shared_bitmap_manager.h"
  38 #include "content/common/media/media_param_traits.h"
  39 #include "content/common/view_messages.h"
  40 #include "content/public/browser/browser_child_process_host.h"
  41 #include "content/public/browser/browser_context.h"
  42 #include "content/public/browser/browser_thread.h"
  43 #include "content/public/browser/content_browser_client.h"
  44 #include "content/public/browser/download_save_info.h"
  45 #include "content/public/browser/plugin_service_filter.h"
  46 #include "content/public/browser/resource_context.h"
  47 #include "content/public/browser/user_metrics.h"
  48 #include "content/public/common/content_constants.h"
  49 #include "content/public/common/content_switches.h"
  50 #include "content/public/common/context_menu_params.h"
  51 #include "content/public/common/url_constants.h"
  52 #include "content/public/common/webplugininfo.h"
  53 #include "ipc/ipc_channel_handle.h"
  54 #include "ipc/ipc_platform_file.h"
  55 #include "media/audio/audio_manager.h"
  56 #include "media/audio/audio_manager_base.h"
  57 #include "media/audio/audio_parameters.h"
  58 #include "media/base/media_log_event.h"
  59 #include "net/base/io_buffer.h"
  60 #include "net/base/keygen_handler.h"
  61 #include "net/base/mime_util.h"
  62 #include "net/base/request_priority.h"
  63 #include "net/cookies/canonical_cookie.h"
  64 #include "net/cookies/cookie_store.h"
  65 #include "net/http/http_cache.h"
  66 #include "net/url_request/url_request_context.h"
  67 #include "net/url_request/url_request_context_getter.h"
  68 #include "ppapi/shared_impl/file_type_conversion.h"
  69 #include "third_party/WebKit/public/web/WebNotificationPresenter.h"
  70 #include "ui/gfx/color_profile.h"
  71
  72 #if defined(OS_MACOSX)
  73 #include "content/common/mac/font_descriptor.h"
  74 #else
  75 #include "gpu/GLES2/gl2extchromium.h"
  76 #include "third_party/khronos/GLES2/gl2.h"
  77 #include "third_party/khronos/GLES2/gl2ext.h"
  78 #endif
  79 #if defined(OS_POSIX)
  80 #include "base/file_descriptor_posix.h"
  81 #endif
  82 #if defined(OS_WIN)
  83 #include "content/common/font_cache_dispatcher_win.h"
  84 #include "content/common/sandbox_win.h"
  85 #endif
  86 #if defined(OS_ANDROID)
  87 #include "media/base/android/webaudio_media_codec_bridge.h"
  88 #endif
  89
  90 using net::CookieStore;
  91
  92 namespace content {
  93 namespace {
  94
  95 #if defined(ENABLE_PLUGINS)
  96 const int kPluginsRefreshThresholdInSeconds = 3;
  97 #endif
  98
  99 // When two CPU usage queries arrive within this interval, we sample the CPU
 100 // usage only once and send it as a response for both queries.
 101 static const int64 kCPUUsageSampleIntervalMs = 900;
 102
 103 const uint32 kFilteredMessageClasses[] = {
 104   ChildProcessMsgStart,
 105   DesktopNotificationMsgStart,
 106   FrameMsgStart,
 107   ViewMsgStart,
 108 };
 109
 110 #if defined(OS_WIN)
 111 // On Windows, |g_color_profile| can run on an arbitrary background thread.
 112 // We avoid races by using LazyInstance's constructor lock to initialize the
 113 // object.
 114 base::LazyInstance<gfx::ColorProfile>::Leaky g_color_profile =
 115     LAZY_INSTANCE_INITIALIZER;
 116 #endif
 117
 118 // Common functionality for converting a sync renderer message to a callback
 119 // function in the browser. Derive from this, create it on the heap when
 120 // issuing your callback. When done, write your reply parameters into
 121 // reply_msg(), and then call SendReplyAndDeleteThis().
 122 class RenderMessageCompletionCallback {
 123  public:
 124   RenderMessageCompletionCallback(RenderMessageFilter* filter,
 125                                   IPC::Message* reply_msg)
 126       : filter_(filter),
 127         reply_msg_(reply_msg) {
 128   }
 129
 130   virtual ~RenderMessageCompletionCallback() {
 131   }
 132
 133   RenderMessageFilter* filter() { return filter_.get(); }
 134   IPC::Message* reply_msg() { return reply_msg_; }
 135
 136   void SendReplyAndDeleteThis() {
 137     filter_->Send(reply_msg_);
 138     delete this;
 139   }
 140
 141  private:
 142   scoped_refptr<RenderMessageFilter> filter_;
 143   IPC::Message* reply_msg_;
 144 };
 145
 146 class OpenChannelToPpapiPluginCallback
 147     : public RenderMessageCompletionCallback,
 148       public PpapiPluginProcessHost::PluginClient {
 149  public:
 150   OpenChannelToPpapiPluginCallback(RenderMessageFilter* filter,
 151                                    ResourceContext* context,
 152                                    IPC::Message* reply_msg)
 153       : RenderMessageCompletionCallback(filter, reply_msg),
 154         context_(context) {
 155   }
 156
 157   virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
 158                                    int* renderer_id) OVERRIDE {
 159     *renderer_handle = filter()->PeerHandle();
 160     *renderer_id = filter()->render_process_id();
 161   }
 162
 163   virtual void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
 164                                     base::ProcessId plugin_pid,
 165                                     int plugin_child_id) OVERRIDE {
 166     ViewHostMsg_OpenChannelToPepperPlugin::WriteReplyParams(
 167         reply_msg(), channel_handle, plugin_pid, plugin_child_id);
 168     SendReplyAndDeleteThis();
 169   }
 170
 171   virtual bool OffTheRecord() OVERRIDE {
 172     return filter()->OffTheRecord();
 173   }
 174
 175   virtual ResourceContext* GetResourceContext() OVERRIDE {
 176     return context_;
 177   }
 178
 179  private:
 180   ResourceContext* context_;
 181 };
 182
 183 class OpenChannelToPpapiBrokerCallback
 184     : public PpapiPluginProcessHost::BrokerClient {
 185  public:
 186   OpenChannelToPpapiBrokerCallback(RenderMessageFilter* filter,
 187                                    int routing_id)
 188       : filter_(filter),
 189         routing_id_(routing_id) {
 190   }
 191
 192   virtual ~OpenChannelToPpapiBrokerCallback() {}
 193
 194   virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
 195                                    int* renderer_id) OVERRIDE {
 196     *renderer_handle = filter_->PeerHandle();
 197     *renderer_id = filter_->render_process_id();
 198   }
 199
 200   virtual void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
 201                                     base::ProcessId plugin_pid,
 202                                     int /* plugin_child_id */) OVERRIDE {
 203     filter_->Send(new ViewMsg_PpapiBrokerChannelCreated(routing_id_,
 204                                                         plugin_pid,
 205                                                         channel_handle));
 206     delete this;
 207   }
 208
 209   virtual bool OffTheRecord() OVERRIDE {
 210     return filter_->OffTheRecord();
 211   }
 212
 213  private:
 214   scoped_refptr<RenderMessageFilter> filter_;
 215   int routing_id_;
 216 };
 217
 218 }  // namespace
 219
 220 class RenderMessageFilter::OpenChannelToNpapiPluginCallback
 221     : public RenderMessageCompletionCallback,
 222       public PluginProcessHost::Client {
 223  public:
 224   OpenChannelToNpapiPluginCallback(RenderMessageFilter* filter,
 225                                    ResourceContext* context,
 226                                    IPC::Message* reply_msg)
 227       : RenderMessageCompletionCallback(filter, reply_msg),
 228         context_(context),
 229         host_(NULL),
 230         sent_plugin_channel_request_(false) {
 231   }
 232
 233   virtual int ID() OVERRIDE {
 234     return filter()->render_process_id();
 235   }
 236
 237   virtual ResourceContext* GetResourceContext() OVERRIDE {
 238     return context_;
 239   }
 240
 241   virtual bool OffTheRecord() OVERRIDE {
 242     if (filter()->OffTheRecord())
 243       return true;
 244     if (GetContentClient()->browser()->AllowSaveLocalState(context_))
 245       return false;
 246
 247     // For now, only disallow storing data for Flash <http://crbug.com/97319>.
 248     for (size_t i = 0; i < info_.mime_types.size(); ++i) {
 249       if (info_.mime_types[i].mime_type == kFlashPluginSwfMimeType)
 250         return true;
 251     }
 252     return false;
 253   }
 254
 255   virtual void SetPluginInfo(const WebPluginInfo& info) OVERRIDE {
 256     info_ = info;
 257   }
 258
 259   virtual void OnFoundPluginProcessHost(PluginProcessHost* host) OVERRIDE {
 260     DCHECK(host);
 261     host_ = host;
 262   }
 263
 264   virtual void OnSentPluginChannelRequest() OVERRIDE {
 265     sent_plugin_channel_request_ = true;
 266   }
 267
 268   virtual void OnChannelOpened(const IPC::ChannelHandle& handle) OVERRIDE {
 269     WriteReplyAndDeleteThis(handle);
 270   }
 271
 272   virtual void OnError() OVERRIDE {
 273     WriteReplyAndDeleteThis(IPC::ChannelHandle());
 274   }
 275
 276   PluginProcessHost* host() const {
 277     return host_;
 278   }
 279
 280   bool sent_plugin_channel_request() const {
 281     return sent_plugin_channel_request_;
 282   }
 283
 284   void Cancel() {
 285     delete this;
 286   }
 287
 288  private:
 289   void WriteReplyAndDeleteThis(const IPC::ChannelHandle& handle) {
 290     FrameHostMsg_OpenChannelToPlugin::WriteReplyParams(reply_msg(),
 291                                                        handle, info_);
 292     filter()->OnCompletedOpenChannelToNpapiPlugin(this);
 293     SendReplyAndDeleteThis();
 294   }
 295
 296   ResourceContext* context_;
 297   WebPluginInfo info_;
 298   PluginProcessHost* host_;
 299   bool sent_plugin_channel_request_;
 300 };
 301
 302 RenderMessageFilter::RenderMessageFilter(
 303     int render_process_id,
 304     PluginServiceImpl* plugin_service,
 305     BrowserContext* browser_context,
 306     net::URLRequestContextGetter* request_context,
 307     RenderWidgetHelper* render_widget_helper,
 308     media::AudioManager* audio_manager,
 309     MediaInternals* media_internals,
 310     DOMStorageContextWrapper* dom_storage_context)
 311     : BrowserMessageFilter(
 312           kFilteredMessageClasses, arraysize(kFilteredMessageClasses)),
 313       resource_dispatcher_host_(ResourceDispatcherHostImpl::Get()),
 314       plugin_service_(plugin_service),
 315       profile_data_directory_(browser_context->GetPath()),
 316       request_context_(request_context),
 317       resource_context_(browser_context->GetResourceContext()),
 318       render_widget_helper_(render_widget_helper),
 319       incognito_(browser_context->IsOffTheRecord()),
 320       dom_storage_context_(dom_storage_context),
 321       render_process_id_(render_process_id),
 322       cpu_usage_(0),
 323       audio_manager_(audio_manager),
 324       media_internals_(media_internals) {
 325   DCHECK(request_context_.get());
 326
 327   render_widget_helper_->Init(render_process_id_, resource_dispatcher_host_);
 328 }
 329
 330 RenderMessageFilter::~RenderMessageFilter() {
 331   // This function should be called on the IO thread.
 332   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 333   DCHECK(plugin_host_clients_.empty());
 334   HostSharedBitmapManager::current()->ProcessRemoved(PeerHandle());
 335 }
 336
 337 void RenderMessageFilter::OnChannelClosing() {
 338 #if defined(ENABLE_PLUGINS)
 339   for (std::set<OpenChannelToNpapiPluginCallback*>::iterator it =
 340        plugin_host_clients_.begin(); it != plugin_host_clients_.end(); ++it) {
 341     OpenChannelToNpapiPluginCallback* client = *it;
 342     if (client->host()) {
 343       if (client->sent_plugin_channel_request()) {
 344         client->host()->CancelSentRequest(client);
 345       } else {
 346         client->host()->CancelPendingRequest(client);
 347       }
 348     } else {
 349       plugin_service_->CancelOpenChannelToNpapiPlugin(client);
 350     }
 351     client->Cancel();
 352   }
 353 #endif  // defined(ENABLE_PLUGINS)
 354   plugin_host_clients_.clear();
 355 }
 356
 357 void RenderMessageFilter::OnChannelConnected(int32 peer_id) {
 358   base::ProcessHandle handle = PeerHandle();
 359 #if defined(OS_MACOSX)
 360   process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle,
 361                                                                     NULL));
 362 #else
 363   process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
 364 #endif
 365   cpu_usage_ = process_metrics_->GetCPUUsage(); // Initialize CPU usage counters
 366   cpu_usage_sample_time_ = base::TimeTicks::Now();
 367 }
 368
 369 bool RenderMessageFilter::OnMessageReceived(const IPC::Message& message) {
 370   bool handled = true;
 371   IPC_BEGIN_MESSAGE_MAP(RenderMessageFilter, message)
 372 #if defined(OS_WIN)
 373     IPC_MESSAGE_HANDLER(ViewHostMsg_PreCacheFontCharacters,
 374                         OnPreCacheFontCharacters)
 375 #endif
 376     IPC_MESSAGE_HANDLER(ViewHostMsg_GetProcessMemorySizes,
 377                         OnGetProcessMemorySizes)
 378     IPC_MESSAGE_HANDLER(ViewHostMsg_GenerateRoutingID, OnGenerateRoutingID)
 379     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWindow, OnCreateWindow)
 380     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWidget, OnCreateWidget)
 381     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateFullscreenWidget,
 382                         OnCreateFullscreenWidget)
 383     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCookie, OnSetCookie)
 384     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetCookies, OnGetCookies)
 385     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRawCookies, OnGetRawCookies)
 386     IPC_MESSAGE_HANDLER(ViewHostMsg_DeleteCookie, OnDeleteCookie)
 387     IPC_MESSAGE_HANDLER(ViewHostMsg_CookiesEnabled, OnCookiesEnabled)
 388 #if defined(OS_MACOSX)
 389     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_LoadFont, OnLoadFont)
 390 #endif
 391     IPC_MESSAGE_HANDLER(ViewHostMsg_DownloadUrl, OnDownloadUrl)
 392 #if defined(ENABLE_PLUGINS)
 393     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPlugins, OnGetPlugins)
 394     IPC_MESSAGE_HANDLER(FrameHostMsg_GetPluginInfo, OnGetPluginInfo)
 395     IPC_MESSAGE_HANDLER_DELAY_REPLY(FrameHostMsg_OpenChannelToPlugin,
 396                                     OnOpenChannelToPlugin)
 397     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPepperPlugin,
 398                                     OnOpenChannelToPepperPlugin)
 399     IPC_MESSAGE_HANDLER(ViewHostMsg_DidCreateOutOfProcessPepperInstance,
 400                         OnDidCreateOutOfProcessPepperInstance)
 401     IPC_MESSAGE_HANDLER(ViewHostMsg_DidDeleteOutOfProcessPepperInstance,
 402                         OnDidDeleteOutOfProcessPepperInstance)
 403     IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToPpapiBroker,
 404                         OnOpenChannelToPpapiBroker)
 405 #endif
 406     IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_SwapCompositorFrame,
 407         render_widget_helper_->DidReceiveBackingStoreMsg(message))
 408     IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_UpdateRect,
 409         render_widget_helper_->DidReceiveBackingStoreMsg(message))
 410     IPC_MESSAGE_HANDLER(DesktopNotificationHostMsg_CheckPermission,
 411                         OnCheckNotificationPermission)
 412     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedMemory,
 413                         OnAllocateSharedMemory)
 414     IPC_MESSAGE_HANDLER_DELAY_REPLY(
 415         ChildProcessHostMsg_SyncAllocateSharedBitmap, OnAllocateSharedBitmap)
 416     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_AllocatedSharedBitmap,
 417                         OnAllocatedSharedBitmap)
 418     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_DeletedSharedBitmap,
 419                         OnDeletedSharedBitmap)
 420 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 421     IPC_MESSAGE_HANDLER(ViewHostMsg_AllocTransportDIB, OnAllocTransportDIB)
 422     IPC_MESSAGE_HANDLER(ViewHostMsg_FreeTransportDIB, OnFreeTransportDIB)
 423 #endif
 424     IPC_MESSAGE_HANDLER(ViewHostMsg_DidGenerateCacheableMetadata,
 425                         OnCacheableMetadataAvailable)
 426     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_Keygen, OnKeygen)
 427     IPC_MESSAGE_HANDLER(ViewHostMsg_GetCPUUsage, OnGetCPUUsage)
 428     IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig,
 429                         OnGetAudioHardwareConfig)
 430 #if defined(OS_WIN)
 431     IPC_MESSAGE_HANDLER(ViewHostMsg_GetMonitorColorProfile,
 432                         OnGetMonitorColorProfile)
 433 #endif
 434     IPC_MESSAGE_HANDLER(ViewHostMsg_MediaLogEvents, OnMediaLogEvents)
 435     IPC_MESSAGE_HANDLER(ViewHostMsg_Are3DAPIsBlocked, OnAre3DAPIsBlocked)
 436     IPC_MESSAGE_HANDLER(ViewHostMsg_DidLose3DContext, OnDidLose3DContext)
 437 #if defined(OS_ANDROID)
 438     IPC_MESSAGE_HANDLER(ViewHostMsg_RunWebAudioMediaCodec, OnWebAudioMediaCodec)
 439 #endif
 440     IPC_MESSAGE_UNHANDLED(handled = false)
 441   IPC_END_MESSAGE_MAP()
 442
 443   return handled;
 444 }
 445
 446 void RenderMessageFilter::OnDestruct() const {
 447   BrowserThread::DeleteOnIOThread::Destruct(this);
 448 }
 449
 450 base::TaskRunner* RenderMessageFilter::OverrideTaskRunnerForMessage(
 451     const IPC::Message& message) {
 452 #if defined(OS_WIN)
 453   // Windows monitor profile must be read from a file.
 454   if (message.type() == ViewHostMsg_GetMonitorColorProfile::ID)
 455     return BrowserThread::GetBlockingPool();
 456 #endif
 457   // Always query audio device parameters on the audio thread.
 458   if (message.type() == ViewHostMsg_GetAudioHardwareConfig::ID)
 459     return audio_manager_->GetTaskRunner().get();
 460   return NULL;
 461 }
 462
 463 bool RenderMessageFilter::OffTheRecord() const {
 464   return incognito_;
 465 }
 466
 467 void RenderMessageFilter::OnCreateWindow(
 468     const ViewHostMsg_CreateWindow_Params& params,
 469     int* route_id,
 470     int* main_frame_route_id,
 471     int* surface_id,
 472     int64* cloned_session_storage_namespace_id) {
 473   bool no_javascript_access;
 474
 475   // Merge the additional features into the WebWindowFeatures struct before we
 476   // pass it on.
 477   blink::WebVector<blink::WebString> additional_features(
 478       params.additional_features.size());
 479
 480   for (size_t i = 0; i < params.additional_features.size(); ++i)
 481     additional_features[i] = blink::WebString(params.additional_features[i]);
 482
 483   blink::WebWindowFeatures features = params.features;
 484   features.additionalFeatures.swap(additional_features);
 485
 486   bool can_create_window =
 487       GetContentClient()->browser()->CanCreateWindow(
 488           params.opener_url,
 489           params.opener_top_level_frame_url,
 490           params.opener_security_origin,
 491           params.window_container_type,
 492           params.target_url,
 493           params.referrer,
 494           params.disposition,
 495           features,
 496           params.user_gesture,
 497           params.opener_suppressed,
 498           resource_context_,
 499           render_process_id_,
 500           params.opener_id,
 501           &no_javascript_access);
 502
 503   if (!can_create_window) {
 504     *route_id = MSG_ROUTING_NONE;
 505     *main_frame_route_id = MSG_ROUTING_NONE;
 506     *surface_id = 0;
 507     return;
 508   }
 509
 510   // This will clone the sessionStorage for namespace_id_to_clone.
 511   scoped_refptr<SessionStorageNamespaceImpl> cloned_namespace =
 512       new SessionStorageNamespaceImpl(dom_storage_context_.get(),
 513                                       params.session_storage_namespace_id);
 514   *cloned_session_storage_namespace_id = cloned_namespace->id();
 515
 516   render_widget_helper_->CreateNewWindow(params,
 517                                          no_javascript_access,
 518                                          PeerHandle(),
 519                                          route_id,
 520                                          main_frame_route_id,
 521                                          surface_id,
 522                                          cloned_namespace.get());
 523 }
 524
 525 void RenderMessageFilter::OnCreateWidget(int opener_id,
 526                                          blink::WebPopupType popup_type,
 527                                          int* route_id,
 528                                          int* surface_id) {
 529   render_widget_helper_->CreateNewWidget(
 530       opener_id, popup_type, route_id, surface_id);
 531 }
 532
 533 void RenderMessageFilter::OnCreateFullscreenWidget(int opener_id,
 534                                                    int* route_id,
 535                                                    int* surface_id) {
 536   render_widget_helper_->CreateNewFullscreenWidget(
 537       opener_id, route_id, surface_id);
 538 }
 539
 540 void RenderMessageFilter::OnGetProcessMemorySizes(size_t* private_bytes,
 541                                                   size_t* shared_bytes) {
 542   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 543   using base::ProcessMetrics;
 544 #if !defined(OS_MACOSX) || defined(OS_IOS)
 545   scoped_ptr<ProcessMetrics> metrics(ProcessMetrics::CreateProcessMetrics(
 546       PeerHandle()));
 547 #else
 548   scoped_ptr<ProcessMetrics> metrics(ProcessMetrics::CreateProcessMetrics(
 549       PeerHandle(), content::BrowserChildProcessHost::GetPortProvider()));
 550 #endif
 551   if (!metrics->GetMemoryBytes(private_bytes, shared_bytes)) {
 552     *private_bytes = 0;
 553     *shared_bytes = 0;
 554   }
 555 }
 556
 557 void RenderMessageFilter::OnSetCookie(int render_frame_id,
 558                                       const GURL& url,
 559                                       const GURL& first_party_for_cookies,
 560                                       const std::string& cookie) {
 561   ChildProcessSecurityPolicyImpl* policy =
 562       ChildProcessSecurityPolicyImpl::GetInstance();
 563   if (!policy->CanAccessCookiesForOrigin(render_process_id_, url))
 564     return;
 565
 566   net::CookieOptions options;
 567   if (GetContentClient()->browser()->AllowSetCookie(
 568           url, first_party_for_cookies, cookie, resource_context_,
 569           render_process_id_, render_frame_id, &options)) {
 570     net::CookieStore* cookie_store = GetCookieStoreForURL(url);
 571     // Pass a null callback since we don't care about when the 'set' completes.
 572     cookie_store->SetCookieWithOptionsAsync(
 573         url, cookie, options, net::CookieStore::SetCookiesCallback());
 574   }
 575 }
 576
 577 void RenderMessageFilter::OnGetCookies(int render_frame_id,
 578                                        const GURL& url,
 579                                        const GURL& first_party_for_cookies,
 580                                        IPC::Message* reply_msg) {
 581   ChildProcessSecurityPolicyImpl* policy =
 582       ChildProcessSecurityPolicyImpl::GetInstance();
 583   if (!policy->CanAccessCookiesForOrigin(render_process_id_, url)) {
 584     SendGetCookiesResponse(reply_msg, std::string());
 585     return;
 586   }
 587
 588   // If we crash here, figure out what URL the renderer was requesting.
 589   // http://crbug.com/99242
 590   char url_buf[128];
 591   base::strlcpy(url_buf, url.spec().c_str(), arraysize(url_buf));
 592   base::debug::Alias(url_buf);
 593
 594   net::CookieStore* cookie_store = GetCookieStoreForURL(url);
 595   cookie_store->GetAllCookiesForURLAsync(
 596       url, base::Bind(&RenderMessageFilter::CheckPolicyForCookies, this,
 597                       render_frame_id, url, first_party_for_cookies,
 598                       reply_msg));
 599 }
 600
 601 void RenderMessageFilter::OnGetRawCookies(
 602     const GURL& url,
 603     const GURL& first_party_for_cookies,
 604     IPC::Message* reply_msg) {
 605   ChildProcessSecurityPolicyImpl* policy =
 606       ChildProcessSecurityPolicyImpl::GetInstance();
 607   // Only return raw cookies to trusted renderers or if this request is
 608   // not targeted to an an external host like ChromeFrame.
 609   // TODO(ananta) We need to support retreiving raw cookies from external
 610   // hosts.
 611   if (!policy->CanReadRawCookies(render_process_id_) ||
 612       !policy->CanAccessCookiesForOrigin(render_process_id_, url)) {
 613     SendGetRawCookiesResponse(reply_msg, net::CookieList());
 614     return;
 615   }
 616
 617   // We check policy here to avoid sending back cookies that would not normally
 618   // be applied to outbound requests for the given URL.  Since this cookie info
 619   // is visible in the developer tools, it is helpful to make it match reality.
 620   net::CookieStore* cookie_store = GetCookieStoreForURL(url);
 621   cookie_store->GetAllCookiesForURLAsync(
 622       url, base::Bind(&RenderMessageFilter::SendGetRawCookiesResponse,
 623                       this, reply_msg));
 624 }
 625
 626 void RenderMessageFilter::OnDeleteCookie(const GURL& url,
 627                                          const std::string& cookie_name) {
 628   ChildProcessSecurityPolicyImpl* policy =
 629       ChildProcessSecurityPolicyImpl::GetInstance();
 630   if (!policy->CanAccessCookiesForOrigin(render_process_id_, url))
 631     return;
 632
 633   net::CookieStore* cookie_store = GetCookieStoreForURL(url);
 634   cookie_store->DeleteCookieAsync(url, cookie_name, base::Closure());
 635 }
 636
 637 void RenderMessageFilter::OnCookiesEnabled(
 638     int render_frame_id,
 639     const GURL& url,
 640     const GURL& first_party_for_cookies,
 641     bool* cookies_enabled) {
 642   // TODO(ananta): If this render view is associated with an automation channel,
 643   // aka ChromeFrame then we need to retrieve cookie settings from the external
 644   // host.
 645   *cookies_enabled = GetContentClient()->browser()->AllowGetCookie(
 646       url, first_party_for_cookies, net::CookieList(), resource_context_,
 647       render_process_id_, render_frame_id);
 648 }
 649
 650 #if defined(OS_MACOSX)
 651 void RenderMessageFilter::OnLoadFont(const FontDescriptor& font,
 652                                      IPC::Message* reply_msg) {
 653   FontLoader::Result* result = new FontLoader::Result;
 654
 655   BrowserThread::PostTaskAndReply(
 656       BrowserThread::FILE, FROM_HERE,
 657       base::Bind(&FontLoader::LoadFont, font, result),
 658       base::Bind(&RenderMessageFilter::SendLoadFontReply, this, reply_msg,
 659                  base::Owned(result)));
 660 }
 661
 662 void RenderMessageFilter::SendLoadFontReply(IPC::Message* reply,
 663                                             FontLoader::Result* result) {
 664   base::SharedMemoryHandle handle;
 665   if (result->font_data_size == 0 || result->font_id == 0) {
 666     result->font_data_size = 0;
 667     result->font_id = 0;
 668     handle = base::SharedMemory::NULLHandle();
 669   } else {
 670     result->font_data.GiveToProcess(base::GetCurrentProcessHandle(), &handle);
 671   }
 672   ViewHostMsg_LoadFont::WriteReplyParams(
 673       reply, result->font_data_size, handle, result->font_id);
 674   Send(reply);
 675 }
 676 #endif  // OS_MACOSX
 677
 678 #if defined(ENABLE_PLUGINS)
 679 void RenderMessageFilter::OnGetPlugins(
 680     bool refresh,
 681     IPC::Message* reply_msg) {
 682   // Don't refresh if the specified threshold has not been passed.  Note that
 683   // this check is performed before off-loading to the file thread.  The reason
 684   // we do this is that some pages tend to request that the list of plugins be
 685   // refreshed at an excessive rate.  This instigates disk scanning, as the list
 686   // is accumulated by doing multiple reads from disk.  This effect is
 687   // multiplied when we have several pages requesting this operation.
 688   if (refresh) {
 689     const base::TimeDelta threshold = base::TimeDelta::FromSeconds(
 690         kPluginsRefreshThresholdInSeconds);
 691     const base::TimeTicks now = base::TimeTicks::Now();
 692     if (now - last_plugin_refresh_time_ >= threshold) {
 693       // Only refresh if the threshold hasn't been exceeded yet.
 694       PluginServiceImpl::GetInstance()->RefreshPlugins();
 695       last_plugin_refresh_time_ = now;
 696     }
 697   }
 698
 699   PluginServiceImpl::GetInstance()->GetPlugins(
 700       base::Bind(&RenderMessageFilter::GetPluginsCallback, this, reply_msg));
 701 }
 702
 703 void RenderMessageFilter::GetPluginsCallback(
 704     IPC::Message* reply_msg,
 705     const std::vector<WebPluginInfo>& all_plugins) {
 706   // Filter the plugin list.
 707   PluginServiceFilter* filter = PluginServiceImpl::GetInstance()->GetFilter();
 708   std::vector<WebPluginInfo> plugins;
 709
 710   int child_process_id = -1;
 711   int routing_id = MSG_ROUTING_NONE;
 712   for (size_t i = 0; i < all_plugins.size(); ++i) {
 713     // Copy because the filter can mutate.
 714     WebPluginInfo plugin(all_plugins[i]);
 715     if (!filter || filter->IsPluginAvailable(child_process_id,
 716                                              routing_id,
 717                                              resource_context_,
 718                                              GURL(),
 719                                              GURL(),
 720                                              &plugin)) {
 721       plugins.push_back(plugin);
 722     }
 723   }
 724
 725   ViewHostMsg_GetPlugins::WriteReplyParams(reply_msg, plugins);
 726   Send(reply_msg);
 727 }
 728
 729 void RenderMessageFilter::OnGetPluginInfo(
 730     int render_frame_id,
 731     const GURL& url,
 732     const GURL& page_url,
 733     const std::string& mime_type,
 734     bool* found,
 735     WebPluginInfo* info,
 736     std::string* actual_mime_type) {
 737   bool allow_wildcard = true;
 738   *found = plugin_service_->GetPluginInfo(
 739       render_process_id_, render_frame_id, resource_context_,
 740       url, page_url, mime_type, allow_wildcard,
 741       NULL, info, actual_mime_type);
 742 }
 743
 744 void RenderMessageFilter::OnOpenChannelToPlugin(int render_frame_id,
 745                                                 const GURL& url,
 746                                                 const GURL& policy_url,
 747                                                 const std::string& mime_type,
 748                                                 IPC::Message* reply_msg) {
 749   OpenChannelToNpapiPluginCallback* client =
 750       new OpenChannelToNpapiPluginCallback(this, resource_context_, reply_msg);
 751   DCHECK(!ContainsKey(plugin_host_clients_, client));
 752   plugin_host_clients_.insert(client);
 753   plugin_service_->OpenChannelToNpapiPlugin(
 754       render_process_id_, render_frame_id,
 755       url, policy_url, mime_type, client);
 756 }
 757
 758 void RenderMessageFilter::OnOpenChannelToPepperPlugin(
 759     const base::FilePath& path,
 760     IPC::Message* reply_msg) {
 761   plugin_service_->OpenChannelToPpapiPlugin(
 762       render_process_id_,
 763       path,
 764       profile_data_directory_,
 765       new OpenChannelToPpapiPluginCallback(this, resource_context_, reply_msg));
 766 }
 767
 768 void RenderMessageFilter::OnDidCreateOutOfProcessPepperInstance(
 769     int plugin_child_id,
 770     int32 pp_instance,
 771     PepperRendererInstanceData instance_data,
 772     bool is_external) {
 773   // It's important that we supply the render process ID ourselves based on the
 774   // channel the message arrived on. We use the
 775   //   PP_Instance -> (process id, view id)
 776   // mapping to decide how to handle messages received from the (untrusted)
 777   // plugin, so an exploited renderer must not be able to insert fake mappings
 778   // that may allow it access to other render processes.
 779   DCHECK_EQ(0, instance_data.render_process_id);
 780   instance_data.render_process_id = render_process_id_;
 781   if (is_external) {
 782     // We provide the BrowserPpapiHost to the embedder, so it's safe to cast.
 783     BrowserPpapiHostImpl* host = static_cast<BrowserPpapiHostImpl*>(
 784         GetContentClient()->browser()->GetExternalBrowserPpapiHost(
 785             plugin_child_id));
 786     if (host)
 787       host->AddInstance(pp_instance, instance_data);
 788   } else {
 789     PpapiPluginProcessHost::DidCreateOutOfProcessInstance(
 790         plugin_child_id, pp_instance, instance_data);
 791   }
 792 }
 793
 794 void RenderMessageFilter::OnDidDeleteOutOfProcessPepperInstance(
 795     int plugin_child_id,
 796     int32 pp_instance,
 797     bool is_external) {
 798   if (is_external) {
 799     // We provide the BrowserPpapiHost to the embedder, so it's safe to cast.
 800     BrowserPpapiHostImpl* host = static_cast<BrowserPpapiHostImpl*>(
 801         GetContentClient()->browser()->GetExternalBrowserPpapiHost(
 802             plugin_child_id));
 803     if (host)
 804       host->DeleteInstance(pp_instance);
 805   } else {
 806     PpapiPluginProcessHost::DidDeleteOutOfProcessInstance(
 807         plugin_child_id, pp_instance);
 808   }
 809 }
 810
 811 void RenderMessageFilter::OnOpenChannelToPpapiBroker(
 812     int routing_id,
 813     const base::FilePath& path) {
 814   plugin_service_->OpenChannelToPpapiBroker(
 815       render_process_id_,
 816       path,
 817       new OpenChannelToPpapiBrokerCallback(this, routing_id));
 818 }
 819 #endif  // defined(ENABLE_PLUGINS)
 820
 821 void RenderMessageFilter::OnGenerateRoutingID(int* route_id) {
 822   *route_id = render_widget_helper_->GetNextRoutingID();
 823 }
 824
 825 void RenderMessageFilter::OnGetCPUUsage(int* cpu_usage) {
 826   base::TimeTicks now = base::TimeTicks::Now();
 827   int64 since_last_sample_ms = (now - cpu_usage_sample_time_).InMilliseconds();
 828   if (since_last_sample_ms > kCPUUsageSampleIntervalMs) {
 829     cpu_usage_sample_time_ = now;
 830     cpu_usage_ = static_cast<int>(process_metrics_->GetCPUUsage());
 831   }
 832   *cpu_usage = cpu_usage_;
 833 }
 834
 835 void RenderMessageFilter::OnGetAudioHardwareConfig(
 836     media::AudioParameters* input_params,
 837     media::AudioParameters* output_params) {
 838   DCHECK(input_params);
 839   DCHECK(output_params);
 840   *output_params = audio_manager_->GetDefaultOutputStreamParameters();
 841
 842   // TODO(henrika): add support for all available input devices.
 843   *input_params = audio_manager_->GetInputStreamParameters(
 844       media::AudioManagerBase::kDefaultDeviceId);
 845 }
 846
 847 #if defined(OS_WIN)
 848 void RenderMessageFilter::OnGetMonitorColorProfile(std::vector<char>* profile) {
 849   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 850   *profile = g_color_profile.Get().profile();
 851 }
 852 #endif
 853
 854 void RenderMessageFilter::OnDownloadUrl(int render_view_id,
 855                                         const GURL& url,
 856                                         const Referrer& referrer,
 857                                         const base::string16& suggested_name,
 858                                         const bool use_prompt) {
 859   scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
 860   save_info->suggested_name = suggested_name;
 861   save_info->prompt_for_save_location = use_prompt;
 862
 863   // There may be a special cookie store that we could use for this download,
 864   // rather than the default one. Since this feature is generally only used for
 865   // proper render views, and not downloads, we do not need to retrieve the
 866   // special cookie store here, but just initialize the request to use the
 867   // default cookie store.
 868   // TODO(tburkard): retrieve the appropriate special cookie store, if this
 869   // is ever to be used for downloads as well.
 870   scoped_ptr<net::URLRequest> request(
 871       resource_context_->GetRequestContext()->CreateRequest(
 872           url, net::DEFAULT_PRIORITY, NULL, NULL));
 873   RecordDownloadSource(INITIATED_BY_RENDERER);
 874   resource_dispatcher_host_->BeginDownload(
 875       request.Pass(),
 876       referrer,
 877       true,  // is_content_initiated
 878       resource_context_,
 879       render_process_id_,
 880       render_view_id,
 881       false,
 882       save_info.Pass(),
 883       content::DownloadItem::kInvalidId,
 884       ResourceDispatcherHostImpl::DownloadStartedCallback());
 885 }
 886
 887 void RenderMessageFilter::OnCheckNotificationPermission(
 888     const GURL& source_origin, int* result) {
 889 #if defined(ENABLE_NOTIFICATIONS)
 890   *result = GetContentClient()->browser()->
 891       CheckDesktopNotificationPermission(source_origin, resource_context_,
 892                                          render_process_id_);
 893 #else
 894   *result = blink::WebNotificationPresenter::PermissionAllowed;
 895 #endif
 896 }
 897
 898 void RenderMessageFilter::OnAllocateSharedMemory(
 899     uint32 buffer_size,
 900     base::SharedMemoryHandle* handle) {
 901   ChildProcessHostImpl::AllocateSharedMemory(
 902       buffer_size, PeerHandle(), handle);
 903 }
 904
 905 void RenderMessageFilter::AllocateSharedBitmapOnFileThread(
 906     uint32 buffer_size,
 907     const cc::SharedBitmapId& id,
 908     IPC::Message* reply_msg) {
 909   base::SharedMemoryHandle handle;
 910   HostSharedBitmapManager::current()->AllocateSharedBitmapForChild(
 911       PeerHandle(), buffer_size, id, &handle);
 912   ChildProcessHostMsg_SyncAllocateSharedBitmap::WriteReplyParams(reply_msg,
 913                                                                  handle);
 914   Send(reply_msg);
 915 }
 916
 917 void RenderMessageFilter::OnAllocateSharedBitmap(uint32 buffer_size,
 918                                                  const cc::SharedBitmapId& id,
 919                                                  IPC::Message* reply_msg) {
 920   BrowserThread::PostTask(
 921       BrowserThread::FILE_USER_BLOCKING,
 922       FROM_HERE,
 923       base::Bind(&RenderMessageFilter::AllocateSharedBitmapOnFileThread,
 924                  this,
 925                  buffer_size,
 926                  id,
 927                  reply_msg));
 928 }
 929
 930 void RenderMessageFilter::OnAllocatedSharedBitmap(
 931     size_t buffer_size,
 932     const base::SharedMemoryHandle& handle,
 933     const cc::SharedBitmapId& id) {
 934   HostSharedBitmapManager::current()->ChildAllocatedSharedBitmap(
 935       buffer_size, handle, PeerHandle(), id);
 936 }
 937
 938 void RenderMessageFilter::OnDeletedSharedBitmap(const cc::SharedBitmapId& id) {
 939   HostSharedBitmapManager::current()->ChildDeletedSharedBitmap(id);
 940 }
 941
 942 net::CookieStore* RenderMessageFilter::GetCookieStoreForURL(
 943     const GURL& url) {
 944   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 945
 946   net::URLRequestContext* context =
 947       GetContentClient()->browser()->OverrideRequestContextForURL(
 948           url, resource_context_);
 949
 950   // If we should use a special URLRequestContext rather than the default one,
 951   // return the cookie store of that special URLRequestContext.
 952   if (context)
 953     return context->cookie_store();
 954
 955   // Otherwise, if there is a special cookie store to be used for this process,
 956   // return that cookie store.
 957   net::CookieStore* cookie_store =
 958       GetContentClient()->browser()->OverrideCookieStoreForRenderProcess(
 959           render_process_id_);
 960   if (cookie_store)
 961     return cookie_store;
 962
 963   // Otherwise, return the cookie store of the default request context used
 964   // for this renderer.
 965   return request_context_->GetURLRequestContext()->cookie_store();
 966 }
 967
 968 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 969 void RenderMessageFilter::OnAllocTransportDIB(
 970     uint32 size, bool cache_in_browser, TransportDIB::Handle* handle) {
 971   render_widget_helper_->AllocTransportDIB(size, cache_in_browser, handle);
 972 }
 973
 974 void RenderMessageFilter::OnFreeTransportDIB(
 975     TransportDIB::Id dib_id) {
 976   render_widget_helper_->FreeTransportDIB(dib_id);
 977 }
 978 #endif
 979
 980 bool RenderMessageFilter::CheckPreparsedJsCachingEnabled() const {
 981   static bool checked = false;
 982   static bool result = false;
 983   if (!checked) {
 984     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 985     result = command_line.HasSwitch(switches::kEnablePreparsedJsCaching);
 986     checked = true;
 987   }
 988   return result;
 989 }
 990
 991 void RenderMessageFilter::OnCacheableMetadataAvailable(
 992     const GURL& url,
 993     double expected_response_time,
 994     const std::vector<char>& data) {
 995   if (!CheckPreparsedJsCachingEnabled())
 996     return;
 997
 998   net::HttpCache* cache = request_context_->GetURLRequestContext()->
 999       http_transaction_factory()->GetCache();
1000   DCHECK(cache);
1001
1002   // Use the same priority for the metadata write as for script
1003   // resources (see defaultPriorityForResourceType() in WebKit's
1004   // CachedResource.cpp). Note that WebURLRequest::PriorityMedium
1005   // corresponds to net::LOW (see ConvertWebKitPriorityToNetPriority()
1006   // in weburlloader_impl.cc).
1007   const net::RequestPriority kPriority = net::LOW;
1008   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(data.size()));
1009   memcpy(buf->data(), &data.front(), data.size());
1010   cache->WriteMetadata(url,
1011                        kPriority,
1012                        base::Time::FromDoubleT(expected_response_time),
1013                        buf.get(),
1014                        data.size());
1015 }
1016
1017 void RenderMessageFilter::OnKeygen(uint32 key_size_index,
1018                                    const std::string& challenge_string,
1019                                    const GURL& url,
1020                                    IPC::Message* reply_msg) {
1021   // Map displayed strings indicating level of keysecurity in the <keygen>
1022   // menu to the key size in bits. (See SSLKeyGeneratorChromium.cpp in WebCore.)
1023   int key_size_in_bits;
1024   switch (key_size_index) {
1025     case 0:
1026       key_size_in_bits = 2048;
1027       break;
1028     case 1:
1029       key_size_in_bits = 1024;
1030       break;
1031     default:
1032       DCHECK(false) << "Illegal key_size_index " << key_size_index;
1033       ViewHostMsg_Keygen::WriteReplyParams(reply_msg, std::string());
1034       Send(reply_msg);
1035       return;
1036   }
1037
1038   resource_context_->CreateKeygenHandler(
1039       key_size_in_bits,
1040       challenge_string,
1041       url,
1042       base::Bind(
1043           &RenderMessageFilter::PostKeygenToWorkerThread, this, reply_msg));
1044 }
1045
1046 void RenderMessageFilter::PostKeygenToWorkerThread(
1047     IPC::Message* reply_msg,
1048     scoped_ptr<net::KeygenHandler> keygen_handler) {
1049   VLOG(1) << "Dispatching keygen task to worker pool.";
1050   // Dispatch to worker pool, so we do not block the IO thread.
1051   if (!base::WorkerPool::PostTask(
1052            FROM_HERE,
1053            base::Bind(&RenderMessageFilter::OnKeygenOnWorkerThread,
1054                       this,
1055                       base::Passed(&keygen_handler),
1056                       reply_msg),
1057            true)) {
1058     NOTREACHED() << "Failed to dispatch keygen task to worker pool";
1059     ViewHostMsg_Keygen::WriteReplyParams(reply_msg, std::string());
1060     Send(reply_msg);
1061   }
1062 }
1063
1064 void RenderMessageFilter::OnKeygenOnWorkerThread(
1065     scoped_ptr<net::KeygenHandler> keygen_handler,
1066     IPC::Message* reply_msg) {
1067   DCHECK(reply_msg);
1068
1069   // Generate a signed public key and challenge, then send it back.
1070   ViewHostMsg_Keygen::WriteReplyParams(
1071       reply_msg,
1072       keygen_handler->GenKeyAndSignChallenge());
1073   Send(reply_msg);
1074 }
1075
1076 void RenderMessageFilter::OnMediaLogEvents(
1077     const std::vector<media::MediaLogEvent>& events) {
1078   if (media_internals_)
1079     media_internals_->OnMediaEvents(render_process_id_, events);
1080 }
1081
1082 void RenderMessageFilter::CheckPolicyForCookies(
1083     int render_frame_id,
1084     const GURL& url,
1085     const GURL& first_party_for_cookies,
1086     IPC::Message* reply_msg,
1087     const net::CookieList& cookie_list) {
1088   net::CookieStore* cookie_store = GetCookieStoreForURL(url);
1089   // Check the policy for get cookies, and pass cookie_list to the
1090   // TabSpecificContentSetting for logging purpose.
1091   if (GetContentClient()->browser()->AllowGetCookie(
1092           url, first_party_for_cookies, cookie_list, resource_context_,
1093           render_process_id_, render_frame_id)) {
1094     // Gets the cookies from cookie store if allowed.
1095     cookie_store->GetCookiesWithOptionsAsync(
1096         url, net::CookieOptions(),
1097         base::Bind(&RenderMessageFilter::SendGetCookiesResponse,
1098                    this, reply_msg));
1099   } else {
1100     SendGetCookiesResponse(reply_msg, std::string());
1101   }
1102 }
1103
1104 void RenderMessageFilter::SendGetCookiesResponse(IPC::Message* reply_msg,
1105                                                  const std::string& cookies) {
1106   ViewHostMsg_GetCookies::WriteReplyParams(reply_msg, cookies);
1107   Send(reply_msg);
1108 }
1109
1110 void RenderMessageFilter::SendGetRawCookiesResponse(
1111     IPC::Message* reply_msg,
1112     const net::CookieList& cookie_list) {
1113   std::vector<CookieData> cookies;
1114   for (size_t i = 0; i < cookie_list.size(); ++i)
1115     cookies.push_back(CookieData(cookie_list[i]));
1116   ViewHostMsg_GetRawCookies::WriteReplyParams(reply_msg, cookies);
1117   Send(reply_msg);
1118 }
1119
1120 void RenderMessageFilter::OnCompletedOpenChannelToNpapiPlugin(
1121     OpenChannelToNpapiPluginCallback* client) {
1122   DCHECK_CURRENTLY_ON(BrowserThread::IO);
1123   DCHECK(ContainsKey(plugin_host_clients_, client));
1124   plugin_host_clients_.erase(client);
1125 }
1126
1127 void RenderMessageFilter::OnAre3DAPIsBlocked(int render_view_id,
1128                                              const GURL& top_origin_url,
1129                                              ThreeDAPIType requester,
1130                                              bool* blocked) {
1131   *blocked = GpuDataManagerImpl::GetInstance()->Are3DAPIsBlocked(
1132       top_origin_url, render_process_id_, render_view_id, requester);
1133 }
1134
1135 void RenderMessageFilter::OnDidLose3DContext(
1136     const GURL& top_origin_url,
1137     ThreeDAPIType /* unused */,
1138     int arb_robustness_status_code) {
1139 #if defined(OS_MACOSX)
1140     // TODO(kbr): this file indirectly includes npapi.h, which on Mac
1141     // OS pulls in the system OpenGL headers. For some
1142     // not-yet-investigated reason this breaks the build with the 10.6
1143     // SDK but not 10.7. For now work around this in a way compatible
1144     // with the Khronos headers.
1145 #ifndef GL_GUILTY_CONTEXT_RESET_ARB
1146 #define GL_GUILTY_CONTEXT_RESET_ARB 0x8253
1147 #endif
1148 #ifndef GL_INNOCENT_CONTEXT_RESET_ARB
1149 #define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254
1150 #endif
1151 #ifndef GL_UNKNOWN_CONTEXT_RESET_ARB
1152 #define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255
1153 #endif
1154
1155 #endif
1156   GpuDataManagerImpl::DomainGuilt guilt;
1157   switch (arb_robustness_status_code) {
1158     case GL_GUILTY_CONTEXT_RESET_ARB:
1159       guilt = GpuDataManagerImpl::DOMAIN_GUILT_KNOWN;
1160       break;
1161     case GL_UNKNOWN_CONTEXT_RESET_ARB:
1162       guilt = GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN;
1163       break;
1164     default:
1165       // Ignore lost contexts known to be innocent.
1166       return;
1167   }
1168
1169   GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
1170       top_origin_url, guilt);
1171 }
1172
1173 #if defined(OS_WIN)
1174 void RenderMessageFilter::OnPreCacheFontCharacters(const LOGFONT& font,
1175                                                    const base::string16& str) {
1176   // TODO(scottmg): pdf/ppapi still require the renderer to be able to precache
1177   // GDI fonts (http://crbug.com/383227), even when using DirectWrite.
1178   // Eventually this shouldn't be added and should be moved to
1179   // FontCacheDispatcher too. http://crbug.com/356346.
1180
1181   // First, comments from FontCacheDispatcher::OnPreCacheFont do apply here too.
1182   // Except that for True Type fonts,
1183   // GetTextMetrics will not load the font in memory.
1184   // The only way windows seem to load properly, it is to create a similar
1185   // device (like the one in which we print), then do an ExtTextOut,
1186   // as we do in the printing thread, which is sandboxed.
1187   HDC hdc = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
1188   HFONT font_handle = CreateFontIndirect(&font);
1189   DCHECK(NULL != font_handle);
1190
1191   HGDIOBJ old_font = SelectObject(hdc, font_handle);
1192   DCHECK(NULL != old_font);
1193
1194   ExtTextOut(hdc, 0, 0, ETO_GLYPH_INDEX, 0, str.c_str(), str.length(), NULL);
1195
1196   SelectObject(hdc, old_font);
1197   DeleteObject(font_handle);
1198
1199   HENHMETAFILE metafile = CloseEnhMetaFile(hdc);
1200
1201   if (metafile) {
1202     DeleteEnhMetaFile(metafile);
1203   }
1204 }
1205 #endif
1206
1207 #if defined(OS_ANDROID)
1208 void RenderMessageFilter::OnWebAudioMediaCodec(
1209     base::SharedMemoryHandle encoded_data_handle,
1210     base::FileDescriptor pcm_output,
1211     uint32_t data_size) {
1212   // Let a WorkerPool handle this request since the WebAudio
1213   // MediaCodec bridge is slow and can block while sending the data to
1214   // the renderer.
1215   base::WorkerPool::PostTask(
1216       FROM_HERE,
1217       base::Bind(&media::WebAudioMediaCodecBridge::RunWebAudioMediaCodec,
1218                  encoded_data_handle, pcm_output, data_size),
1219       true);
1220 }
1221 #endif
1222
1223 }  // namespace content