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/plugin/webplugin_proxy.h" 6 7 #include "build/build_config.h" 8 9 #include "base/bind.h" 10 #include "base/lazy_instance.h" 11 #include "base/memory/scoped_handle.h" 12 #include "base/memory/shared_memory.h" 13 #include "build/build_config.h" 14 #include "content/child/npapi/npobject_proxy.h" 15 #include "content/child/npapi/npobject_util.h" 16 #include "content/child/npapi/webplugin_delegate_impl.h" 17 #include "content/child/plugin_messages.h" 18 #include "content/plugin/plugin_channel.h" 19 #include "content/plugin/plugin_thread.h" 20 #include "content/public/common/content_client.h" 21 #include "content/public/common/url_constants.h" 22 #include "skia/ext/platform_canvas.h" 23 #include "skia/ext/platform_device.h" 24 #include "third_party/WebKit/public/web/WebBindings.h" 25 #include "ui/gfx/blit.h" 26 #include "ui/gfx/canvas.h" 27 28 #if defined(OS_MACOSX) 29 #include "base/mac/mac_util.h" 30 #include "base/mac/scoped_cftyperef.h" 31 #include "content/plugin/webplugin_accelerated_surface_proxy_mac.h" 32 #endif 33 34 #if defined(USE_X11) 35 #include "ui/base/x/x11_util_internal.h" 36 #endif 37 38 #if defined(OS_WIN) 39 #include "content/common/plugin_process_messages.h" 40 #include "content/public/common/sandbox_init.h" 41 #endif 42 43 using WebKit::WebBindings; 44 45 namespace content { 46 47 WebPluginProxy::SharedTransportDIB::SharedTransportDIB(TransportDIB* dib) 48 : dib_(dib) { 49 } 50 51 WebPluginProxy::SharedTransportDIB::~SharedTransportDIB() { 52 } 53 54 WebPluginProxy::WebPluginProxy( 55 PluginChannel* channel, 56 int route_id, 57 const GURL& page_url, 58 int host_render_view_routing_id) 59 : channel_(channel), 60 route_id_(route_id), 61 window_npobject_(NULL), 62 plugin_element_(NULL), 63 delegate_(NULL), 64 waiting_for_paint_(false), 65 page_url_(page_url), 66 windowless_buffer_index_(0), 67 host_render_view_routing_id_(host_render_view_routing_id), 68 weak_factory_(this) { 69 #if defined(USE_X11) 70 windowless_shm_pixmaps_[0] = None; 71 windowless_shm_pixmaps_[1] = None; 72 use_shm_pixmap_ = false; 73 74 // If the X server supports SHM pixmaps 75 // and the color depth and masks match, 76 // then consider using SHM pixmaps for windowless plugin painting. 77 Display* display = ui::GetXDisplay(); 78 if (ui::QuerySharedMemorySupport(display) == ui::SHARED_MEMORY_PIXMAP && 79 ui::BitsPerPixelForPixmapDepth( 80 display, DefaultDepth(display, DefaultScreen(display))) == 32) { 81 Visual* vis = DefaultVisual(display, DefaultScreen(display)); 82 83 if (vis->red_mask == 0xff0000 && 84 vis->green_mask == 0xff00 && 85 vis->blue_mask == 0xff) 86 use_shm_pixmap_ = true; 87 } 88 #endif 89 } 90 91 WebPluginProxy::~WebPluginProxy() { 92 #if defined(USE_X11) 93 if (windowless_shm_pixmaps_[0] != None) 94 XFreePixmap(ui::GetXDisplay(), windowless_shm_pixmaps_[0]); 95 if (windowless_shm_pixmaps_[1] != None) 96 XFreePixmap(ui::GetXDisplay(), windowless_shm_pixmaps_[1]); 97 #endif 98 99 #if defined(OS_MACOSX) 100 // Destroy the surface early, since it may send messages during cleanup. 101 if (accelerated_surface_) 102 accelerated_surface_.reset(); 103 #endif 104 105 if (plugin_element_) 106 WebBindings::releaseObject(plugin_element_); 107 if (window_npobject_) 108 WebBindings::releaseObject(window_npobject_); 109 } 110 111 bool WebPluginProxy::Send(IPC::Message* msg) { 112 return channel_->Send(msg); 113 } 114 115 void WebPluginProxy::SetWindow(gfx::PluginWindowHandle window) { 116 Send(new PluginHostMsg_SetWindow(route_id_, window)); 117 } 118 119 void WebPluginProxy::SetAcceptsInputEvents(bool accepts) { 120 NOTREACHED(); 121 } 122 123 void WebPluginProxy::WillDestroyWindow(gfx::PluginWindowHandle window) { 124 #if defined(OS_WIN) 125 PluginThread::current()->Send( 126 new PluginProcessHostMsg_PluginWindowDestroyed( 127 window, ::GetParent(window))); 128 #elif defined(USE_X11) 129 // Nothing to do. 130 #else 131 NOTIMPLEMENTED(); 132 #endif 133 } 134 135 #if defined(OS_WIN) 136 void WebPluginProxy::SetWindowlessData( 137 HANDLE pump_messages_event, gfx::NativeViewId dummy_activation_window) { 138 HANDLE pump_messages_event_for_renderer = NULL; 139 BrokerDuplicateHandle(pump_messages_event, channel_->peer_pid(), 140 &pump_messages_event_for_renderer, 141 SYNCHRONIZE | EVENT_MODIFY_STATE, 0); 142 DCHECK(pump_messages_event_for_renderer); 143 Send(new PluginHostMsg_SetWindowlessData( 144 route_id_, pump_messages_event_for_renderer, dummy_activation_window)); 145 } 146 #endif 147 148 void WebPluginProxy::CancelResource(unsigned long id) { 149 Send(new PluginHostMsg_CancelResource(route_id_, id)); 150 resource_clients_.erase(id); 151 } 152 153 void WebPluginProxy::Invalidate() { 154 gfx::Rect rect(0, 0, 155 delegate_->GetRect().width(), 156 delegate_->GetRect().height()); 157 InvalidateRect(rect); 158 } 159 160 void WebPluginProxy::InvalidateRect(const gfx::Rect& rect) { 161 #if defined(OS_MACOSX) 162 // If this is a Core Animation plugin, all we need to do is inform the 163 // delegate. 164 if (!windowless_context()) { 165 delegate_->PluginDidInvalidate(); 166 return; 167 } 168 169 // Some plugins will send invalidates larger than their own rect when 170 // offscreen, so constrain invalidates to the plugin rect. 171 gfx::Rect plugin_rect = delegate_->GetRect(); 172 plugin_rect.set_origin(gfx::Point(0, 0)); 173 plugin_rect.Intersect(rect); 174 const gfx::Rect invalidate_rect(plugin_rect); 175 #else 176 const gfx::Rect invalidate_rect(rect); 177 #endif 178 damaged_rect_.Union(invalidate_rect); 179 // Ignore NPN_InvalidateRect calls with empty rects. Also don't send an 180 // invalidate if it's outside the clipping region, since if we did it won't 181 // lead to a paint and we'll be stuck waiting forever for a DidPaint response. 182 // 183 // TODO(piman): There is a race condition here, because this test assumes 184 // that when the paint actually occurs, the clip rect will not have changed. 185 // This is not true because scrolling (or window resize) could occur and be 186 // handled by the renderer before it receives the InvalidateRect message, 187 // changing the clip rect and then not painting. 188 if (damaged_rect_.IsEmpty() || 189 !delegate_->GetClipRect().Intersects(damaged_rect_)) 190 return; 191 192 // Only send a single InvalidateRect message at a time. From DidPaint we 193 // will dispatch an additional InvalidateRect message if necessary. 194 if (!waiting_for_paint_) { 195 waiting_for_paint_ = true; 196 // Invalidates caused by calls to NPN_InvalidateRect/NPN_InvalidateRgn 197 // need to be painted asynchronously as per the NPAPI spec. 198 base::MessageLoop::current()->PostTask( 199 FROM_HERE, 200 base::Bind(&WebPluginProxy::OnPaint, 201 weak_factory_.GetWeakPtr(), 202 damaged_rect_)); 203 damaged_rect_ = gfx::Rect(); 204 } 205 } 206 207 NPObject* WebPluginProxy::GetWindowScriptNPObject() { 208 if (window_npobject_) 209 return window_npobject_; 210 211 int npobject_route_id = channel_->GenerateRouteID(); 212 bool success = false; 213 Send(new PluginHostMsg_GetWindowScriptNPObject( 214 route_id_, npobject_route_id, &success)); 215 if (!success) 216 return NULL; 217 218 // PluginChannel creates a dummy owner identifier for unknown owners, so 219 // use that. 220 NPP owner = channel_->GetExistingNPObjectOwner(MSG_ROUTING_NONE); 221 222 window_npobject_ = NPObjectProxy::Create(channel_.get(), 223 npobject_route_id, 224 host_render_view_routing_id_, 225 page_url_, 226 owner); 227 228 return window_npobject_; 229 } 230 231 NPObject* WebPluginProxy::GetPluginElement() { 232 if (plugin_element_) 233 return plugin_element_; 234 235 int npobject_route_id = channel_->GenerateRouteID(); 236 bool success = false; 237 Send(new PluginHostMsg_GetPluginElement(route_id_, npobject_route_id, 238 &success)); 239 if (!success) 240 return NULL; 241 242 // PluginChannel creates a dummy owner identifier for unknown owners, so 243 // use that. 244 NPP owner = channel_->GetExistingNPObjectOwner(MSG_ROUTING_NONE); 245 246 plugin_element_ = NPObjectProxy::Create(channel_.get(), 247 npobject_route_id, 248 host_render_view_routing_id_, 249 page_url_, 250 owner); 251 252 return plugin_element_; 253 } 254 255 bool WebPluginProxy::FindProxyForUrl(const GURL& url, std::string* proxy_list) { 256 bool result = false; 257 Send(new PluginHostMsg_ResolveProxy(route_id_, url, &result, proxy_list)); 258 return result; 259 } 260 261 void WebPluginProxy::SetCookie(const GURL& url, 262 const GURL& first_party_for_cookies, 263 const std::string& cookie) { 264 Send(new PluginHostMsg_SetCookie(route_id_, url, 265 first_party_for_cookies, cookie)); 266 } 267 268 std::string WebPluginProxy::GetCookies(const GURL& url, 269 const GURL& first_party_for_cookies) { 270 std::string cookies; 271 Send(new PluginHostMsg_GetCookies(route_id_, url, 272 first_party_for_cookies, &cookies)); 273 274 return cookies; 275 } 276 277 WebPluginResourceClient* WebPluginProxy::GetResourceClient(int id) { 278 ResourceClientMap::iterator iterator = resource_clients_.find(id); 279 // The IPC messages which deal with streams are now asynchronous. It is 280 // now possible to receive stream messages from the renderer for streams 281 // which may have been cancelled by the plugin. 282 if (iterator == resource_clients_.end()) { 283 return NULL; 284 } 285 286 return iterator->second; 287 } 288 289 int WebPluginProxy::GetRendererId() { 290 if (channel_.get()) 291 return channel_->renderer_id(); 292 return -1; 293 } 294 295 void WebPluginProxy::DidPaint() { 296 // If we have an accumulated damaged rect, then check to see if we need to 297 // send out another InvalidateRect message. 298 waiting_for_paint_ = false; 299 if (!damaged_rect_.IsEmpty()) 300 InvalidateRect(damaged_rect_); 301 } 302 303 void WebPluginProxy::OnResourceCreated(int resource_id, 304 WebPluginResourceClient* client) { 305 DCHECK(resource_clients_.find(resource_id) == resource_clients_.end()); 306 resource_clients_[resource_id] = client; 307 } 308 309 void WebPluginProxy::HandleURLRequest(const char* url, 310 const char* method, 311 const char* target, 312 const char* buf, 313 unsigned int len, 314 int notify_id, 315 bool popups_allowed, 316 bool notify_redirects) { 317 if (!target && (0 == base::strcasecmp(method, "GET"))) { 318 // Please refer to https://bugzilla.mozilla.org/show_bug.cgi?id=366082 319 // for more details on this. 320 if (delegate_->GetQuirks() & 321 WebPluginDelegateImpl::PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS) { 322 GURL request_url(url); 323 if (!request_url.SchemeIs(chrome::kHttpScheme) && 324 !request_url.SchemeIs(chrome::kHttpsScheme) && 325 !request_url.SchemeIs(chrome::kFtpScheme)) { 326 return; 327 } 328 } 329 } 330 331 PluginHostMsg_URLRequest_Params params; 332 params.url = url; 333 params.method = method; 334 if (target) 335 params.target = std::string(target); 336 337 if (len) { 338 params.buffer.resize(len); 339 memcpy(¶ms.buffer.front(), buf, len); 340 } 341 342 params.notify_id = notify_id; 343 params.popups_allowed = popups_allowed; 344 params.notify_redirects = notify_redirects; 345 346 Send(new PluginHostMsg_URLRequest(route_id_, params)); 347 } 348 349 void WebPluginProxy::Paint(const gfx::Rect& rect) { 350 #if defined(OS_MACOSX) 351 if (!windowless_context()) 352 return; 353 #else 354 if (!windowless_canvas() || !windowless_canvas()->getDevice()) 355 return; 356 #endif 357 358 // Clear the damaged area so that if the plugin doesn't paint there we won't 359 // end up with the old values. 360 gfx::Rect offset_rect = rect; 361 offset_rect.Offset(delegate_->GetRect().OffsetFromOrigin()); 362 #if defined(OS_MACOSX) 363 CGContextSaveGState(windowless_context()); 364 // It is possible for windowless_contexts_ to change during plugin painting 365 // (since the plugin can make a synchronous call during paint event handling), 366 // in which case we don't want to try to restore later. Not an owning ref 367 // since owning the ref without owning the shared backing memory doesn't make 368 // sense, so this should only be used for pointer comparisons. 369 CGContextRef saved_context_weak = windowless_context(); 370 // We also save the buffer index for the comparison because if we flip buffers 371 // but haven't reallocated them then we do need to restore the context because 372 // it is going to continue to be used. 373 int saved_index = windowless_buffer_index_; 374 375 CGContextClipToRect(windowless_context(), rect.ToCGRect()); 376 // TODO(caryclark): This is a temporary workaround to allow the Darwin / Skia 377 // port to share code with the Darwin / CG port. All ports will eventually use 378 // the common code below. 379 delegate_->CGPaint(windowless_context(), rect); 380 if (windowless_contexts_[saved_index].get() == saved_context_weak) 381 CGContextRestoreGState(windowless_contexts_[saved_index]); 382 #else 383 // See above comment about windowless_context_ changing. 384 // http::/crbug.com/139462 385 skia::RefPtr<skia::PlatformCanvas> saved_canvas = windowless_canvas(); 386 #if defined(USE_X11) 387 scoped_refptr<SharedTransportDIB> local_dib_ref( 388 windowless_dibs_[windowless_buffer_index_]); 389 #endif 390 391 saved_canvas->save(); 392 393 // The given clip rect is relative to the plugin coordinate system. 394 SkRect sk_rect = { SkIntToScalar(rect.x()), 395 SkIntToScalar(rect.y()), 396 SkIntToScalar(rect.right()), 397 SkIntToScalar(rect.bottom()) }; 398 saved_canvas->clipRect(sk_rect); 399 400 // Fill a transparent value so that if the plugin supports transparency that 401 // will work. 402 saved_canvas->drawColor(SkColorSetARGB(0, 0, 0, 0), SkXfermode::kSrc_Mode); 403 404 // Bring the windowless canvas into the window coordinate system, which is 405 // how the plugin expects to draw (since the windowless API was originally 406 // designed just for scribbling over the web page). 407 saved_canvas->translate(SkIntToScalar(-delegate_->GetRect().x()), 408 SkIntToScalar(-delegate_->GetRect().y())); 409 410 // Before we send the invalidate, paint so that renderer uses the updated 411 // bitmap. 412 delegate_->Paint(saved_canvas.get(), offset_rect); 413 414 saved_canvas->restore(); 415 #endif 416 } 417 418 void WebPluginProxy::UpdateGeometry( 419 const gfx::Rect& window_rect, 420 const gfx::Rect& clip_rect, 421 const TransportDIB::Handle& windowless_buffer0, 422 const TransportDIB::Handle& windowless_buffer1, 423 int windowless_buffer_index) { 424 gfx::Rect old = delegate_->GetRect(); 425 gfx::Rect old_clip_rect = delegate_->GetClipRect(); 426 427 // Update the buffers before doing anything that could call into plugin code, 428 // so that we don't process buffer changes out of order if plugins make 429 // synchronous calls that lead to nested UpdateGeometry calls. 430 if (TransportDIB::is_valid_handle(windowless_buffer0)) { 431 // The plugin's rect changed, so now we have new buffers to draw into. 432 SetWindowlessBuffers(windowless_buffer0, 433 windowless_buffer1, 434 window_rect); 435 } 436 437 DCHECK(0 <= windowless_buffer_index && windowless_buffer_index <= 1); 438 windowless_buffer_index_ = windowless_buffer_index; 439 #if defined(USE_X11) 440 delegate_->SetWindowlessShmPixmap(windowless_shm_pixmap()); 441 #endif 442 443 #if defined(OS_MACOSX) 444 delegate_->UpdateGeometryAndContext( 445 window_rect, clip_rect, windowless_context()); 446 #else 447 delegate_->UpdateGeometry(window_rect, clip_rect); 448 #endif 449 450 // Send over any pending invalidates which occured when the plugin was 451 // off screen. 452 if (delegate_->IsWindowless() && !clip_rect.IsEmpty() && 453 !damaged_rect_.IsEmpty()) { 454 InvalidateRect(damaged_rect_); 455 } 456 } 457 458 #if defined(OS_WIN) 459 460 void WebPluginProxy::CreateCanvasFromHandle( 461 const TransportDIB::Handle& dib_handle, 462 const gfx::Rect& window_rect, 463 skia::RefPtr<skia::PlatformCanvas>* canvas) { 464 *canvas = skia::AdoptRef( 465 skia::CreatePlatformCanvas(window_rect.width(), 466 window_rect.height(), 467 true, 468 dib_handle, 469 skia::RETURN_NULL_ON_FAILURE)); 470 // The canvas does not own the section so we need to close it now. 471 CloseHandle(dib_handle); 472 } 473 474 void WebPluginProxy::SetWindowlessBuffers( 475 const TransportDIB::Handle& windowless_buffer0, 476 const TransportDIB::Handle& windowless_buffer1, 477 const gfx::Rect& window_rect) { 478 CreateCanvasFromHandle(windowless_buffer0, 479 window_rect, 480 &windowless_canvases_[0]); 481 if (!windowless_canvases_[0]) { 482 windowless_canvases_[1].clear(); 483 return; 484 } 485 CreateCanvasFromHandle(windowless_buffer1, 486 window_rect, 487 &windowless_canvases_[1]); 488 if (!windowless_canvases_[1]) { 489 windowless_canvases_[0].clear(); 490 return; 491 } 492 } 493 494 #elif defined(OS_MACOSX) 495 496 void WebPluginProxy::CreateDIBAndCGContextFromHandle( 497 const TransportDIB::Handle& dib_handle, 498 const gfx::Rect& window_rect, 499 scoped_ptr<TransportDIB>* dib_out, 500 base::ScopedCFTypeRef<CGContextRef>* cg_context_out) { 501 // Convert the shared memory handle to a handle that works in our process, 502 // and then use that to create a CGContextRef. 503 TransportDIB* dib = TransportDIB::Map(dib_handle); 504 CGContextRef cg_context = NULL; 505 if (dib) { 506 cg_context = CGBitmapContextCreate( 507 dib->memory(), 508 window_rect.width(), 509 window_rect.height(), 510 8, 511 4 * window_rect.width(), 512 base::mac::GetSystemColorSpace(), 513 kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host); 514 CGContextTranslateCTM(cg_context, 0, window_rect.height()); 515 CGContextScaleCTM(cg_context, 1, -1); 516 } 517 dib_out->reset(dib); 518 cg_context_out->reset(cg_context); 519 } 520 521 void WebPluginProxy::SetWindowlessBuffers( 522 const TransportDIB::Handle& windowless_buffer0, 523 const TransportDIB::Handle& windowless_buffer1, 524 const gfx::Rect& window_rect) { 525 CreateDIBAndCGContextFromHandle(windowless_buffer0, 526 window_rect, 527 &windowless_dibs_[0], 528 &windowless_contexts_[0]); 529 CreateDIBAndCGContextFromHandle(windowless_buffer1, 530 window_rect, 531 &windowless_dibs_[1], 532 &windowless_contexts_[1]); 533 } 534 535 #elif defined(TOOLKIT_GTK) 536 537 void WebPluginProxy::CreateDIBAndCanvasFromHandle( 538 const TransportDIB::Handle& dib_handle, 539 const gfx::Rect& window_rect, 540 scoped_refptr<SharedTransportDIB>* dib_out, 541 skia::RefPtr<skia::PlatformCanvas>* canvas) { 542 TransportDIB* dib = TransportDIB::Map(dib_handle); 543 // dib may be NULL if the renderer has already destroyed the TransportDIB by 544 // the time we receive the handle, e.g. in case of multiple resizes. 545 if (dib) { 546 *canvas = skia::AdoptRef( 547 dib->GetPlatformCanvas(window_rect.width(), window_rect.height())); 548 } else { 549 canvas->clear(); 550 } 551 *dib_out = new SharedTransportDIB(dib); 552 } 553 554 void WebPluginProxy::CreateShmPixmapFromDIB( 555 TransportDIB* dib, 556 const gfx::Rect& window_rect, 557 XID* pixmap_out) { 558 if (dib) { 559 Display* display = ui::GetXDisplay(); 560 XID root_window = ui::GetX11RootWindow(); 561 XShmSegmentInfo shminfo = {0}; 562 563 if (*pixmap_out != None) 564 XFreePixmap(display, *pixmap_out); 565 566 shminfo.shmseg = dib->MapToX(display); 567 // Create a shared memory pixmap based on the image buffer. 568 *pixmap_out = XShmCreatePixmap(display, root_window, 569 NULL, &shminfo, 570 window_rect.width(), window_rect.height(), 571 DefaultDepth(display, 572 DefaultScreen(display))); 573 } 574 } 575 576 void WebPluginProxy::SetWindowlessBuffers( 577 const TransportDIB::Handle& windowless_buffer0, 578 const TransportDIB::Handle& windowless_buffer1, 579 const gfx::Rect& window_rect) { 580 CreateDIBAndCanvasFromHandle(windowless_buffer0, 581 window_rect, 582 &windowless_dibs_[0], 583 &windowless_canvases_[0]); 584 CreateDIBAndCanvasFromHandle(windowless_buffer1, 585 window_rect, 586 &windowless_dibs_[1], 587 &windowless_canvases_[1]); 588 589 // If SHM pixmaps support is available, create SHM pixmaps to pass to the 590 // delegate for windowless plugin painting. 591 if (delegate_->IsWindowless() && use_shm_pixmap_) { 592 CreateShmPixmapFromDIB(windowless_dibs_[0]->dib(), 593 window_rect, 594 &windowless_shm_pixmaps_[0]); 595 CreateShmPixmapFromDIB(windowless_dibs_[1]->dib(), 596 window_rect, 597 &windowless_shm_pixmaps_[1]); 598 } 599 } 600 601 #else 602 603 void WebPluginProxy::SetWindowlessBuffers( 604 const TransportDIB::Handle& windowless_buffer0, 605 const TransportDIB::Handle& windowless_buffer1, 606 const gfx::Rect& window_rect) { 607 NOTIMPLEMENTED(); 608 } 609 610 #endif 611 612 void WebPluginProxy::CancelDocumentLoad() { 613 Send(new PluginHostMsg_CancelDocumentLoad(route_id_)); 614 } 615 616 void WebPluginProxy::InitiateHTTPRangeRequest( 617 const char* url, const char* range_info, int range_request_id) { 618 Send(new PluginHostMsg_InitiateHTTPRangeRequest( 619 route_id_, url, range_info, range_request_id)); 620 } 621 622 void WebPluginProxy::SetDeferResourceLoading(unsigned long resource_id, 623 bool defer) { 624 Send(new PluginHostMsg_DeferResourceLoading(route_id_, resource_id, defer)); 625 } 626 627 #if defined(OS_MACOSX) 628 void WebPluginProxy::FocusChanged(bool focused) { 629 IPC::Message* msg = new PluginHostMsg_FocusChanged(route_id_, focused); 630 Send(msg); 631 } 632 633 void WebPluginProxy::StartIme() { 634 IPC::Message* msg = new PluginHostMsg_StartIme(route_id_); 635 // This message can be sent during event-handling, and needs to be delivered 636 // within that context. 637 msg->set_unblock(true); 638 Send(msg); 639 } 640 641 WebPluginAcceleratedSurface* WebPluginProxy::GetAcceleratedSurface( 642 gfx::GpuPreference gpu_preference) { 643 if (!accelerated_surface_) 644 accelerated_surface_.reset( 645 WebPluginAcceleratedSurfaceProxy::Create(this, gpu_preference)); 646 return accelerated_surface_.get(); 647 } 648 649 void WebPluginProxy::AcceleratedPluginEnabledRendering() { 650 Send(new PluginHostMsg_AcceleratedPluginEnabledRendering(route_id_)); 651 } 652 653 void WebPluginProxy::AcceleratedPluginAllocatedIOSurface(int32 width, 654 int32 height, 655 uint32 surface_id) { 656 Send(new PluginHostMsg_AcceleratedPluginAllocatedIOSurface( 657 route_id_, width, height, surface_id)); 658 } 659 660 void WebPluginProxy::AcceleratedPluginSwappedIOSurface() { 661 Send(new PluginHostMsg_AcceleratedPluginSwappedIOSurface( 662 route_id_)); 663 } 664 #endif 665 666 void WebPluginProxy::OnPaint(const gfx::Rect& damaged_rect) { 667 GetContentClient()->SetActiveURL(page_url_); 668 669 Paint(damaged_rect); 670 Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect)); 671 } 672 673 bool WebPluginProxy::IsOffTheRecord() { 674 return channel_->incognito(); 675 } 676 677 void WebPluginProxy::ResourceClientDeleted( 678 WebPluginResourceClient* resource_client) { 679 ResourceClientMap::iterator index = resource_clients_.begin(); 680 while (index != resource_clients_.end()) { 681 WebPluginResourceClient* client = (*index).second; 682 683 if (client == resource_client) { 684 resource_clients_.erase(index++); 685 } else { 686 index++; 687 } 688 } 689 } 690 691 void WebPluginProxy::URLRedirectResponse(bool allow, int resource_id) { 692 Send(new PluginHostMsg_URLRedirectResponse(route_id_, allow, resource_id)); 693 } 694 695 #if defined(OS_WIN) && !defined(USE_AURA) 696 void WebPluginProxy::UpdateIMEStatus() { 697 // Retrieve the IME status from a plug-in and send it to a renderer process 698 // when the plug-in has updated it. 699 int input_type; 700 gfx::Rect caret_rect; 701 if (!delegate_->GetIMEStatus(&input_type, &caret_rect)) 702 return; 703 704 Send(new PluginHostMsg_NotifyIMEStatus(route_id_, input_type, caret_rect)); 705 } 706 #endif 707 708 } // namespace content 709